Release 0.4.9.7

Library fixes

KKdBaseLib/F2/ENRS.cs

@@ -24,12 +24,10 @@ namespace KKdBaseLib.F2
                 for (i = 0; i < ENRSCount; i++)
                 {
                     enrsEntry = default;
-                    enrsEntry.Offset = ReadENRSValue(ref localPtr);
-                    enrsEntry.Count  = ReadENRSValue(ref localPtr);
-                    enrsEntry.Size   = ReadENRSValue(ref localPtr);
-                    enrsEntry.Repeat = ReadENRSValue(ref localPtr);
-
-                    if (i > 0) enrsEntry.Offset += Array[i - 1].Offset;
+                    if (ReadENRSValue(ref localPtr, out enrsEntry.Offset)) return;
+                    if (ReadENRSValue(ref localPtr, out enrsEntry.Count )) return;
+                    if (ReadENRSValue(ref localPtr, out enrsEntry.Size  )) return;
+                    if (ReadENRSValue(ref localPtr, out enrsEntry.Repeat)) return;
 
                     if (enrsEntry.Repeat < 1) { enrsEntry.Sub = null; Array[i] = enrsEntry; continue; }
 
@@ -37,9 +35,8 @@ namespace KKdBaseLib.F2
                     for (i0 = 0; i0 < enrsEntry.Count; i0++)
                     {
                         sub = default;
-                        sub.Skip    = ReadENRSValue(ref localPtr, out sub.Type);
-                        sub.Reverse = ReadENRSValue(ref localPtr);
-                        if (i0 > 0) sub.Skip += enrsEntry.Sub[i0 - 1].SizeSkip;
+                        if (ReadENRSValue(ref localPtr, out sub.Skip, out sub.Type)) return;
+                        if (ReadENRSValue(ref localPtr, out sub.Reverse           )) return;
                         enrsEntry.Sub[i0] = sub;
 
                         if (enrsEntry.Sub[i0].Type == ENRSEntry.Type.Invalid) { Array = null; return; }
@@ -65,27 +62,24 @@ namespace KKdBaseLib.F2
                 for (i = 0; i < Array.Length; i++)
                 {
                     ENRSEntry enrsEntry = Array[i];
-                    WriteENRSValue(ref localPtr, i > 0 ? enrsEntry.Offset -
-                        Array[i - 1].Offset : enrsEntry.Offset);
-                    WriteENRSValue(ref localPtr, enrsEntry.Count > enrsEntry.Sub.Length ?
-                        enrsEntry.Sub.Length : enrsEntry.Count);
-                    WriteENRSValue(ref localPtr, enrsEntry.Size  );
-                    WriteENRSValue(ref localPtr, enrsEntry.Repeat);
+                    if (WriteENRSValue(ref localPtr, enrsEntry.Offset)) goto End;
+                    if (WriteENRSValue(ref localPtr, enrsEntry.Count )) goto End;
+                    if (WriteENRSValue(ref localPtr, enrsEntry.Size  )) goto End;
+                    if (WriteENRSValue(ref localPtr, enrsEntry.Repeat)) goto End;
 
                     if (enrsEntry.Repeat < 1) continue;
 
                     for (i0 = 0; i0 < enrsEntry.Count && i0 < enrsEntry.Sub.Length; i0++)
                     {
-                        if (enrsEntry.Sub[i0].Type < ENRSEntry.Type. WORD ||
-                            enrsEntry.Sub[i0].Type > ENRSEntry.Type.QWORD)
+                        if (enrsEntry.Sub[i0].Type > ENRSEntry.Type.QWORD)
                             return data;
 
-                        WriteENRSValue(ref localPtr, i0 > 0 ? enrsEntry.Sub[i0].Skip -
-                            enrsEntry.Sub[i0 - 1].SizeSkip : enrsEntry.Sub[i0].Skip, enrsEntry.Sub[i0].Type);
-                        WriteENRSValue(ref localPtr, enrsEntry.Sub[i0].Reverse);
+                        if (WriteENRSValue(ref localPtr, enrsEntry.Sub[i0].Skip, enrsEntry.Sub[i0].Type)) goto End;
+                        if (WriteENRSValue(ref localPtr, enrsEntry.Sub[i0].Reverse                     )) goto End;
                     }
                 }
             }
+        End:
             return data;
         }
 
