diff --git a/.github/workflows/update-version-number.yaml b/.github/workflows/update-version-number.yaml
index 94859c2..8e52094 100644
--- a/.github/workflows/update-version-number.yaml
+++ b/.github/workflows/update-version-number.yaml
@@ -72,7 +72,7 @@ jobs:
 
       - name: Update Directory.Build.props  ${{ steps.configure.outputs.git-tag }}
         run: |
-          ruby -i -pe 'gsub(%r{(<PackageVersion>)[\d\.]+(</PackageVersion>)}, %q{\1${{ steps.configure.outputs.git-tag }}\2})' Directory.Build.props
+          ruby -i -pe 'gsub(%r{(<PackageVersion>)([\d\.]+)(</PackageVersion>)}, %q{\1${{ steps.configure.outputs.git-tag }}\3})' Directory.Build.props
 
       - name: Update README.md  ${{ steps.configure.outputs.git-tag }}
         run: |
diff --git a/VYaml.Tests/Emitter/Utf8YamlEmitterTest.cs b/VYaml.Tests/Emitter/Utf8YamlEmitterTest.cs
index f707f0e..522fc1b 100644
--- a/VYaml.Tests/Emitter/Utf8YamlEmitterTest.cs
+++ b/VYaml.Tests/Emitter/Utf8YamlEmitterTest.cs
@@ -356,6 +356,113 @@ public void BlockSequence_Nested1()
             ));
         }
 
+        [Test]
+        public void BlockSequence_Nested2()
+        {
+            var emitter = CreateEmitter();
+            emitter.BeginMapping(MappingStyle.Block);
+            {
+                emitter.WriteString("matrix");
+                emitter.BeginSequence(SequenceStyle.Block);
+                {
+                    emitter.BeginSequence(SequenceStyle.Flow);
+                    {
+                        emitter.WriteInt32(100);
+                        emitter.WriteInt32(200);
+                    }
+                    emitter.EndSequence();
+
+                    emitter.BeginSequence(SequenceStyle.Flow);
+                    {
+                        emitter.WriteInt32(300);
+                        emitter.WriteInt32(400);
+                    }
+                    emitter.EndSequence();
+                }
+                emitter.EndSequence();
+            }
+            emitter.EndMapping();
+
+            Assert.That(ToString(in emitter), Is.EqualTo(
+                "matrix: \n" +
+                "- [100, 200]\n" +
+                "- [300, 400]\n"
+            ));
+        }
+
+        [Test]
+        public void BlockSequence_Nested3()
+        {
+            var emitter = CreateEmitter();
+            emitter.BeginMapping(MappingStyle.Block);
+            {
+                emitter.WriteString("key1");
+                emitter.BeginMapping(MappingStyle.Block);
+                {
+                    emitter.WriteString("matrix");
+                    emitter.BeginSequence(SequenceStyle.Block);
+                    {
+                        emitter.BeginSequence(SequenceStyle.Flow);
+                        {
+                            emitter.WriteInt32(100);
+                            emitter.WriteInt32(200);
+                        }
+                        emitter.EndSequence();
+
+                        emitter.BeginSequence(SequenceStyle.Flow);
+                        {
+                            emitter.WriteInt32(300);
+                            emitter.WriteInt32(400);
+                        }
+                        emitter.EndSequence();
+                    }
+                    emitter.EndSequence();
+                }
+                emitter.EndMapping();
+            }
+            emitter.EndMapping();
+
+            Assert.That(ToString(in emitter), Is.EqualTo(
+                "key1: \n" +
+                "  matrix: \n" +
+                "  - [100, 200]\n" +
+                "  - [300, 400]\n"
+            ));
+        }
+
+        [Test]
+        public void BlockSequence_Nested4()
+        {
+            var emitter = CreateEmitter();
+            emitter.BeginSequence(SequenceStyle.Block);
+            {
+                emitter.BeginSequence(SequenceStyle.Block);
+                {
+                    emitter.BeginSequence(SequenceStyle.Flow);
+                    {
+                        emitter.WriteInt32(100);
+                        emitter.WriteInt32(200);
+                    }
+                    emitter.EndSequence();
+
+                    emitter.BeginSequence(SequenceStyle.Flow);
+                    {
+                        emitter.WriteInt32(300);
+                        emitter.WriteInt32(400);
+                    }
+                    emitter.EndSequence();
+                }
+                emitter.EndSequence();
+            }
+            emitter.EndSequence();
+
+            Assert.That(ToString(in emitter), Is.EqualTo(
+                "- \n" +
+                "  - [100, 200]\n" +
+                "  - [300, 400]\n"
+            ));
+        }
+
         [Test]
         public void BlockSequence_NestedDeeply()
         {
diff --git a/VYaml.Unity/Assets/Tests/Emitter/Utf8YamlEmitterTest.cs b/VYaml.Unity/Assets/Tests/Emitter/Utf8YamlEmitterTest.cs
index f707f0e..522fc1b 100644
--- a/VYaml.Unity/Assets/Tests/Emitter/Utf8YamlEmitterTest.cs
+++ b/VYaml.Unity/Assets/Tests/Emitter/Utf8YamlEmitterTest.cs
@@ -356,6 +356,113 @@ public void BlockSequence_Nested1()
             ));
         }
 