@@ -96,10 +90,10 @@ namespace KKdBaseLib.F2
             for (i = 0; i < Array.Length; i++)
             {
                 ENRSEntry enrs = Array[i];
-                length += GetSize(i > 0 ? enrs.Offset - Array[i - 1].Offset : enrs.Offset);
-                length += GetSize(enrs.Count );
-                length += GetSize(enrs.Size  );
-                length += GetSize(enrs.Repeat);
+                if (GetSize(enrs.Offset, ref length)) goto End;
+                if (GetSize(enrs.Count , ref length)) goto End;
+                if (GetSize(enrs.Size  , ref length)) goto End;
+                if (GetSize(enrs.Repeat, ref length)) goto End;
 
                 if (enrs.Repeat < 1) continue;
 
@@ -108,15 +102,24 @@ namespace KKdBaseLib.F2
                     if (enrs.Sub[i0].Type < ENRSEntry.Type. WORD ||
                         enrs.Sub[i0].Type > ENRSEntry.Type.QWORD) return length.A(0x10);
 
-                    length += GetSizeType(i0 > 0 ? enrs.Sub[i0].Skip -
-                        enrs.Sub[i0 - 1].SizeSkip : enrs.Sub[i0].Skip);
-                    length += GetSize(enrs.Sub[i0].Reverse);
+                    if (GetSizeType(enrs.Sub[i0].Skip   , ref length)) goto End;
+                    if (GetSize    (enrs.Sub[i0].Reverse, ref length)) goto End;
                 }
             }
+        End:
             return length.A(0x10);
 