+        [Test]
+        public void BlockSequence_Nested2()
+        {
+            var emitter = CreateEmitter();
+            emitter.BeginMapping(MappingStyle.Block);
+            {
+                emitter.WriteString("matrix");
+                emitter.BeginSequence(SequenceStyle.Block);
+                {
+                    emitter.BeginSequence(SequenceStyle.Flow);
+                    {
+                        emitter.WriteInt32(100);
+                        emitter.WriteInt32(200);
+                    }
+                    emitter.EndSequence();
+
+                    emitter.BeginSequence(SequenceStyle.Flow);
+                    {
+                        emitter.WriteInt32(300);
+                        emitter.WriteInt32(400);
+                    }
+                    emitter.EndSequence();
+                }
+                emitter.EndSequence();
+            }
+            emitter.EndMapping();
+
+            Assert.That(ToString(in emitter), Is.EqualTo(
+                "matrix: \n" +
+                "- [100, 200]\n" +
+                "- [300, 400]\n"
+            ));
+        }
+
+        [Test]
+        public void BlockSequence_Nested3()
+        {
+            var emitter = CreateEmitter();
+            emitter.BeginMapping(MappingStyle.Block);
+            {
+                emitter.WriteString("key1");
+                emitter.BeginMapping(MappingStyle.Block);
+                {
+                    emitter.WriteString("matrix");
+                    emitter.BeginSequence(SequenceStyle.Block);
+                    {
+                        emitter.BeginSequence(SequenceStyle.Flow);
+                        {
+                            emitter.WriteInt32(100);
+                            emitter.WriteInt32(200);
+                        }
+                        emitter.EndSequence();
+
+                        emitter.BeginSequence(SequenceStyle.Flow);
+                        {
+                            emitter.WriteInt32(300);
+                            emitter.WriteInt32(400);
+                        }
+                        emitter.EndSequence();
+                    }
+                    emitter.EndSequence();
+                }
+                emitter.EndMapping();
+            }
+            emitter.EndMapping();
+
+            Assert.That(ToString(in emitter), Is.EqualTo(
+                "key1: \n" +
+                "  matrix: \n" +
+                "  - [100, 200]\n" +
+                "  - [300, 400]\n"
+            ));
+        }
+
+        [Test]
+        public void BlockSequence_Nested4()
+        {
+            var emitter = CreateEmitter();
+            emitter.BeginSequence(SequenceStyle.Block);
+            {
+                emitter.BeginSequence(SequenceStyle.Block);
+                {
+                    emitter.BeginSequence(SequenceStyle.Flow);
+                    {
+                        emitter.WriteInt32(100);
+                        emitter.WriteInt32(200);
+                    }
+                    emitter.EndSequence();
+
+                    emitter.BeginSequence(SequenceStyle.Flow);
+                    {
+                        emitter.WriteInt32(300);
+                        emitter.WriteInt32(400);
+                    }
+                    emitter.EndSequence();
+                }
+                emitter.EndSequence();
+            }
+            emitter.EndSequence();
+
+            Assert.That(ToString(in emitter), Is.EqualTo(
+                "- \n" +
+                "  - [100, 200]\n" +
+                "  - [300, 400]\n"
+            ));
+        }
+
         [Test]
         public void BlockSequence_NestedDeeply()
         {
diff --git a/VYaml.Unity/Assets/VYaml/Runtime/Emitter/Utf8YamlEmitter.cs b/VYaml.Unity/Assets/VYaml/Runtime/Emitter/Utf8YamlEmitter.cs
index e3392e4..e4484b0 100644
--- a/VYaml.Unity/Assets/VYaml/Runtime/Emitter/Utf8YamlEmitter.cs
+++ b/VYaml.Unity/Assets/VYaml/Runtime/Emitter/Utf8YamlEmitter.cs
@@ -142,9 +142,7 @@ public void BeginSequence(SequenceStyle style = SequenceStyle.Block)
                         {
                             var output = writer.GetSpan(currentIndentLevel * options.IndentWidth + BlockSequenceEntryHeader.Length + 1);
                             var offset = 0;
-                            WriteIndent(output, ref offset);
-                            BlockSequenceEntryHeader.CopyTo(output[offset..]);
-                            offset += BlockSequenceEntryHeader.Length;
+                            WriteBlockSequenceEntryHeader(output, ref offset);
                             output[offset++] = YamlCodes.FlowSequenceStart;
                             writer.Advance(offset);
                             break;
@@ -299,9 +297,7 @@ public void BeginMapping(MappingStyle style = MappingStyle.Block)
                         {
                             var output = writer.GetSpan(currentIndentLevel * options.IndentWidth + BlockSequenceEntryHeader.Length + FlowMappingHeader.Length + GetTagLength() + 1);
                             var offset = 0;
-                            WriteIndent(output, ref offset);
-                            BlockSequenceEntryHeader.CopyTo(output[offset..]);
-                            offset += BlockSequenceEntryHeader.Length;
+                            WriteBlockSequenceEntryHeader(output, ref offset);
                             if (TryWriteTag(output, ref offset))
                             {
                                 output[offset++] = YamlCodes.Space;
@@ -698,21 +694,32 @@ void WriteRaw1(byte value)
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         void WriteBlockSequenceEntryHeader()
+        {
+            var output = writer.GetSpan(BlockSequenceEntryHeader.Length + currentIndentLevel * options.IndentWidth + 2);
+            var offset = 0;
+            WriteBlockSequenceEntryHeader(output, ref offset);
+            writer.Advance(offset);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        void WriteBlockSequenceEntryHeader(Span<byte> output, ref int offset)
         {
             if (IsFirstElement)
             {
                 switch (PreviousState)
                 {
                     case EmitState.BlockSequenceEntry:
-                        WriteRaw1(YamlCodes.Lf);
+                        output[offset++] = YamlCodes.Lf;
                         IncreaseIndent();
                         break;
                     case EmitState.BlockMappingValue:
-                        WriteRaw1(YamlCodes.Lf);
+                        output[offset++] = YamlCodes.Lf;
                         break;
                 }
             }
-            WriteRaw(BlockSequenceEntryHeader, true, false);
+            WriteIndent(output, ref offset);
+            BlockSequenceEntryHeader.CopyTo(output[offset..]);
+            offset += BlockSequenceEntryHeader.Length;
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -751,23 +758,7 @@ void BeginScalar(Span<byte> output, ref int offset)
             {
                 case EmitState.BlockSequenceEntry:
                 {
-                    // first nested element
-                    if (IsFirstElement)
-                    {
-                        switch (PreviousState)
-                        {
-                            case EmitState.BlockSequenceEntry:
-                                IncreaseIndent();
-                                output[offset++] = YamlCodes.Lf;
-                                break;
-                            case EmitState.BlockMappingValue:
-                                output[offset++] = YamlCodes.Lf;
-                                break;
-                        }
-                    }
-                    WriteIndent(output, ref offset);
-                    BlockSequenceEntryHeader.CopyTo(output[offset..]);
-                    offset += BlockSequenceEntryHeader.Length;
+                    WriteBlockSequenceEntryHeader(output, ref offset);
 
                     if (TryWriteTag(output, ref offset))
                     {
diff --git a/VYaml/Emitter/Utf8YamlEmitter.cs b/VYaml/Emitter/Utf8YamlEmitter.cs
index e3392e4..e4484b0 100644
--- a/VYaml/Emitter/Utf8YamlEmitter.cs
+++ b/VYaml/Emitter/Utf8YamlEmitter.cs
@@ -142,9 +142,7 @@ public void BeginSequence(SequenceStyle style = SequenceStyle.Block)
                         {
                             var output = writer.GetSpan(currentIndentLevel * options.IndentWidth + BlockSequenceEntryHeader.Length + 1);
                             var offset = 0;
-                            WriteIndent(output, ref offset);
-                            BlockSequenceEntryHeader.CopyTo(output[offset..]);
-                            offset += BlockSequenceEntryHeader.Length;
+                            WriteBlockSequenceEntryHeader(output, ref offset);
                             output[offset++] = YamlCodes.FlowSequenceStart;
                             writer.Advance(offset);
                             break;
@@ -299,9 +297,7 @@ public void BeginMapping(MappingStyle style = MappingStyle.Block)
                         {
                             var output = writer.GetSpan(currentIndentLevel * options.IndentWidth + BlockSequenceEntryHeader.Length + FlowMappingHeader.Length + GetTagLength() + 1);
                             var offset = 0;
-                            WriteIndent(output, ref offset);
-                            BlockSequenceEntryHeader.CopyTo(output[offset..]);
-                            offset += BlockSequenceEntryHeader.Length;
+                            WriteBlockSequenceEntryHeader(output, ref offset);
                             if (TryWriteTag(output, ref offset))
                             {
                                 output[offset++] = YamlCodes.Space;
@@ -698,21 +694,32 @@ void WriteRaw1(byte value)
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         void WriteBlockSequenceEntryHeader()
+        {
+            var output = writer.GetSpan(BlockSequenceEntryHeader.Length + currentIndentLevel * options.IndentWidth + 2);
+            var offset = 0;
+            WriteBlockSequenceEntryHeader(output, ref offset);
+            writer.Advance(offset);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        void WriteBlockSequenceEntryHeader(Span<byte> output, ref int offset)
         {
             if (IsFirstElement)
             {
                 switch (PreviousState)
                 {
                     case EmitState.BlockSequenceEntry:
-                        WriteRaw1(YamlCodes.Lf);
+                        output[offset++] = YamlCodes.Lf;
                         IncreaseIndent();
                         break;
                     case EmitState.BlockMappingValue:
-                        WriteRaw1(YamlCodes.Lf);
+                        output[offset++] = YamlCodes.Lf;
                         break;
                 }
             }
-            WriteRaw(BlockSequenceEntryHeader, true, false);
+            WriteIndent(output, ref offset);
+            BlockSequenceEntryHeader.CopyTo(output[offset..]);
+            offset += BlockSequenceEntryHeader.Length;
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -751,23 +758,7 @@ void BeginScalar(Span<byte> output, ref int offset)
             {
                 case EmitState.BlockSequenceEntry:
                 {
-                    // first nested element
-                    if (IsFirstElement)
-                    {
-                        switch (PreviousState)
-                        {
-                            case EmitState.BlockSequenceEntry:
-                                IncreaseIndent();
-                                output[offset++] = YamlCodes.Lf;
-                                break;
-                            case EmitState.BlockMappingValue:
-                                output[offset++] = YamlCodes.Lf;
-                                break;
-                        }
-                    }
-                    WriteIndent(output, ref offset);
-                    BlockSequenceEntryHeader.CopyTo(output[offset..]);
-                    offset += BlockSequenceEntryHeader.Length;
+                    WriteBlockSequenceEntryHeader(output, ref offset);
 
                     if (TryWriteTag(output, ref offset))
                     {