-            static int GetSizeType(int val) => val < 0x00000010 ? 1 : val < 0x00001000 ? 2 : 4;
-            static int GetSize    (int val) => val < 0x00000040 ? 1 : val < 0x00004000 ? 2 : 4;
+            static bool GetSizeType(int val, ref int length)
+            {
+                length += val <  0x00000010 ? 1 : val < 0x00001000 ? 2 : val < 0x10000000 ? 4 : 1;
+                return    val >= 0x10000000;
+            }
+
+            static bool GetSize    (int val, ref int length)
+            {
+                length += val <  0x00000040 ? 1 : val < 0x00004000 ? 2 : val < 0x40000000 ? 4 : 1;
+                return    val >= 0x40000000;
+            }
         }
 
         /*private static KKdList<ENRS.SubENRS> Optimize(KKdList<ENRS.SubENRS> Sub)
@@ -138,73 +141,76 @@ namespace KKdBaseLib.F2
 
         [System.ThreadStatic] private static ENRSEntry.Value value;
 
-        private unsafe static int ReadENRSValue(ref byte* ptr, out ENRSEntry.Type type)
+        private unsafe static bool ReadENRSValue(ref byte* ptr, out int v, out ENRSEntry.Type type)
         {
-            int V = *ptr & 0xF;
+            v = *ptr & 0xF;
              type = (ENRSEntry. Type)((*ptr & 0x30) >> 4);
             value = (ENRSEntry.Value)((*ptr & 0xC0) >> 6);
             ptr++;
-                 if (value == ENRSEntry.Value.Int32  )
-            { V = (V << 24) | (ptr[0] << 16) | (ptr[1] << 8) | ptr[2]; ptr += 3; }
-            else if (value == ENRSEntry.Value.Int16  )
-            { V = (V <<  8) |  ptr[0];                                 ptr += 1; }
-            else if (value == ENRSEntry.Value.Invalid) V = 0;
-            return V;
+                 if (value == ENRSEntry.Value.Int32  ) v = (((((v << 8) | *ptr++) << 8) | *ptr++) << 8) | *ptr++;
+            else if (value == ENRSEntry.Value.Int16  ) v =     (v << 8) | *ptr++; 
+            else if (value == ENRSEntry.Value.Invalid) { v = 0; return true; }
+            return false;
         }
 
-        private unsafe static int ReadENRSValue(ref byte* ptr)
+        private unsafe static bool ReadENRSValue(ref byte* ptr, out int v)
         {
-            int V = *ptr & 0x3F;
+            v = *ptr & 0x3F;
             value = (ENRSEntry.Value)((*ptr & 0xC0) >> 6);
             ptr++;
-                 if (value == ENRSEntry.Value.Int32  )
-            { V = (V << 24) | (ptr[0] << 16) | (ptr[1] << 8) | ptr[2]; ptr += 3; }
-            else if (value == ENRSEntry.Value.Int16  )
-            { V = (V <<  8) |  ptr[0];                                 ptr += 1; }
-            else if (value == ENRSEntry.Value.Invalid) V = 0;
-            return V;
+                 if (value == ENRSEntry.Value.Int32  ) v = (((((v << 8) | *ptr++) << 8) | *ptr++) << 8) | *ptr++;
+            else if (value == ENRSEntry.Value.Int16  ) v =     (v << 8) | *ptr++; 
+            else if (value == ENRSEntry.Value.Invalid) { v = 0; return true; }
+            return false;
         }
 
-        private unsafe static void WriteENRSValue(ref byte* ptr, int val, ENRSEntry.Type type)
+        private unsafe static bool WriteENRSValue(ref byte* ptr, int val, ENRSEntry.Type type)
         {
-            value = ENRSEntry.Value.Invalid;
-                 if (val < 0x00000040) value = ENRSEntry.Value.Int8 ;
-            else if (val < 0x00004000) value = ENRSEntry.Value.Int16;
-            else if (val < 0x40000000) value = ENRSEntry.Value.Int32;
-            *ptr = (byte)((((byte)value << 6) & 0xC0) | (((byte)type << 4) & 0x30));
-
-                 if (val < 0x00000010)
-            { *ptr |= (byte)( val        & 0x0F); }
+            byte t = (byte)(((byte)type & 0x3) << 4);
+            if (val < 0x00000010)
+                *ptr++ = (byte)(((byte)ENRSEntry.Value.Int8  << 6) | t | ( val        & 0xF));
             else if (val < 0x00001000)
-            { *ptr |= (byte)((val >>  8) & 0x0F); ptr++;
-              *ptr  = (byte)( val        & 0xFF); }
+            {
+                *ptr++ = (byte)(((byte)ENRSEntry.Value.Int16 << 6) | t | ((val >>  8) & 0xF));
+                *ptr++ = (byte)(val & 0xFF);
+            }
             else if (val < 0x10000000)
-            { *ptr |= (byte)((val >> 24) & 0x0F); ptr++;
-              *ptr  = (byte)((val >> 16) & 0xFF); ptr++;
-              *ptr  = (byte)((val >>  8) & 0xFF); ptr++;
-              *ptr  = (byte)( val        & 0xFF); }
-            ptr++;
+            {
+                *ptr++ = (byte)(((byte)ENRSEntry.Value.Int32 << 6) | t | ((val >> 24) & 0xF));
+                *ptr++ = (byte)((val >> 16) & 0xFF);
+                *ptr++ = (byte)((val >>  8) & 0xFF);
+                *ptr++ = (byte)( val        & 0xFF);
+            }
+            else
+            {
+                *ptr++ = (byte)ENRSEntry.Value.Invalid << 6;
+                return true;
+            }
+            return false;
         }
 
-        private unsafe static void WriteENRSValue(ref byte* ptr, int val)
+        private unsafe static bool WriteENRSValue(ref byte* ptr, int val)
         {
-            value = ENRSEntry.Value.Invalid;
-                 if (val < 0x00000040) value = ENRSEntry.Value.Int8 ;
-            else if (val < 0x00004000) value = ENRSEntry.Value.Int16;
-            else if (val < 0x40000000) value = ENRSEntry.Value.Int32;
-            *ptr = (byte)(((byte)value << 6) & 0xC0);
-
-                 if (val < 0x00000040)
-            { *ptr |= (byte)( val        & 0x3F); }
+            if (val < 0x00000040)
+                *ptr++ = (byte)(((byte)ENRSEntry.Value.Int8  << 6) | ( val        & 0x3F));
             else if (val < 0x00004000)
-            { *ptr |= (byte)((val >>  8) & 0x3F); ptr++;
-              *ptr  = (byte)( val        & 0xFF); }
+            {
+                *ptr++ = (byte)(((byte)ENRSEntry.Value.Int16 << 6) | ((val >>  8) & 0x3F));
+                *ptr++ = (byte)(val & 0xFF);
+            }
             else if (val < 0x40000000)
-            { *ptr |= (byte)((val >> 24) & 0x3F); ptr++;
-              *ptr  = (byte)((val >> 16) & 0xFF); ptr++;
-              *ptr  = (byte)((val >>  8) & 0xFF); ptr++;
-              *ptr  = (byte)( val        & 0xFF); }
-            ptr++;
+            {
+                *ptr++ = (byte)(((byte)ENRSEntry.Value.Int32 << 6) | ((val >> 24) & 0x3F));
+                *ptr++ = (byte)((val >> 16) & 0xFF);
+                *ptr++ = (byte)((val >>  8) & 0xFF);
+                *ptr++ = (byte)( val        & 0xFF);
+            }
+            else
+            {
+                *ptr++ = (byte)ENRSEntry.Value.Invalid << 6;
+                return true;
+            }
+            return false;
         }
 
         public struct ENRSEntry

KKdBaseLib/F2/POF.cs

@@ -12,7 +12,6 @@ namespace KKdBaseLib.F2
 
         public unsafe void Read(byte[] data, bool shiftX)
         {
-            Value Val = 0;
             Offsets = KKdList<long>.New;
             fixed (byte* ptr = data)
             {
@@ -25,14 +24,7 @@ namespace KKdBaseLib.F2
                 Offsets.Capacity = length;
                 while (length > i)
                 {
-                    v = *l & 0x3F;
-                    Val = (Value)(*l & 0xC0);
-                         if (Val == Value.Int32)
-                    { v = (v << 24) | (l[1] << 16) | (l[2] << 8) | l[3]; l += 4; i += 4; }
-                    else if (Val == Value.Int16)
-                    { v = (v <<  8) |  l[1];                             l += 2; i += 2; }
-                    else if (Val == Value.Int8 ) {                       l ++  ; i ++  ; }
-                    else break;
+                    if (ReadPOFValue(ref l, out v)) break;
                     j++;
                     offset += v;
                     Offsets.Add(offset << bitShift);
@@ -44,44 +36,82 @@ namespace KKdBaseLib.F2
         public unsafe byte[] Write(bool shiftX)
         {
             Offsets.Sort();
-            long offset = 0;
-            byte bitShift = (byte)(shiftX ? 3 : 2);
-            int max1 = 0x00100 >> bitShift;
-            int max2 = 0x10000 >> bitShift;
+            long j, k, o;
+            byte bitShift, v;
+            bitShift = (byte)(shiftX ? 3 : 2);
+            v = (byte)((1 << bitShift) - 1);
 
+            j = 0;
             byte[] data = new byte[length(shiftX)];
             fixed (byte* ptr = data)
             {
-                byte Val = 0;
                 *(int*)ptr = length(shiftX);
-                byte* localPtr = ptr + 4;
+                byte* l = ptr + 4;
                 for (int i = 0; i < Offsets.Count; i++)
                 {
-                    offset = Offsets[i];
-                    if (i > 0) { offset -= Offsets[i - 1]; if (offset == 0) continue; }
-
-                    offset >>= bitShift;
-                    Val = (byte)(offset > max2 ? Value.Int32 : offset > max1 ? Value.Int16 : Value.Int8);
-                         if (offset < max1)   *localPtr = (byte)(Val |  offset       );
-                    else if (offset < max2) { *localPtr = (byte)(Val | (offset >>  8)); localPtr++;
-                                              *localPtr = (byte)        offset        ; }
-                    else                    { *localPtr = (byte)(Val | (offset >> 24)); localPtr++;
-                                              *localPtr = (byte)       (offset >> 16) ; localPtr++;
-                                              *localPtr = (byte)       (offset >>  8) ; localPtr++;
-                                              *localPtr = (byte)        offset        ; }
-                    localPtr++;
+                    o = Offsets[i];
+                    if ((o & v) != 0)
+                    {
+                        WritePOFValue(ref l, 0x7FFFFFFF);
+                        break;
+                    }
+                    
+                    k = o - j;
+                    if (i > 0 & k == 0)
+                        continue;
+                    j = o;
+                    o = k;
+                    WritePOFValue(ref l, o >> bitShift);
                 }
             }
             return data;
         }
 
+        [System.ThreadStatic] private static Value value;
+
+        private unsafe static bool ReadPOFValue(ref byte* ptr, out int v)
+        {
+            v = *ptr & 0x3F;
+            value = (Value)((*ptr & 0xC0) >> 6);
+            ptr++;
+                 if (value == Value.Int32  ) v = (((((v << 8) | *ptr++) << 8) | *ptr++) << 8) | *ptr++;
+            else if (value == Value.Int16  ) v =     (v << 8) | *ptr++; 
+            else if (value == Value.Invalid) { v = 0; return true; }
+            return false;
+        }
+
+        private unsafe static bool WritePOFValue(ref byte* ptr, long val)
+        {
+            if (val < 0x00000040)
+                *ptr++ = (byte)(((byte)Value.Int8  << 6) | ( val        & 0x3F));
+            else if (val < 0x00004000)
+            {
+                *ptr++ = (byte)(((byte)Value.Int16 << 6) | ((val >>  8) & 0x3F));
+                *ptr++ = (byte)(val & 0xFF);
+            }
+            else if (val < 0x40000000)
+            {
+                *ptr++ = (byte)(((byte)Value.Int32 << 6) | ((val >> 24) & 0x3F));
+                *ptr++ = (byte)((val >> 16) & 0xFF);
+                *ptr++ = (byte)((val >>  8) & 0xFF);
+                *ptr++ = (byte)( val        & 0xFF);
+            }
+            else
+            {
+                *ptr++ = (byte)Value.Invalid << 6;
+                return true;
+            }
+            return false;
+        }
+
         private int length(bool shiftX = false)
         {
-            int length = 6;
+            int length = 4;
             long offset = 0;
             byte bitShift = (byte)(shiftX ? 3 : 2);
-            int max1 = 0x00100 >> bitShift;
-            int max2 = 0x10000 >> bitShift;
+            int max1 = 0x00000040;
+            int max2 = 0x00004000;
+            int max3 = 0x40000000;
             for (int i = 0; i < Offsets.Count; i++)
             {
                 offset = Offsets[i];
@@ -90,17 +120,18 @@ namespace KKdBaseLib.F2
                 offset >>= bitShift;
                      if (offset < max1) length += 1;
                 else if (offset < max2) length += 2;
-                else                    length += 4;
+                else if (offset < max3) length += 4;
+                else                    length += 1;
             }
             return length;
         }
 
         public enum Value : byte
         {
-            Invalid = 0b00000000,
-            Int8    = 0b01000000,
-            Int16   = 0b10000000,
-            Int32   = 0b11000000,
+            Invalid = 0b00,
+            Int8    = 0b01,
+            Int16   = 0b10,
+            Int32   = 0b11,
         }
 
         public override string ToString() =>

KKdBaseLib/F2/Struct.cs

@@ -31,14 +31,12 @@ namespace KKdBaseLib.F2
             uint length = Data != null ? (uint)Data.Length : 0;
             if (HasPOF ) length += 0x20 + (uint)(shiftX ? POF.LengthX : POF.Length);
             if (HasENRS) length += 0x20 + (uint)ENRS.Length;
-
             if (HasSubStructs)
-            {
                 for (int i = 0; i < SubStructs.Length; i++)
                     length += (uint)(shiftX ? SubStructs[i].LengthX : SubStructs[i].Length)
                         + SubStructs[i].Header.Length;
+            if (HasPOF || HasENRS || HasSubStructs)
                 length += 0x20;
-            }
             return length;
         }
 

KKdBaseLib/KKdBaseLib.csproj

@@ -6,12 +6,12 @@
     <Configuration></Configuration>
     <Copyright>korenkonder (C) 2019-2020</Copyright>
     <Description>A base library</Description>
-    <FileVersion>0.4.9.5</FileVersion>
+    <FileVersion>0.4.9.7</FileVersion>
     <PackageId>KKdBaseLib</PackageId>
     <Product>KKdBaseLib</Product>
     <TargetFramework>net461</TargetFramework>
     <Title>KKdBaseLib</Title>
-    <Version>0.4.9.5</Version>
+    <Version>0.4.9.7</Version>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
     <PlatformTarget>AnyCPU</PlatformTarget>

KKdBaseLib/KKdList.cs

@@ -107,13 +107,15 @@ namespace KKdBaseLib
         }
 
         public void Sort()
-        { List<T> List = (List<T>)this; List.Sort(); array = List.ToArray(); count = List.Count; }
+        { Capacity = Count; List<T> List = (List<T>)this; List.Sort();
+          array = List.ToArray(); count = List.Count; }
 
         public static explicit operator KKdList<T>(   List<T> list) =>
             new KKdList<T> { array = list.ToArray(), count = list.Count };
 
         public static explicit operator    List<T>(KKdList<T> list)
-        { List<T> outList = new List<T>(); for (int i = 0; i < list.Count; i++) outList.Add(list[i]); return outList; }
+        { list.Capacity = list.Count; List<T> outList = new List<T>();
+          for (int i = 0; i < list.Count; i++) outList.Add(list[i]); return outList; }
 
         public override string ToString() =>
             $"(Count: {Count}; Capacity: {Capacity}; Current: {Current})";

KKdBaseLib/Main.cs

@@ -199,13 +199,54 @@ namespace KKdBaseLib
 
         public static int[] SW(this int length)
         {
-            int i = 0;
-            List<string> A = new List<string>();
-            for (i = 0; i < length; i++) A.Add(i.ToString());
-            A.Sort();
-            int[] B = new int[length];
-            for (i = 0; i < length; i++) B[i] = int.Parse(A[i]);
-            return B;
+            int i, j, l, m;
+
+            if (length <= 0) return new int[0];
+            if (length == 1) return new int[1] { 0 };
+
+            int[] sort = new int[length];
+            sort[0] = 0;
+            i = 1;
+            j = 1;
+
+            m = 1;
+            while (m < length)
+                m *= 10;
+            l = 0;
+            while (i < length)
+            {
+                if (j * 10 < m)
+                {
+                    sort[i++] = j;
+                    j *= 10;
+                }
+                else if (j >= length)
+                {
+                    m /= 10;
+                    j /= 10;
+                    sort[i++] = ++j;
+                    if (j * 10 >= length)
+                        j++;
+                }
+                else if (j % 10 != 9)
+                    sort[i++] = j++;
+
+                if (i < length)
+                    if (j == length && j % 10 != 9)
+                    {
+                        m /= 10;
+                        j /= 10;
+                        while (j % 10 == 9) j /= 10;
+                        j++;
+                    }
+                    else if (j < length && j % 10 == 9)
+                    {
+                        sort[i++] = j;
+                        while (j % 10 == 9) j /= 10;
+                        j++;
+                    }
+            }
+            return sort;
         }
     }
 }

KKdMainLib/DEX.cs

@@ -55,6 +55,7 @@ namespace KKdMainLib
                     if (element.Frame == 999999 || element.Both == 0xFFFF) break;
                     Dex[i].Main.Add(element);
                 }
+                Dex[i].Main.Capacity = Dex[i].Main.Count;
 
                 Dex[i].Eyes = KKdList<EXPElement>.New;
                 s.P = Dex[i].EyesOffset;
@@ -68,6 +69,7 @@ namespace KKdMainLib
                     if (element.Frame == 999999 || element.Both == 0xFFFF) break;
                     Dex[i].Eyes.Add(element);
                 }
+                Dex[i].Eyes.Capacity = Dex[i].Eyes.Count;
 
                 Dex[i].Name = s.RSaO(Dex[i].NameOffset);
             }
@@ -191,7 +193,7 @@ namespace KKdMainLib
                     {
                         Dex[i0].Eyes = KKdList<EXPElement>.New;
                         Dex[i0].Eyes.Capacity = temp.Array.Length;
-                        for (i1 = 0; i1 < this.Dex[i0].Eyes.Capacity; i1++)
+                        for (i1 = 0; i1 < Dex[i0].Eyes.Capacity; i1++)
                             Dex[i0].Eyes.Add(EXPElement.Read(temp[i1]));
                     }
                     temp.Dispose();

KKdMainLib/Extensions.cs

@@ -137,6 +137,7 @@ namespace KKdMainLib
                 else { stream.PI64 -= header.Length; break; }
                 lastSig = sig;
             }
+            subStructs.Capacity = subStructs.Count;
 
             if (subStructs.Capacity > 0) @struct.SubStructs = subStructs.ToArray();
             return @struct;

KKdMainLib/IO/Extensions.cs

@@ -18,6 +18,7 @@ namespace KKdMainLib.IO
                 if (a == end) break;
                 else s.Add(a);
             }
+            s.Capacity = s.Count;
             return s.ToArray();
         }
 

KKdMainLib/IO/JSON.cs

@@ -104,7 +104,7 @@ namespace KKdMainLib.IO
                 else if (c == ',') { _IO.RCUTF8(); continue; }
                 else return KKdList<MsgPack>.Null;
             }
-
+            obj.Capacity = obj.Count;
             return obj;
         }
 
@@ -125,6 +125,7 @@ namespace KKdMainLib.IO
                 else if (c == ',') { _IO.RCUTF8(); continue; }
                 else return null;
             }
+            obj.Capacity = obj.Count;
             return obj.ToArray();
         }
 

KKdMainLib/KKdMainLib.csproj

@@ -6,12 +6,12 @@
     <Configuration></Configuration>
     <Copyright>korenkonder (C) 2018-2020</Copyright>
     <Description>A simple library for working with Project Diva AC/DT/F/AFT/F2/X/FT/M39 files</Description>
-    <FileVersion>0.4.9.5</FileVersion>
+    <FileVersion>0.4.9.6</FileVersion>
     <PackageId>KKdMainLib</PackageId>
     <Product>KKdMainLib</Product>
     <TargetFramework>net461</TargetFramework>
     <Title>KKdMainLib</Title>
-    <Version>0.4.9.5</Version>
+    <Version>0.4.9.6</Version>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
     <PlatformTarget>AnyCPU</PlatformTarget>

PD_Tool/Program.cs

@@ -47,7 +47,7 @@ namespace PD_Tool
 
         private static void MainMenu()
         {
-            Console.Title = "PD_Tool v0.4.9.4";
+            Console.Title = "PD_Tool v0.4.9.7";
             Console.Clear();
 
             ConsoleDesign(true);

PD_Tool/Properties/AssemblyInfo.cs

@@ -11,5 +11,5 @@ using System.Runtime.InteropServices;
 [assembly: AssemblyCulture("")]
 [assembly: ComVisible(false)]
 [assembly: Guid("7B5D5A3A-A6F8-4813-C97D-ACFC98F7397E")]
-[assembly: AssemblyVersion("0.4.9.4")]
-[assembly: AssemblyFileVersion("0.4.9.4")]
+[assembly: AssemblyVersion("0.4.9.7")]
+[assembly: AssemblyFileVersion("0.4.9.7")]