Merge remote-tracking branch 'upstream/master'

ArcFormats/ArcCommon.cs

@@ -103,14 +103,14 @@ namespace GameRes.Formats
         {
             bool ext_is_empty = string.IsNullOrEmpty (ext);
             if (!ext_is_empty && '.' == ext[0])
-                return filename.EndsWith (ext, StringComparison.InvariantCultureIgnoreCase);
+                return filename.EndsWith (ext, StringComparison.OrdinalIgnoreCase);
             int ext_start = GetExtensionIndex (filename);
             // filename extension length
             int l_ext_length = filename.Length - ext_start;
             if (ext_is_empty)
                 return 0 == l_ext_length;
             return (l_ext_length == ext.Length
-                    && filename.EndsWith (ext, StringComparison.InvariantCultureIgnoreCase));
+                    && filename.EndsWith (ext, StringComparison.OrdinalIgnoreCase));
         }
 
         /// <summary>
@@ -129,7 +129,7 @@ namespace GameRes.Formats
                 }
                 else if ('.' == ext[0] || l_ext_length == ext.Length)
                 {
-                    if (filename.EndsWith (ext, StringComparison.InvariantCultureIgnoreCase))
+                    if (filename.EndsWith (ext, StringComparison.OrdinalIgnoreCase))
                         return true;
                 }
             }

ArcFormats/ArcFormats.csproj

@@ -123,6 +123,8 @@
     <Compile Include="AdvSys\ImageGWD.cs" />
     <Compile Include="Ail\ArcLNK2.cs" />
     <Compile Include="AIRNovel\ArcAIR.cs" />
+    <Compile Include="FC01\ArcBDT.cs" />
+    <Compile Include="FC01\BdtTables.cs" />
     <Compile Include="GScripter\ArcDATA.cs" />
     <Compile Include="Ism\ImagePNG.cs" />
     <Compile Include="Kogado\ArcARC.cs" />
@@ -166,6 +168,7 @@
     <Compile Include="Macromedia\Palettes.cs" />
     <Compile Include="Mugi\ArcBIN.cs" />
     <Compile Include="NScripter\Script.cs" />
+    <Compile Include="Psp\ArcQPK.cs" />
     <Compile Include="ScrPlayer\ImageIMG.cs" />
     <Compile Include="Software House Parsley\ArcScn.cs" />
     <Compile Include="TechGian\ArcBIN.cs" />
@@ -748,7 +751,7 @@
     <Compile Include="AZSys\ArcAZSys.cs" />
     <Compile Include="Ethornell\ArcBGI.cs" />
     <Compile Include="Ffa\ArcBlackPackage.cs" />
-    <Compile Include="Macromedia\ArcCCT.cs" />
+    <None Include="Macromedia\ArcCCT.cs" />
     <Compile Include="Cherry\ArcCherry.cs" />
     <Compile Include="Circus\ArcCircus.cs" />
     <Compile Include="ArcCommon.cs" />

ArcFormats/CatSystem/ImageHG3.cs

@@ -30,6 +30,8 @@ using System.Windows.Media.Imaging;
 using System.Windows.Media;
 using GameRes.Compression;
 using GameRes.Utility;
+using System.Collections.Generic;
+using System.Linq;
 
 namespace GameRes.Formats.CatSystem
 {
@@ -285,9 +287,10 @@ namespace GameRes.Formats.CatSystem
         byte[] UnpackJpeg ()
         {
             Flipped = false;
-            m_input.ReadInt32();
+            var toc = ReadSections();
+
+            m_input.Position = toc["img_jpg"] + 12;
             var jpeg_size = m_input.ReadInt32();
-            long next_section = Source.Position + jpeg_size;
             BitmapSource frame;
             using (var jpeg = new StreamRegion (Source, Source.Position, jpeg_size, true))
             {
@@ -297,42 +300,71 @@ namespace GameRes.Formats.CatSystem
             if (frame.Format.BitsPerPixel < 24)
                 throw new NotSupportedException ("Not supported HG-3 JPEG color depth");
             int src_pixel_size = frame.Format.BitsPerPixel/8;
-            int stride = (int)m_info.Width * src_pixel_size;
+            int stride = m_info.iWidth * src_pixel_size;
-            var pixels = new byte[stride*(int)m_info.Height];
+            var pixels = new byte[stride * m_info.iHeight];
             frame.CopyPixels (pixels, stride, 0);
-            var output = new byte[m_info.Width*m_info.Height*4];
+
-            uint total = m_info.Width * m_info.Height;
+            int total = m_info.iWidth * m_info.iHeight;
+            byte[] alpha = null;
+            if (toc.ContainsKey ("img_al"))
+                alpha = ReadAlpha (toc["img_al"]);
+            else
+                alpha = Enumerable.Repeat<byte> (0xFF, total).ToArray();
+
+            bool swap_rgb = toc.ContainsKey ("imgmode"); // XXX ???
+
+            var output = new byte[total * 4];
             int src = 0;
             int dst = 0;
+            int src_A = 0;
+            int src_R = 2, src_G = 1, src_B = 0;
+            if (swap_rgb)
+            {
+                src_R = 0;
+                src_B = 2;
+            }
             for (uint i = 0; i < total; ++i)
             {
-                output[dst++] = pixels[src+2];
+                output[dst++] = pixels[src+src_B];
-                output[dst++] = pixels[src+1];
+                output[dst++] = pixels[src+src_G];
-                output[dst++] = pixels[src];
+                output[dst++] = pixels[src+src_R];
-                output[dst++] = 0xFF;
+                output[dst++] = alpha[src_A++];
                 src += src_pixel_size;
             }
+            return output;
+        }
 
-            m_input.Position = next_section;
+        byte[] ReadAlpha (long start_pos)
-            var section_header = m_input.ReadBytes (8);
+        {
-            if (!Binary.AsciiEqual (section_header, "img_al\0\0"))
+            m_input.Position = start_pos + 0x10;
-                return output;
+            int packed_size = m_input.ReadInt32();
-            m_input.Seek (8, SeekOrigin.Current);
             int alpha_size = m_input.ReadInt32();
-            using (var alpha_in = new StreamRegion (Source, Source.Position+4, alpha_size, true))
+            using (var alpha_in = new StreamRegion (Source, Source.Position, packed_size, true))
             using (var alpha = new ZLibStream (alpha_in, CompressionMode.Decompress))
             {
-                for (int i = 3; i < output.Length; i += 4)
+                var alpha_data = new byte[alpha_size];
-                {
+                alpha.Read (alpha_data, 0, alpha_size);
-                    int b = alpha.ReadByte();
+                return alpha_data;
-                    if (-1 == b)
-                        throw new EndOfStreamException();
-                    output[i] = (byte)b;
-                }
-                return output;
             }
         }
 
+        Dictionary<string, long> ReadSections ()
+        {
+            long next_offset = m_info.HeaderSize;
+            var toc = new Dictionary<string, long>();
+            uint section_size;
+            do
+            {
+                m_input.Position = next_offset;
+                var section_name = m_input.ReadCString (8);
+                section_size = m_input.ReadUInt32();
+                toc[section_name] = next_offset;
+                next_offset += section_size;
+            }
+            while (section_size != 0);
+            return toc;
+        }
+
         byte[] UnpackWebp ()
         {
             throw new NotImplementedException ("HG-3 WebP decoder not implemented.");

ArcFormats/DraftArc.cs

@@ -29,11 +29,11 @@ namespace GameRes.Formats.??????
     [Export(typeof(ArchiveFormat))]
     public class PakOpener : ArchiveFormat
     {
-        public override string         Tag { get => "ARC"; }
+        public override string         Tag => "ARC";
-        public override string Description { get => "?????? engine resource archive"; }
+        public override string Description => "?????? engine resource archive";
-        public override uint     Signature { get => 0; }
+        public override uint     Signature => 0;
-        public override bool  IsHierarchic { get => false; }
+        public override bool  IsHierarchic => false;
-        public override bool      CanWrite { get => false; }
+        public override bool      CanWrite => false;
 
         public override ArcFile TryOpen (ArcView file)
         {
@@ -51,5 +51,10 @@ namespace GameRes.Formats.??????
             }
             return new ArcFile (file, this, dir);
         }
+
+        public override Stream OpenEntry (ArcFile arc, Entry entry)
+        {
+            return base.OpenEntry (arc, entry);
+        }
     }
 }

ArcFormats/DraftAudio.cs

@@ -26,10 +26,10 @@ namespace GameRes.Formats.??????
     [Export(typeof(AudioFormat))]
     public class xxxAudio : AudioFormat
     {
-        public override string         Tag { get => "xxx"; }
+        public override string         Tag => "xxx";
-        public override string Description { get => "?????? audio resource"; }
+        public override string Description => "?????? audio resource";
-        public override uint     Signature { get => 0; }
+        public override uint     Signature => 0;
-        public override bool      CanWrite { get => false; }
+        public override bool      CanWrite => false;
 
         public override SoundInput TryOpen (IBinaryStream file)
         {

ArcFormats/DraftImage.cs

@@ -28,9 +28,9 @@ namespace GameRes.Formats.??????
     [Export(typeof(ImageFormat))]
     public class xxxFormat : ImageFormat
     {
-        public override string         Tag { get => "xxx"; }
+        public override string         Tag => "xxx";
-        public override string Description { get => "?????? image format"; }
+        public override string Description => "?????? image format";
-        public override uint     Signature { get => 0; }
+        public override uint     Signature => 0;
 
         public override ImageMetaData ReadMetaData (IBinaryStream file)
         {

ArcFormats/Emote/ArcPSB.cs

@@ -64,7 +64,7 @@ namespace GameRes.Formats.Emote
 
         public PsbOpener ()
         {
-            Extensions = new string[] { "psb", "pimg", "dpak", "psbz" };
+            Extensions = new string[] { "psb", "pimg", "dpak", "psbz", "psp" };
         }
 
         public override ArcFile TryOpen (ArcView file)

ArcFormats/FC01/ArcBDT.cs

@@ -0,0 +1,151 @@
+//! \file       ArcBDT.cs
+//! \date       2023 Sep 10
+//! \brief      RPA resource archive.
+//
+// Copyright (C) 2023 by morkt
+//
+// 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.
+//
+
+using System;
+using System.Collections.Generic;
+using System.ComponentModel.Composition;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+
+// [021228][Fairytale Kagetsu Gumi] Tsuki Jong
+
+namespace GameRes.Formats.FC01
+{
+    [Export(typeof(ArchiveFormat))]
+    public partial class BdtOpener : PakOpener
+    {
+        public override string         Tag => "BDT";
+        public override string Description => "Fairytale resource archive";
+        public override uint     Signature => 0x4B434150; // 'PACK'
+        public override bool  IsHierarchic => false;
+        public override bool      CanWrite => false;
+
+        public BdtOpener ()
+        {
+            Signatures = new[] { 0x4B434150u, 0u };
+        }
+
+        public override ArcFile TryOpen (ArcView file)
+        {
+            uint signature = file.View.ReadUInt32 (0);
+            if (signature != this.Signature)
+                return BogusMediaArchive (file, signature);
+            var arc_name = Path.GetFileNameWithoutExtension (file.Name).ToLowerInvariant();
+            if (!arc_name.StartsWith ("dt0"))
+                return null;
+
+            uint index_pos = 12;
+            int count = file.View.ReadInt32 (4);
+            if (!IsSaneCount (count) || file.MaxOffset <= index_pos)
+                return null;
+            int entry_size = file.View.ReadInt32 (8);
+
+            string arc_num_str = arc_name.Substring (3);
+            int arc_num = int.Parse (arc_num_str, NumberStyles.HexNumber);
+            var dir = ReadVomIndex (file, arc_num, count, entry_size);
+            if (null == dir)
+                return null;
+            var arc_key = GetKey (arc_num);
+            return new AgsiArchive (file, this, dir, arc_key);
+        }
+
+        List<Entry> ReadVomIndex (ArcView file, int arc_num, int count, int record_size)
+        {
+            if (4 == arc_num) // dt004.bdt is an archive of indexes
+            {
+                var reader = new IndexReader (file, count, record_size);
+                return reader.ReadIndex();
+            }
+            var dt4name = VFS.ChangeFileName (file.Name, "dt004.bdt");
+            using (var dt4file = VFS.OpenView (dt4name))
+            {
+                var dt4arc = TryOpen (dt4file);
+                if (null == dt4arc)
+                    return null;
+                using (dt4arc)
+                {
+                    int vom_idx = arc_num;
+                    if (arc_num > 4)
+                        --vom_idx;
+                    var voms = string.Format ("vom{0:D3}.dat", vom_idx);
+                    var vom_entry = dt4arc.Dir.First (e => e.Name == voms);
+                    using (var input = dt4arc.OpenEntry (vom_entry))
+                    using (var index = BinaryStream.FromStream (input, vom_entry.Name))
+                    {
+                        var reader = new IndexReader (file, count, record_size);
+                        return reader.ReadIndex (index);
+                    }
+                }
+            }
+        }
+
+        ArcFile BogusMediaArchive (ArcView file, uint signature)
+        {
+            if (!file.Name.HasExtension (".bdt"))
+                return null;
+            string ext = null;
+            string type = "";
+            if (OggAudio.Instance.Signature == signature)
+            {
+                ext = ".ogg";
+                type = "audio";
+            }
+            else if (AudioFormat.Wav.Signature == signature && file.View.AsciiEqual (8, "AVI "))
+            {
+                ext = ".avi";
+            }
+            if (null == ext)
+                return null;
+            var name = Path.GetFileNameWithoutExtension (file.Name);
+            var dir = new List<Entry> {
+                new Entry {
+                    Name = name + ext,
+                    Type = type,
+                    Offset = 0,
+                    Size = (uint)file.MaxOffset
+                }
+            };
+            return new ArcFile (file, this, dir);
+        }
+
+        byte[] GetKey (int index)
+        {
+            int src = index * 8;
+            if (src + 8 > KeyOffsetTable.Length)
+                throw new ArgumentException ("Invalid AGSI key index.");
+            var key = new byte[8];
+            key[0] = KeySource[KeyOffsetTable[src++]];
+            key[1] = KeySource[KeyOffsetTable[src++]];
+            key[2] = KeySource[KeyOffsetTable[src++]];
+            key[3] = KeySource[KeyOffsetTable[src++] + 480];
+            key[4] = KeySource[KeyOffsetTable[src++] + 480];
+            key[5] = KeySource[KeyOffsetTable[src++] + 480];
+            key[6] = KeySource[KeyOffsetTable[src++] + 480];
+            key[7] = KeySource[KeyOffsetTable[src++] + 480];
+            return key;
+        }
+    }
+}

ArcFormats/FC01/ArcPAK.cs

@@ -102,8 +102,10 @@ namespace GameRes.Formats.FC01
 
         public override Stream OpenEntry (ArcFile arc, Entry entry)
         {
-            var aent = (AgsiEntry)entry;
+            var aent = entry as AgsiEntry;
             var aarc = arc as AgsiArchive;
+            if (null == aent)
+                return base.OpenEntry (arc, entry);
             Stream input;
             if (!aent.IsEncrypted)
                 input = arc.File.CreateStream (entry.Offset, entry.Size);
@@ -202,16 +204,16 @@ namespace GameRes.Formats.FC01
         ArcView     m_file;
         int         m_count;
         int         m_record_size;
-        uint        m_data_offset;
 
         public bool IsEncrypted { get; set; }
+        public uint  DataOffset { get; set; }
 
-        public IndexReader (ArcView file, int count, int record_size, bool is_encrypted)
+        public IndexReader (ArcView file, int count, int record_size, bool is_encrypted = false)
         {
             m_file = file;
             m_count = count;
             m_record_size = record_size;
-            m_data_offset = (uint)(0xC + m_count * m_record_size);
+            DataOffset = (uint)(0xC + m_count * m_record_size);
             IsEncrypted = is_encrypted;
         }
 
@@ -239,7 +241,7 @@ namespace GameRes.Formats.FC01
             if (!ArchiveFormat.IsSaneCount (count) || record_size <= 0x10 || record_size > 0x100)
                 return null;
             var reader = new IndexReader (file, count, record_size, is_encrypted);
-            if (reader.m_data_offset >= file.MaxOffset)
+            if (reader.DataOffset >= file.MaxOffset)
                 return null;
             return reader;
         }
@@ -247,29 +249,32 @@ namespace GameRes.Formats.FC01
         public List<Entry> ReadIndex ()
         {
             using (var index = OpenIndex())
+                return ReadIndex (index);
+        }
+
+        public List<Entry> ReadIndex (IBinaryStream index)
+        {
+            int name_size = m_record_size - 0x10;
+            var dir = new List<Entry> (m_count);
+            for (int i = 0; i < m_count; ++i)
             {
-                int name_size = m_record_size - 0x10;
+                var entry = new AgsiEntry();
-                var dir = new List<Entry> (m_count);
+                entry.UnpackedSize = index.ReadUInt32();
-                for (int i = 0; i < m_count; ++i)
+                entry.Size         = index.ReadUInt32();
-                {
+                entry.Method       = index.ReadInt32();
-                    var entry = new AgsiEntry();
+                entry.Offset       = index.ReadUInt32() + DataOffset;
-                    entry.UnpackedSize = index.ReadUInt32();
+                if (!entry.CheckPlacement (m_file.MaxOffset))
-                    entry.Size         = index.ReadUInt32();
+                    return null;
-                    entry.Method       = index.ReadInt32();
+                var name = index.ReadCString (name_size);
-                    entry.Offset       = index.ReadUInt32() + m_data_offset;
+                if (string.IsNullOrEmpty (name))
-                    if (!entry.CheckPlacement (m_file.MaxOffset))
+                    return null;
-                        return null;
+                entry.Name = name;
-                    var name = index.ReadCString (name_size);
+                entry.Type = FormatCatalog.Instance.GetTypeFromName (name);
-                    if (string.IsNullOrEmpty (name))
+                entry.IsPacked = entry.Method != 0 && entry.Method != 3;
-                        return null;
+                entry.IsSpecial = name.Equals ("Copyright.Dat", StringComparison.OrdinalIgnoreCase);
-                    entry.Name = name;
+                dir.Add (entry);
-                    entry.Type = FormatCatalog.Instance.GetTypeFromName (name);
-                    entry.IsPacked = entry.Method != 0 && entry.Method != 3;
-                    entry.IsSpecial = name.Equals ("Copyright.Dat", StringComparison.OrdinalIgnoreCase);
-                    dir.Add (entry);
-                }
-                return dir;
             }
+            return dir;
         }
 
         IBinaryStream OpenIndex ()

ArcFormats/FC01/BdtTables.cs

@@ -0,0 +1,159 @@
+//! \file       BdtTables.cs
+//! \date       2023 Sep 10
+//! \brief      BDT archives key tables.
+//
+
+namespace GameRes.Formats.FC01
+{
+    public partial class BdtOpener
+    {
+        internal static readonly ushort[] KeyOffsetTable = new ushort[] { // dword_4C7D80
+            0x029, 0x0E3, 0x05E, 0x104, 0x261, 0x16C, 0x256, 0x22E, 0x08A, 0x023, 0x1B4, 0x01D, 0x115, 0x0D5,
+            0x178, 0x1EB, 0x07F, 0x1D6, 0x02F, 0x14C, 0x238, 0x04A, 0x099, 0x124, 0x1C9, 0x0F9, 0x071, 0x260,
+            0x094, 0x15F, 0x044, 0x078, 0x072, 0x1B9, 0x18C, 0x0E3, 0x0DF, 0x1F3, 0x162, 0x053, 0x03D, 0x1BF,
+            0x198, 0x210, 0x0DB, 0x218, 0x05B, 0x139, 0x0E8, 0x1A9, 0x098, 0x148, 0x1A7, 0x17F, 0x0B3, 0x1E1,
+            0x119, 0x05F, 0x131, 0x121, 0x1F7, 0x023, 0x240, 0x120, 0x172, 0x048, 0x1BE, 0x130, 0x10E, 0x1A5,
+            0x05A, 0x199, 0x15D, 0x116, 0x195, 0x0B6, 0x19F, 0x189, 0x003, 0x06A, 0x0D6, 0x1AA, 0x05A, 0x22C,
+            0x1BE, 0x047, 0x1DE, 0x234, 0x04E, 0x0EE, 0x043, 0x1F9, 0x098, 0x0C3, 0x11D, 0x0BB, 0x099, 0x1AB,
+            0x0AE, 0x060, 0x1FE, 0x0A1, 0x1A6, 0x111, 0x1B5, 0x15F, 0x102, 0x24E, 0x106, 0x000, 0x0BA, 0x1BB,
+            0x0C3, 0x0CA, 0x0DC, 0x090, 0x18D, 0x1E2, 0x1BD, 0x161, 0x0E5, 0x137, 0x17C, 0x20D, 0x042, 0x1DA,
+            0x0D8, 0x131, 0x013, 0x01F, 0x177, 0x069, 0x1AF, 0x129, 0x18F, 0x251, 0x070, 0x106, 0x091, 0x209,
+            0x0C0, 0x01A, 0x05E, 0x23A, 0x0F3, 0x03E, 0x1B6, 0x0F7, 0x066, 0x19B, 0x268, 0x08B, 0x0FD, 0x156,
+            0x01D, 0x10F, 0x13B, 0x1F1, 0x083, 0x163, 0x010, 0x1B8, 0x1C8, 0x1CD, 0x103, 0x1C0, 0x0DD, 0x18A,
+            0x035, 0x0A3, 0x0FF, 0x0B0, 0x1D3, 0x00E, 0x025, 0x1FB, 0x193, 0x083, 0x0CD, 0x235, 0x0F4, 0x05F,
+            0x0C8, 0x18B, 0x055, 0x0DE, 0x017, 0x24A, 0x046, 0x036, 0x207, 0x123, 0x0E9, 0x18D, 0x146, 0x073,
+            0x09D, 0x00D, 0x0AF, 0x153, 0x0C2, 0x0A8, 0x0AF, 0x21F, 0x1D4, 0x074, 0x026, 0x20C, 0x170, 0x13B,
+            0x173, 0x0D2, 0x122, 0x076, 0x00C, 0x200, 0x0AA, 0x046, 0x0D4, 0x25A, 0x03D, 0x0C7, 0x0CF, 0x1DD,
+            0x17E, 0x176, 0x13C, 0x1D7, 0x084, 0x002, 0x02E, 0x203, 0x014, 0x067, 0x12A, 0x00F, 0x0C2, 0x1F0,
+            0x0E2, 0x222, 0x0C9, 0x079, 0x12B, 0x1A0, 0x1BA, 0x257, 0x156, 0x0A0, 0x109, 0x17A, 0x15E, 0x048,
+            0x02D, 0x01E, 0x24D, 0x082, 0x1AD, 0x0D0, 0x042, 0x029, 0x068, 0x214, 0x14A, 0x0B9, 0x0CB, 0x134,
+            0x027, 0x223, 0x0A3, 0x0B4, 0x0EC, 0x197, 0x107, 0x136, 0x0B9, 0x12F, 0x20B, 0x220, 0x145, 0x07F,
+            0x052, 0x11E, 0x02C, 0x0C1, 0x0CD, 0x110, 0x1C3, 0x1C8, 0x044, 0x162, 0x09D, 0x087, 0x15E, 0x0B7,
+            0x055, 0x17D, 0x076, 0x01A, 0x0B0, 0x017, 0x05C, 0x012, 0x247, 0x081, 0x088, 0x0A6, 0x14C, 0x075,
+            0x248, 0x151, 0x0E8, 0x004, 0x032, 0x111, 0x1A4, 0x1A9, 0x0BF, 0x137, 0x21A, 0x0D7, 0x189, 0x04A,
+            0x12E, 0x170, 0x0DA, 0x019, 0x04D, 0x0D6, 0x16A, 0x168, 0x19C, 0x19C, 0x188, 0x1C4, 0x204, 0x12B,
+            0x125, 0x128, 0x00B, 0x114, 0x0E7, 0x070, 0x06C, 0x1FD, 0x0C6, 0x1B0, 0x003, 0x15D, 0x085, 0x07A,
+            0x1C2, 0x237, 0x041, 0x07D, 0x183, 0x08E, 0x216, 0x126, 0x224, 0x010, 0x0E4, 0x059, 0x019, 0x0EB,
+            0x1E8, 0x04C, 0x1F6, 0x091, 0x18E, 0x08C, 0x0F0, 0x13F, 0x0F0, 0x065, 0x157, 0x1B8, 0x08E, 0x142,
+            0x033, 0x20F, 0x03B, 0x242, 0x1AC, 0x0E0, 0x005, 0x1A3, 0x17B, 0x03C, 0x175, 0x22D, 0x239, 0x10A,
+            0x022, 0x006, 0x07B, 0x16D, 0x014, 0x052, 0x241, 0x1B1, 0x12C, 0x074, 0x0F1, 0x1FF, 0x0B1, 0x118,
+            0x0AE, 0x062, 0x139, 0x0DD, 0x103, 0x193, 0x11A, 0x02B, 0x06E, 0x077, 0x0A7, 0x158, 0x15C, 0x21D,
+            0x230, 0x009, 0x194, 0x215, 0x171, 0x09F, 0x0DB, 0x174, 0x04F, 0x17E, 0x022, 0x1FC, 0x196, 0x06C,
+            0x04F, 0x16A, 0x1C6, 0x142, 0x1D1, 0x1A1, 0x045, 0x024, 0x092, 0x16F, 0x0A7, 0x1B0, 0x231, 0x1D6,
+            0x129, 0x181, 0x145, 0x0AC, 0x050, 0x0E6, 0x024, 0x154, 0x002, 0x152, 0x016, 0x23B, 0x1B2, 0x14F,
+            0x132, 0x17C, 0x11C, 0x00D, 0x085, 0x208, 0x229, 0x1D9, 0x158, 0x13E, 0x135, 0x018, 0x0E2, 0x12C,
+            0x1D5, 0x1C5, 0x168, 0x054, 0x108, 0x17F, 0x09C, 0x1ED, 0x021, 0x127, 0x160, 0x03A, 0x0BF, 0x0B3,
+            0x10B, 0x140, 0x008, 0x13A, 0x232, 0x186, 0x051, 0x061, 0x056, 0x09B, 0x059, 0x19A, 0x0B5, 0x169,
+            0x066, 0x16E, 0x07C, 0x072, 0x0A4, 0x144, 0x196, 0x133, 0x0F7, 0x16B, 0x118, 0x1E0, 0x16E, 0x17B,
+            0x034, 0x11B, 0x06F, 0x08F, 0x0C0, 0x0EE, 0x213, 0x03F, 0x181, 0x141, 0x0A5, 0x09E, 0x120, 0x0F9,
+            0x0F8, 0x030, 0x187, 0x155, 0x050, 0x069, 0x151, 0x03E, 0x164, 0x032, 0x0E9, 0x0D4, 0x000, 0x0AD,
+            0x178, 0x19E, 0x1C1, 0x21C, 0x10C, 0x21E, 0x0AB, 0x0FC, 0x026, 0x1AA, 0x01C, 0x177, 0x058, 0x04B,
+            0x10D, 0x0DF, 0x081, 0x079, 0x08C, 0x1D2, 0x21B, 0x0B2, 0x049, 0x025, 0x14D, 0x18C, 0x018, 0x19D,
+            0x202, 0x125, 0x073, 0x0D9, 0x191, 0x198, 0x1AB, 0x07B, 0x005, 0x1C9, 0x114, 0x065, 0x0F6, 0x02A,
+            0x0C4, 0x0DC, 0x056, 0x108, 0x009, 0x07E, 0x180, 0x07E, 0x0A5, 0x1A8, 0x09F, 0x1C7, 0x094, 0x0BD,
+            0x028, 0x11E, 0x107, 0x0AB, 0x0EF, 0x05D, 0x0C8, 0x096, 0x037, 0x1BF, 0x1EE, 0x06F, 0x201, 0x219,
+            0x147, 0x0FA, 0x060, 0x0D9, 0x185, 0x09C, 0x1CB, 0x1DF, 0x087, 0x021, 0x0B1, 0x15A, 0x0E5, 0x040,
+            0x063, 0x167, 0x04B, 0x10C, 0x0EA, 0x04E, 0x028, 0x1F4, 0x016, 0x0CA, 0x10F, 0x127, 0x04C, 0x166,
+            0x0CE, 0x190, 0x1E9, 0x15B, 0x14B, 0x159, 0x11B, 0x1B9, 0x013, 0x0DE, 0x0F1, 0x0F6, 0x00A, 0x06D,
+            0x140, 0x0BD, 0x226, 0x1EA, 0x088, 0x0ED, 0x16F, 0x153, 0x0A2, 0x1EF, 0x0CC, 0x020, 0x00B, 0x1DB,
+            0x06E, 0x0CF, 0x090, 0x031, 0x1B5, 0x0FC, 0x080, 0x001, 0x14F, 0x01E, 0x113, 0x0A2, 0x221, 0x22A,
+            0x1CA, 0x0AA, 0x110, 0x0B6, 0x0D5, 0x1D0, 0x228, 0x07C, 0x18E, 0x1B6, 0x064, 0x063, 0x05C, 0x011,
+            0x1E7, 0x105, 0x1E4, 0x146, 0x12F, 0x0BC, 0x011, 0x195, 0x183, 0x1CC, 0x0FF, 0x17A, 0x114, 0x065,
+            0x0F6, 0x02A, 0x0C4, 0x0DC, 0x056, 0x108, 0x009, 0x07E, 0x180, 0x07E, 0x0A5, 0x1A8, 0x09F, 0x1C7,
+            0x094, 0x0BD, 0x028, 0x11E, 0x107, 0x0AB, 0x0EF, 0x05D, 0x0C8, 0x096, 0x037, 0x1BF, 0x1EE, 0x06F,
+            0x201, 0x219, 0x147, 0x0FA, 0x060, 0x0D9, 0x185, 0x09C, 0x1CB, 0x1DF, 0x087, 0x021, 0x0B1, 0x15A,
+            0x0E5, 0x040, 0x063, 0x167, 0x04B, 0x10C, 0x0EA, 0x04E, 0x028, 0x1F4, 0x016, 0x0CA, 0x114, 0x065,
+            0x0F6, 0x02A, 0x0C4, 0x0DC, 0x056, 0x108, 0x009, 0x07E, 0x180, 0x07E, 0x0A5, 0x1A8, 0x09F, 0x1C7,
+            0x094, 0x0BD, 0x028, 0x11E, 0x107, 0x0AB, 0x0EF, 0x05D, 0x0C8, 0x096, 0x037, 0x1BF, 0x1EE, 0x06F,
+            0x201, 0x219, 0x147, 0x0FA, 0x060, 0x0D9, 0x185, 0x09C, 0x1CB, 0x1DF, 0x087, 0x021, 0x0B1, 0x15A,
+            0x0E5, 0x040, 0x063, 0x167, 0x04B, 0x10C, 0x0EA, 0x04E, 0x028, 0x1F4, 0x016, 0x0CA, 0x002, 0x152,
+            0x016, 0x23B, 0x1B2, 0x14F, 0x132, 0x17C, 0x11C, 0x00D, 0x085, 0x208, 0x229, 0x1D9, 0x158, 0x13E,
+            0x135, 0x018, 0x0E2, 0x12C, 0x1D5, 0x1C5, 0x168, 0x054, 0x108, 0x17F, 0x09C, 0x1ED, 0x021, 0x127,
+            0x160, 0x03A, 0x0BF, 0x0B3, 0x10B, 0x140, 0x008, 0x13A, 0x232, 0x186, 0x051, 0x061, 0x056, 0x09B,
+            0x059, 0x19A, 0x0B5, 0x169, 0x066, 0x16E, 0x07C, 0x072, 0x0A4, 0x144, 0x196, 0x133, 0x0F7, 0x16B,
+            0x118, 0x1E0, 0x16E, 0x17B, 0x034, 0x11B, 0x06F, 0x08F, 0x0C0, 0x0EE, 0x213, 0x03F, 0x181, 0x141,
+            0x0A5, 0x09E, 0x120, 0x0F9, 0x0F8, 0x030, 0x187, 0x155, 0x050, 0x069, 0x151, 0x03E, 0x164, 0x032,
+            0x0E9, 0x0D4, 0x000, 0x0AD, 0x178, 0x19E, 0x1C1, 0x21C, 0x10C, 0x21E, 0x0AB, 0x0FC, 0x026, 0x1AA,
+            0x01C, 0x177, 0x058, 0x04B, 0x10D, 0x0DF, 0x081, 0x079, 0x08C, 0x1D2, 0x21B, 0x0B2, 0x049, 0x025,
+            0x14D, 0x18C, 0x018, 0x19D, 0x202, 0x125, 0x073, 0x0D9, 0x191, 0x198, 0x1AB, 0x07B, 0x005, 0x1C9,
+            0x114, 0x065, 0x0F6, 0x02A, 0x0C4, 0x0DC, 0x056, 0x108, 0x009, 0x07E, 0x180, 0x07E, 0x0A5, 0x1A8,
+            0x09F, 0x1C7, 0x094, 0x0BD, 0x028, 0x11E, 0x107, 0x0AB, 0x0EF, 0x05D, 0x0C8, 0x096, 0x037, 0x1BF,
+            0x1EE, 0x06F, 0x201, 0x219, 0x147, 0x0FA, 0x060, 0x0D9, 0x185, 0x09C, 0x1CB, 0x1DF, 0x087, 0x021,
+            0x0B1, 0x15A, 0x0E5, 0x040, 0x063, 0x167, 0x04B, 0x10C, 0x0EA, 0x04E, 0x028, 0x1F4, 0x016, 0x0CA,
+            0x10F, 0x127, 0x04C, 0x166, 0x0CE, 0x190, 0x1E9, 0x15B, 0x14B, 0x159, 0x11B, 0x1B9, 0x013, 0x0DE,
+            0x0F1, 0x0F6,
+        };
+        internal static readonly byte[] KeySource = new byte[] { // byte_4C7920
+            0x5A, 0x4F, 0xC6, 0xCD, 0x58, 0xD3, 0xA1, 0x3F, 0x74, 0xC5, 0xA2, 0xD8, 0x47, 0x6A, 0xEF, 0x42,
+            0x4A, 0x65, 0x54, 0x75, 0xD9, 0x2E, 0xB1, 0x76, 0x48, 0x41, 0x30, 0xDF, 0xBE, 0xD9, 0x5F, 0xD9,
+            0x39, 0xA8, 0xAD, 0xB3, 0xBD, 0xAC, 0xB0, 0xCB, 0xC6, 0x29, 0xB6, 0xE6, 0xD0, 0x0C, 0x67, 0xDE,
+            0x1C, 0x1B, 0x72, 0xAF, 0x74, 0x24, 0x5C, 0xA9, 0xFE, 0x77, 0x9D, 0x6B, 0x6E, 0x45, 0x64, 0x93,
+            0x48, 0xB0, 0x39, 0xDC, 0x4D, 0x79, 0xBF, 0xA7, 0x3B, 0xD2, 0x53, 0x2B, 0xB0, 0x44, 0x7E, 0x6D,
+            0x76, 0x4E, 0xBE, 0xB3, 0x3E, 0x27, 0x3C, 0x02, 0xB8, 0xAD, 0x53, 0x04, 0x42, 0x87, 0xBE, 0x40,
+            0x5D, 0x60, 0xB6, 0x6A, 0x59, 0x5D, 0xBB, 0x71, 0x30, 0x4B, 0x22, 0xDD, 0x6C, 0x37, 0x57, 0x2C,
+            0x50, 0x7D, 0xBE, 0x33, 0x32, 0xE4, 0x2B, 0x56, 0xDD, 0xA9, 0x61, 0xBE, 0x2F, 0x5A, 0x3A, 0xB7,
+            0x7B, 0x5C, 0x6E, 0xD8, 0x3D, 0x50, 0x8C, 0xD7, 0x68, 0x5C, 0xBB, 0xE7, 0x4C, 0xC4, 0x40, 0x2E,
+            0x6C, 0x61, 0xB8, 0x67, 0xD5, 0xBC, 0x21, 0x2F, 0x32, 0x61, 0xF2, 0xFF, 0xCF, 0xBE, 0xAF, 0x74,
+            0xC9, 0xCC, 0x26, 0x79, 0x0F, 0x74, 0xCA, 0x54, 0x3B, 0x13, 0x54, 0xAF, 0x90, 0x72, 0xD1, 0x6A,
+            0x70, 0x59, 0xA9, 0x27, 0x24, 0x11, 0xC8, 0x1E, 0xAD, 0xC5, 0x4B, 0x41, 0xB2, 0xA4, 0xE5, 0xBD,
+            0xDC, 0x92, 0xB1, 0xD5, 0x28, 0x3F, 0x7C, 0x62, 0x2A, 0x46, 0xD4, 0x28, 0xF5, 0x28, 0xB8, 0xB6,
+            0xBF, 0xAE, 0xFD, 0xA9, 0xD9, 0xBC, 0xC9, 0x49, 0x2B, 0xB9, 0x31, 0x4F, 0xD4, 0xA6, 0x59, 0x5B,
+            0x51, 0xCA, 0x31, 0x23, 0xB1, 0x32, 0x80, 0xEC, 0x36, 0x68, 0xB8, 0x2E, 0x45, 0x1A, 0x2D, 0x39,
+            0xD1, 0x34, 0x35, 0xDA, 0xAA, 0xBE, 0x5A, 0xD3, 0x1C, 0x5A, 0xCF, 0x65, 0xBF, 0x6A, 0xCE, 0x52,
+            0x77, 0xBD, 0x2C, 0xD8, 0x57, 0xB3, 0xD4, 0x61, 0x43, 0xB1, 0xD3, 0x28, 0x37, 0xDA, 0xC9, 0x3C,
+            0x61, 0x7B, 0x17, 0x40, 0x32, 0x0A, 0x72, 0x4E, 0x50, 0x44, 0x16, 0x32, 0x2F, 0x32, 0x71, 0xF6,
+            0xB5, 0x0F, 0x86, 0x10, 0x13, 0xCA, 0xD2, 0x36, 0x27, 0x62, 0xA5, 0x79, 0x69, 0x2D, 0x33, 0x30,
+            0x84, 0x66, 0xB7, 0x26, 0xA1, 0xA1, 0xC9, 0x22, 0xB6, 0xC8, 0xA2, 0xC1, 0x6C, 0x78, 0xD8, 0x02,
+            0x53, 0xD1, 0x43, 0xEE, 0xAF, 0x5C, 0x49, 0xCA, 0x13, 0x21, 0xBA, 0xA3, 0xBE, 0xA9, 0x59, 0x3A,
+            0x29, 0x6B, 0xC3, 0xCC, 0xDE, 0xC6, 0x73, 0xA6, 0xD0, 0xB9, 0x2A, 0x65, 0x71, 0xB9, 0xDF, 0x39,
+            0xCF, 0xF4, 0xD0, 0x47, 0x36, 0x21, 0xEB, 0xDD, 0xB4, 0x4B, 0x73, 0xBE, 0xA2, 0x6A, 0xB8, 0x46,
+            0x2F, 0xDB, 0x32, 0xC0, 0x99, 0xA8, 0xD9, 0x2A, 0x71, 0x12, 0x26, 0xCE, 0xCC, 0xC0, 0xD1, 0xCD,
+            0x6C, 0x27, 0xE0, 0x4E, 0x34, 0x91, 0x20, 0x6E, 0xC7, 0x66, 0x62, 0x4F, 0x2F, 0xD4, 0x26, 0x3D,
+            0x84, 0x35, 0xEE, 0xD3, 0xA0, 0x49, 0xDF, 0xA8, 0xDB, 0x69, 0x0C, 0x22, 0x31, 0xD0, 0x24, 0x7F,
+            0x18, 0x3F, 0x28, 0xA1, 0xCD, 0xC0, 0xA9, 0xCB, 0x01, 0x49, 0xCC, 0xCD, 0xFF, 0x34, 0xD9, 0xBD,
+            0xC1, 0xE4, 0x64, 0xB8, 0xA6, 0xD7, 0x54, 0x33, 0xD0, 0xCE, 0x8B, 0x9A, 0xD9, 0xC3, 0xA1, 0x3B,
+            0x40, 0x8E, 0x06, 0x61, 0x37, 0x74, 0x32, 0x83, 0x57, 0xA6, 0x20, 0x0C, 0xAF, 0x83, 0xFD, 0x23,
+            0xA2, 0x44, 0x31, 0x5C, 0xB3, 0x18, 0x47, 0xDA, 0x30, 0x09, 0xE1, 0x61, 0x34, 0x75, 0x77, 0x50,
+            0xC9, 0xDF, 0x5E, 0xD5, 0x68, 0xD5, 0x9A, 0xED, 0x5F, 0x29, 0x4A, 0x55, 0xC2, 0x25, 0x43, 0xB4,
+            0xDE, 0xC4, 0x32, 0x2D, 0xA6, 0x63, 0x4E, 0xA7, 0x23, 0x5E, 0x3B, 0xFB, 0x75, 0xDB, 0x6D, 0x3D,
+            0xD8, 0xC7, 0xB0, 0xC4, 0x61, 0x3C, 0xD6, 0x49, 0x7A, 0xA6, 0xDC, 0x6B, 0xE1, 0x29, 0x4E, 0x54,
+            0x5E, 0x6E, 0x21, 0xF9, 0x21, 0x02, 0xC2, 0x2C, 0x4E, 0xB6, 0xBF, 0xCA, 0x5A, 0xD1, 0x36, 0x3D,
+            0x55, 0x0A, 0xD3, 0x97, 0xD4, 0xC2, 0xD0, 0xD6, 0xDA, 0x79, 0xC8, 0x46, 0xA5, 0x4C, 0xD5, 0xB8,
+            0x3B, 0x9F, 0xB4, 0x61, 0xA3, 0x46, 0xB5, 0x79, 0x58, 0x42, 0xB0, 0x40, 0x54, 0xD6, 0x33, 0x60,
+            0x72, 0x7C, 0xDB, 0x4E, 0x70, 0xB3, 0xB1, 0x8C, 0x3F, 0xC0, 0xB2, 0x80, 0x59, 0x3F, 0x68, 0xBB,
+            0x27, 0xE0, 0x73, 0x6A, 0xC1, 0x7D, 0xA7, 0x62, 0xCB, 0xCB, 0xB8, 0x2A, 0x4A, 0x4D, 0x57, 0xA8,
+            0x3A, 0x5B, 0x62, 0xD4, 0x66, 0x64, 0x47, 0xBE, 0x37, 0x0A, 0x5F, 0x46, 0x36, 0x74, 0x2D, 0x2A,
+            0xA4, 0x42, 0x9A, 0x43, 0x25, 0x4B, 0x59, 0x30, 0x57, 0x43, 0x5A, 0xDE, 0x45, 0x79, 0xBB, 0xB2,
+            0x63, 0x4F, 0xDD, 0x3F, 0x51, 0xDF, 0x2B, 0x6E, 0x94, 0xDC, 0xA6, 0x5F, 0x4A, 0x6C, 0xC6, 0x61,
+            0xDB, 0x4D, 0x55, 0xAD, 0x41, 0x2B, 0x2C, 0xC2, 0xB5, 0x6C, 0x33, 0x69, 0x5A, 0xB5, 0x9D, 0x44,
+            0x7B, 0x3B, 0x47, 0x49, 0x77, 0x2E, 0x9C, 0x55, 0x59, 0x64, 0x21, 0x87, 0x7A, 0x75, 0xBF, 0x38,
+            0x98, 0x27, 0x7E, 0xA8, 0x7D, 0x3E, 0x4C, 0xA6, 0x48, 0xD6, 0xA1, 0x32, 0x5D, 0xAD, 0x2C, 0xDB,
+            0xCF, 0x48, 0x38, 0x68, 0xEE, 0x26, 0x32, 0x79, 0x4F, 0xDB, 0x98, 0x67, 0x65, 0x72, 0xBC, 0xC3,
+            0x2F, 0x74, 0x33, 0x48, 0xC5, 0x48, 0x43, 0xCE, 0xD5, 0xA4, 0xBD, 0x6E, 0xB0, 0xDE, 0xF1, 0x3D,
+            0xC2, 0xA1, 0xC3, 0x76, 0x6C, 0xBE, 0xCB, 0x77, 0x69, 0x0E, 0x2A, 0x49, 0xD9, 0xB5, 0x22, 0x2F,
+            0x7E, 0x77, 0xC7, 0x80, 0x4D, 0x3C, 0xBC, 0x3E, 0x56, 0xC2, 0x61, 0x2B, 0x0B, 0x61, 0xBC, 0xE2,
+            0xB7, 0xD0, 0xA8, 0xCD, 0xBB, 0xA3, 0xB1, 0x50, 0xB9, 0x78, 0xCE, 0xB0, 0x6C, 0xB7, 0xB1, 0x2C,
+            0x22, 0xD3, 0x75, 0xD8, 0x11, 0xB3, 0x76, 0x3A, 0x64, 0x78, 0xB9, 0x67, 0x69, 0xA3, 0x47, 0x21,
+            0x5D, 0x31, 0x43, 0x08, 0x7E, 0xDC, 0xDB, 0xCD, 0x7D, 0x15, 0x6D, 0x28, 0xB3, 0x1C, 0xEB, 0x4A,
+            0xE9, 0xB8, 0x5A, 0x40, 0x40, 0x40, 0xC2, 0x73, 0x28, 0xB8, 0xCC, 0x66, 0xBF, 0x23, 0xDB, 0x5D,
+            0x59, 0xCF, 0x2D, 0x4A, 0xB1, 0xB7, 0x7D, 0xD9, 0xDE, 0xB6, 0x74, 0x55, 0xAE, 0x65, 0xD6, 0x60,
+            0xCB, 0xDA, 0x5C, 0x13, 0x37, 0xBE, 0xEA, 0xDC, 0x24, 0x60, 0x4A, 0x43, 0x6F, 0x41, 0xB5, 0xDC,
+            0x3E, 0x6D, 0x59, 0x51, 0x95, 0x2F, 0x34, 0x6A, 0xAD, 0xC5, 0xAE, 0x3D, 0x26, 0x59, 0x77, 0x44,
+            0xB1, 0x25, 0xDC, 0x38, 0x29, 0x22, 0x7D, 0x28, 0x68, 0xCA, 0xB2, 0x3E, 0xAA, 0x40, 0xA8, 0x7E,
+            0x7A, 0xA5, 0xF2, 0xAF, 0x6D, 0xDA, 0x4A, 0x49, 0x68, 0xD3, 0x74, 0xAD, 0xD5, 0x80, 0xD2, 0x2B,
+            0x3C, 0xC0, 0x30, 0xE5, 0x83, 0x3F, 0xC3, 0x57, 0x53, 0xB9, 0x76, 0x74, 0x45, 0x35, 0x67, 0xD4,
+            0xBB, 0xB8, 0xA6, 0x78, 0xCF, 0xA4, 0xD9, 0xA2, 0x73, 0xB2, 0xC0, 0x53, 0x3C, 0x68, 0xE9, 0xA0,
+            0x78, 0x65, 0x49, 0x25, 0x28, 0xCD, 0x5B, 0xA1, 0xC4, 0x29, 0x2D, 0xCA, 0xEC, 0x28, 0xBF, 0x29,
+            0x6B, 0x4F, 0x7E, 0x67, 0xC3, 0x0F, 0xFA, 0x71, 0x41, 0xC6, 0x3E, 0x5E, 0x02, 0x57, 0xAE, 0x7E,
+            0x65, 0x68, 0x3B, 0xCE, 0x5C, 0x8F, 0xD5, 0x6B, 0xCA, 0x66, 0xE4, 0x45, 0x57, 0x42, 0x72, 0x2C,
+            0xB5, 0x73, 0x5B, 0x30, 0xD5, 0xE1, 0xF9, 0xC9, 0xC8, 0xBE, 0xB9, 0x46, 0xA9, 0xCF, 0xD1, 0x7E,
+            0xAE, 0x2D, 0x22, 0xCA, 0x5E, 0x72, 0x3D, 0x56, 0x50, 0x60, 0xB4, 0x74, 0x5E, 0x48, 0x4E, 0xA5,
+            0x36, 0xBA, 0x2A, 0xC2, 0x60, 0xEE, 0x37, 0x3C, 0x2B, 0x43, 0xB9, 0x03, 0xBF, 0x65, 0x49, 0xCB,
+            0x78, 0x7B, 0x49, 0x8D, 0xD6, 0xCE, 0xAA, 0x4C, 0x4D, 0x27, 0x70, 0xA7, 0x17, 0xB1, 0xAE, 0x05,
+            0x30, 0xC9, 0x6F, 0x05, 0x29, 0xC6, 0x82, 0xAA, 0x41, 0x7F, 0x2D, 0x28, 0xC0, 0x3E, 0x53, 0xEF,
+            0x6A, 0x5F, 0x12, 0x42, 0xE9, 0x3F, 0x52, 0x78, 0x8B, 0x31, 0x23, 0x4F, 0xB1, 0x8A, 0x77, 0xF7,
+            0x38, 0xD6, 0x90, 0xAE, 0x04, 0x9F, 0xED, 0xD6, 0x69, 0x12, 0x26, 0x7F, 0xEC, 0xAE, 0xFC, 0x45,
+            0x01, 0x74, 0xD7, 0x6D, 0x9F, 0x9A, 0xA7, 0x75, 0x5A, 0x30, 0xCD, 0x90, 0xA9, 0xA5, 0x87, 0x4B,
+        };
+    }
+}

ArcFormats/Kaas/ArcKAAS.cs

@@ -129,6 +129,8 @@ namespace GameRes.Formats.KAAS
             var pent = (PdImageEntry)entry;
             byte[] baseline = null;
             var dir = arc.Dir as List<Entry>;
+            // actual baseline image index is hard-coded in game script
+            // we just look back at the first non-incremental image
             for (int i = pent.Number-1; i >= 0; --i)
             {
                 var base_entry = dir[i];

ArcFormats/KiriKiri/ArcXP3.cs

@@ -90,6 +90,7 @@ namespace GameRes.Formats.KiriKiri
         public Xp3Opener ()
         {
             Signatures = new uint[] { 0x0d335058, 0 };
+            Extensions = new[] { "XP3", "EXE" };
             ContainedFormats = new[] { "TLG", "BMP", "PNG", "JPEG", "OGG", "WAV", "TXT" };
         }
         

ArcFormats/LiveMaker/ArcVF.cs

@@ -44,7 +44,7 @@ namespace GameRes.Formats.LiveMaker
 
         public VffOpener ()
         {
-            Extensions = new string[] { "dat" };
+            Extensions = new string[] { "dat", "exe" };
             Signatures = new uint[] { 0x666676, 0 };
         }
 

ArcFormats/Macromedia/ArcCCT.cs

@@ -198,10 +198,10 @@ namespace GameRes.Formats.Macromedia
             if (t >= 0)
             {
                 string ext = new string (type_buf, 0, t+1);
-                return string.Format ("{0:X8}.{1}", id, ext.ToLowerInvariant());
+                return string.Format ("{0:D8}.{1}", id, ext.ToLowerInvariant());
             }
             else
-                return id.ToString ("X8");
+                return id.ToString ("D8");
         }
 
         byte[] ZlibUnpack (long offset, uint size, out int actual_size, int unpacked_size_hint = 0)

ArcFormats/Macromedia/ArcDXR.cs

@@ -23,13 +23,13 @@
 // IN THE SOFTWARE.
 //
 
+using GameRes.Compression;
 using GameRes.Utility;
-using System;
 using System.Collections.Generic;
 using System.ComponentModel.Composition;
-using System.Diagnostics;
 using System.IO;
 using System.Linq;
+using System.Text.RegularExpressions;
 using System.Windows.Media;
 using System.Windows.Media.Imaging;
 
@@ -46,12 +46,12 @@ namespace GameRes.Formats.Macromedia
 
         public DxrOpener ()
         {
-            Extensions = new[] { "dxr", "cxt" };
+            Extensions = new[] { "dxr", "cxt", "cct", "dcr" };
             Signatures = new[] { 0x52494658u, 0x58464952u };
         }
 
         internal static readonly HashSet<string> RawChunks = new HashSet<string> {
-            "RTE0", "RTE1", "FXmp", "VWFI", "VWSC", "Lscr", "STXT", "XMED", "snd "
+            "RTE0", "RTE1", "FXmp", "VWFI", "VWSC", "Lscr", "STXT", "XMED", //"snd "
         };
 
         internal bool ConvertText = true;
@@ -71,9 +71,9 @@ namespace GameRes.Formats.Macromedia
 
                 var dir = new List<Entry> ();
                 ImportMedia (dir_file, dir);
-                foreach (MemoryMapEntry entry in dir_file.MMap.Dir)
+                foreach (DirectorEntry entry in dir_file.Directory)
                 {
-                    if (entry.Size != 0 && RawChunks.Contains (entry.FourCC))
+                    if (entry.Size != 0 && entry.Offset != -1 && RawChunks.Contains (entry.FourCC))
                     {
                         entry.Name = string.Format ("{0:D6}.{1}", entry.Id, entry.FourCC.Trim());
                         if ("snd " == entry.FourCC)
@@ -90,19 +90,30 @@ namespace GameRes.Formats.Macromedia
             var snd = entry as SoundEntry;
             if (snd != null)
                 return OpenSound (arc, snd);
-            var ment = entry as MemoryMapEntry;
+            var pent = entry as PackedEntry;
-            if (!ConvertText || null == ment || ment.FourCC != "STXT")
+            if (null == pent)
                 return base.OpenEntry (arc, entry);
-            uint offset = Binary.BigEndian (arc.File.View.ReadUInt32 (entry.Offset));
+            var input = OpenChunkStream (arc.File, pent);
-            uint length = Binary.BigEndian (arc.File.View.ReadUInt32 (entry.Offset + 4));
+            var ment = entry as DirectorEntry;
-            return arc.File.CreateStream (entry.Offset + offset, length);
+            if (null == ment || !ConvertText || ment.FourCC != "STXT")
+                return input.AsStream;
+            using (input)
+            {
+                uint offset = Binary.BigEndian (input.ReadUInt32());
+                uint length = Binary.BigEndian (input.ReadUInt32());
+                input.Position = offset;
+                var text = input.ReadBytes ((int)length);
+                return new BinMemoryStream (text, entry.Name);
+            }
         }
 
         internal Stream OpenSound (ArcFile arc, SoundEntry entry)
         {
             if (null == entry.Header)
                 return base.OpenEntry (arc, entry);
-            var header = arc.File.View.ReadBytes (entry.Header.Offset, entry.Header.Size);
+            var header = new byte[entry.Header.UnpackedSize];
+            using (var input = OpenChunkStream (arc.File, entry.Header))
+                input.Read (header, 0, header.Length);
             var format = entry.DeserializeHeader (header);
             var riff = new MemoryStream (0x2C);
             WaveAudio.WriteRiffHeader (riff, format, entry.Size);
@@ -110,12 +121,14 @@ namespace GameRes.Formats.Macromedia
             {
                 using (riff)
                 {
-                    var input = arc.File.CreateStream (entry.Offset, entry.Size);
+                    var input = OpenChunkStream (arc.File, entry).AsStream;
                     return new PrefixStream (riff.ToArray(), input);
                 }
             }
             // samples are stored in big-endian format
-            var samples = arc.File.View.ReadBytes (entry.Offset, entry.Size);
+            var samples = new byte[entry.UnpackedSize];
+            using (var input = OpenChunkStream (arc.File, entry))
+                input.Read (samples, 0, samples.Length);
             for (int i = 1; i < samples.Length; i += 2)
             {
                 byte s = samples[i-1];
@@ -130,7 +143,6 @@ namespace GameRes.Formats.Macromedia
         void ImportMedia (DirectorFile dir_file, List<Entry> dir)
         {
             var seen_ids = new HashSet<int>();
-            var mmap = dir_file.MMap;
             foreach (var cast in dir_file.Casts)
             {
                 foreach (var piece in cast.Members.Values)
@@ -157,17 +169,35 @@ namespace GameRes.Formats.Macromedia
             {
                 if ("ediM" == elem.FourCC)
                 {
-                    var ediM = dir_file.MMap[elem.Id];
+                    var ediM = dir_file.Index[elem.Id];
-                    if (string.IsNullOrEmpty (name))
+                    name = SanitizeName(name, ediM.Id);
-                        name = ediM.Id.ToString ("D6");
+                    return new PackedEntry
-                    return new Entry
                     {
-                        Name   = name + ".mp3",
+                        Name = name + ".ediM",
-                        Type   = "audio",
+                        Type = "audio",
-                        Offset = ediM.Offset,
+                        Offset       = ediM.Offset,
-                        Size   = ediM.Size,
+                        Size         = ediM.Size,
+                        UnpackedSize = ediM.UnpackedSize,
+                        IsPacked     = ediM.IsPacked
                     };
                 }
+                else if ("snd " == elem.FourCC)
+                {
+                    var snd = dir_file.Index[elem.Id];
+                    if (snd.Size != 0)
+                    {
+                        name = SanitizeName (name, snd.Id);
+                        return new PackedEntry
+                        {
+                            Name = name + ".snd",
+                            Type = "audio",
+                            Offset = snd.Offset,
+                            Size = snd.Size,
+                            UnpackedSize = snd.Size,
+                            IsPacked = false,
+                        };
+                    }
+                }
                 if (null == sndHrec && "sndH" == elem.FourCC)
                     sndHrec = elem;
                 else if (null == sndSrec && "sndS" == elem.FourCC)
@@ -175,65 +205,99 @@ namespace GameRes.Formats.Macromedia
             }
             if (sndHrec == null || sndSrec == null)
                 return null;
-            var sndH = dir_file.MMap[sndHrec.Id];
+            var sndH = dir_file.Index[sndHrec.Id];
-            var sndS = dir_file.MMap[sndSrec.Id];
+            var sndS = dir_file.Index[sndSrec.Id];
-            if (string.IsNullOrEmpty (name))
+            name = SanitizeName (name, sndSrec.Id);
-                name = sndSrec.Id.ToString ("D6");
             return new SoundEntry
             {
                 Name   = name + ".snd",
                 Type   = "audio",
                 Offset = sndS.Offset,
                 Size   = sndS.Size,
+                UnpackedSize = sndS.UnpackedSize,
+                IsPacked = sndS.IsPacked,
                 Header = sndH,
             };
         }
 
         Entry ImportBitmap (CastMember bitmap, DirectorFile dir_file, Cast cast)
         {
-//            var bitd = dir_file.KeyTable.FindByCast (bitmap.Id, "BITD");
+            KeyTableEntry bitd = null, edim = null, alfa = null;
-            KeyTableEntry bitd = null, alfa = null;
             foreach (var elem in dir_file.KeyTable.Table.Where (e => e.CastId == bitmap.Id))
             {
                 if (null == bitd && "BITD" == elem.FourCC)
                     bitd = elem;
+                else if (null == edim && "ediM" == elem.FourCC)
+                    edim = elem;
                 else if (null == alfa && "ALFA" == elem.FourCC)
                     alfa = elem;
             }
-            if (bitd == null)
+            if (bitd == null && edim == null)
                 return null;
             var entry = new BitmapEntry();
-            entry.DeserializeHeader (bitmap.SpecificData);
+            if (bitd != null)
-            var name = bitmap.Info.Name;
-            if (string.IsNullOrEmpty (name))
-                name = bitd.Id.ToString ("D6");
-            var chunk = dir_file.MMap[bitd.Id];
-            entry.Name   = name + ".BITD";
-            entry.Type   = "image";
-            entry.Offset = chunk.Offset;
-            entry.Size   = chunk.Size;
-            if (entry.Palette > 0)
             {
-                var cast_id = cast.Index[entry.Palette-1];
+                entry.DeserializeHeader (bitmap.SpecificData);
-                var clut = dir_file.KeyTable.FindByCast (cast_id, "CLUT");
+                var name = SanitizeName (bitmap.Info.Name, bitd.Id);
-                if (clut != null)
+                var chunk = dir_file.Index[bitd.Id];
-                    entry.PaletteRef = dir_file.MMap[clut.Id];
+                entry.Name   = name + ".BITD";
+                entry.Type   = "image";
+                entry.Offset = chunk.Offset;
+                entry.Size   = chunk.Size;
+                entry.IsPacked = chunk.IsPacked;
+                entry.UnpackedSize = chunk.UnpackedSize;
+                if (entry.Palette > 0)
+                {
+                    var cast_id = cast.Index[entry.Palette-1];
+                    var clut = dir_file.KeyTable.FindByCast (cast_id, "CLUT");
+                    if (clut != null)
+                        entry.PaletteRef = dir_file.Index[clut.Id];
+                }
+            }
+            else // if (edim != null)
+            {
+                var name = SanitizeName (bitmap.Info.Name, edim.Id);
+                var chunk = dir_file.Index[edim.Id];
+                entry.Name   = name + ".jpg";
+                entry.Type   = "image";
+                entry.Offset = chunk.Offset;
+                entry.Size   = chunk.Size;
+                entry.IsPacked = false;
+                entry.UnpackedSize = entry.Size;
             }
             if (alfa != null)
-                entry.AlphaRef = dir_file.MMap[alfa.Id];
+                entry.AlphaRef = dir_file.Index[alfa.Id];
             return entry;
         }
 
+        static readonly Regex ForbiddenCharsRe = new Regex (@"[:?*<>/\\]");
+
+        string SanitizeName (string name, int id)
+        {
+            name = name?.Trim();
+            if (string.IsNullOrEmpty (name))
+                name = id.ToString ("D6");
+            else
+                name = ForbiddenCharsRe.Replace (name, "_");
+            return name;
+        }
+
         public override IImageDecoder OpenImage (ArcFile arc, Entry entry)
         {
             var bent = entry as BitmapEntry;
             if (null == bent)
-                return base.OpenImage (arc, entry);
+                return base.OpenImage(arc, entry);
+            if (entry.Name.HasExtension (".jpg"))
+                return OpenJpeg (arc, bent);
+
             BitmapPalette palette = null;
             if (bent.PaletteRef != null)
             {
-                var pal_bytes = arc.File.View.ReadBytes (bent.PaletteRef.Offset, bent.PaletteRef.Size);
+                using (var pal = OpenChunkStream (arc.File, bent.PaletteRef))
-                palette = ReadPalette (pal_bytes);
+                {
+                    var pal_bytes = pal.ReadBytes ((int)bent.PaletteRef.UnpackedSize);
+                    palette = ReadPalette (pal_bytes);
+                }
             }
             else if (bent.BitDepth <= 8)
             {
@@ -247,27 +311,53 @@ namespace GameRes.Formats.Macromedia
                 case -101:  palette = Palettes.SystemWindows; break;
                 }
             }
-            var info = new ImageMetaData {
+            var info = new BitdMetaData {
                 Width = (uint)(bent.Right - bent.Left),
                 Height = (uint)(bent.Bottom - bent.Top),
-                BPP = bent.BitDepth
+                BPP = bent.BitDepth,
+                DepthType = bent.DepthType,
             };
             byte[] alpha_channel = null;
             if (bent.AlphaRef != null)
-            {
+                alpha_channel = ReadAlphaChannel (arc.File, bent.AlphaRef, info);
-                using (var alpha = arc.File.CreateStream (bent.AlphaRef.Offset, bent.AlphaRef.Size))
+            var input = OpenChunkStream (arc.File, bent).AsStream;
-                {
+            return new BitdDecoder (input, info, palette) { AlphaChannel = alpha_channel };
-                    var alpha_info = new ImageMetaData {
+        }
-                        Width = info.Width,
+
-                        Height = info.Height,
+        IImageDecoder OpenJpeg (ArcFile arc, BitmapEntry entry)
-                        BPP = 8,
+        {
-                    };
+            if (null == entry.AlphaRef)
-                    var decoder = new BitdDecoder (alpha, alpha_info, null);
+                return base.OpenImage (arc, entry);
-                    alpha_channel = decoder.Unpack8bpp();
+            // jpeg with alpha-channel
-                }
-            }
             var input = arc.File.CreateStream (entry.Offset, entry.Size);
-            return new BitdDecoder (input.AsStream, info, palette) { AlphaChannel = alpha_channel };
+            try
+            {
+                var info = ImageFormat.Jpeg.ReadMetaData (input);
+                if (null == info)
+                    throw new InvalidFormatException ("Invalid 'ediM' chunk.");
+                var alpha_channel = ReadAlphaChannel (arc.File, entry.AlphaRef, info);
+                return BitdDecoder.FromJpeg (input, info, alpha_channel);
+            }
+            catch
+            {
+                input.Dispose();
+                throw;
+            }
+        }
+
+        byte[] ReadAlphaChannel (ArcView file, DirectorEntry entry, ImageMetaData info)
+        {
+            using (var alpha = OpenChunkStream (file, entry))
+            {
+                var alpha_info = new BitdMetaData {
+                    Width = info.Width,
+                    Height = info.Height,
+                    BPP = 8,
+                    DepthType = 0x80,
+                };
+                var decoder = new BitdDecoder (alpha.AsStream, alpha_info, null);
+                return decoder.Unpack8bpp();
+            }
         }
 
         BitmapPalette ReadPalette (byte[] data)
@@ -280,9 +370,20 @@ namespace GameRes.Formats.Macromedia
             }
             return new BitmapPalette (colors);
         }
+
+        IBinaryStream OpenChunkStream (ArcView file, PackedEntry entry)
+        {
+            var input = file.CreateStream (entry.Offset, entry.Size);
+            if (!entry.IsPacked)
+                return input;
+            var data = new byte[entry.UnpackedSize];
+            using (var zstream = new ZLibStream (input, CompressionMode.Decompress))
+                zstream.Read (data, 0, data.Length);
+            return new BinMemoryStream (data, entry.Name);
+        }
     }
 
-    internal class BitmapEntry : Entry
+    internal class BitmapEntry : PackedEntry
     {
         public byte Flags;
         public byte DepthType;
@@ -292,8 +393,8 @@ namespace GameRes.Formats.Macromedia
         public int  Right;
         public int  BitDepth;
         public int  Palette;
-        public Entry PaletteRef;
+        public DirectorEntry PaletteRef;
-        public Entry AlphaRef;
+        public DirectorEntry AlphaRef;
 
         public void DeserializeHeader (byte[] data)
         {
@@ -314,9 +415,9 @@ namespace GameRes.Formats.Macromedia
         }
     }
 
-    internal class SoundEntry : Entry
+    internal class SoundEntry : PackedEntry
     {
-        public Entry    Header;
+        public DirectorEntry    Header;
 
         public WaveFormat DeserializeHeader (byte[] header)
         {

ArcFormats/Macromedia/AudioSND.cs

@@ -31,10 +31,12 @@ namespace GameRes.Formats.Macromedia
     [Export(typeof(AudioFormat))]
     public class SndAudio : AudioFormat
     {
-        public override string         Tag { get => "SND"; }
+        public override string         Tag => "SND";
-        public override string Description { get => "Macromedia Director audio resource"; }
+        public override string Description => "Macromedia Director audio resource";
-        public override uint     Signature { get => 0; }
+        public override uint     Signature => 0;
-        public override bool      CanWrite { get => false; }
+        public override bool      CanWrite => false;
+
+        static readonly ResourceInstance<AudioFormat> Mp3 = new ResourceInstance<AudioFormat> ("MP3");
 
         public override SoundInput TryOpen (IBinaryStream file)
         {
@@ -83,6 +85,13 @@ namespace GameRes.Formats.Macromedia
             if (bps != 16 && bps != 8)
                 return null;
 
+            // try mp3
+            var samples_stream = new StreamRegion (reader.Source, reader.Position);
+            var mp3_input = new BinaryStream (samples_stream, file.Name);
+            var mp3 = Mp3.Value.TryOpen (mp3_input);
+            if (mp3 != null)
+                return mp3;
+
             var format = new WaveFormat {
                 FormatTag = 1,
                 Channels = channels,
@@ -93,8 +102,7 @@ namespace GameRes.Formats.Macromedia
             format.SetBPS();
             if (8 == bps)
             {
-                var data = new StreamRegion (file.AsStream, file.Position);
+                return new RawPcmInput (samples_stream, format);
-                return new RawPcmInput (data, format);
             }
             int sample_count = frames_count * channels;
             var samples = file.ReadBytes (sample_count);

ArcFormats/Macromedia/DirectorFile.cs

@@ -23,9 +23,11 @@
 // IN THE SOFTWARE.
 //
 
+using GameRes.Compression;
 using GameRes.Utility;
 using System;
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.IO;
 using System.Text;
 
@@ -66,24 +68,53 @@ namespace GameRes.Formats.Macromedia
 
     internal class DirectorFile
     {
+        List<DirectorEntry> m_dir;
+        Dictionary<int, DirectorEntry> m_index = new Dictionary<int, DirectorEntry>();
         MemoryMap       m_mmap = new MemoryMap();
         KeyTable        m_keyTable = new KeyTable();
         DirectorConfig  m_config = new DirectorConfig();
         List<Cast>      m_casts = new List<Cast>();
+        Dictionary<int, byte[]> m_ilsMap = new Dictionary<int, byte[]>();
 
-        public MemoryMap    MMap     => m_mmap;
+        public bool IsAfterBurned { get; private set; }
+
+        public MemoryMap        MMap => m_mmap;
         public KeyTable     KeyTable => m_keyTable;
         public DirectorConfig Config => m_config;
-        public List<Cast>   Casts    => m_casts;
+        public List<Cast>      Casts => m_casts;
+        public List<DirectorEntry>            Directory => m_dir;
+        public Dictionary<int, DirectorEntry> Index     => m_index;
+
+        public DirectorEntry Find (string four_cc) => Directory.Find (e => e.FourCC == four_cc);
+
+        public DirectorEntry FindById (int id)
+        {
+            DirectorEntry entry;
+            m_index.TryGetValue (id, out entry);
+            return entry;
+        }
 
         public bool Deserialize (SerializationContext context, Reader reader)
         {
             reader.Position = 8;
             string codec = reader.ReadFourCC();
-            if (codec != "MV93" && codec != "MC95")
+            if (codec == "MV93" || codec == "MC95")
+            {
+                if (!ReadMMap (context, reader))
+                    return false;
+            }
+            else if (codec == "FGDC" || codec == "FGDM")
+            {
+                IsAfterBurned = true;
+                if (!ReadAfterBurner (context, reader))
+                    return false;
+            }
+            else
+            {
+                Trace.WriteLine (string.Format ("Unknown codec '{0}'", codec), "DXR");
                 return false;
-            return ReadMMap (context, reader)
+            }
-                && ReadKeyTable (context, reader)
+            return ReadKeyTable (context, reader)
                 && ReadConfig (context, reader)
                 && ReadCasts (context, reader);
         }
@@ -99,25 +130,129 @@ namespace GameRes.Formats.Macromedia
                 return false;
             reader.Position = mmap_pos + 8;
             MMap.Deserialize (context, reader);
+            m_dir = MMap.Dir;
+            for (int i = 0; i < m_dir.Count; ++i)
+            {
+                m_index[i] = m_dir[i];
+            }
             return true;
         }
 
+        bool ReadAfterBurner (SerializationContext context, Reader reader)
+        {
+            if (reader.ReadFourCC() != "Fver")
+                return false;
+            int length = reader.ReadVarInt();
+            long next_pos = reader.Position + length;
+            int version = reader.ReadVarInt();
+            if (version > 0x400)
+            {
+                reader.ReadVarInt(); // imap version
+                reader.ReadVarInt(); // director version
+            }
+            if (version > 0x500)
+            {
+                int str_len = reader.ReadU8();
+                reader.Skip (str_len); // version string
+            }
+
+            reader.Position = next_pos;
+            if (reader.ReadFourCC() != "Fcdr")
+                return false;
+            // skip compression table, assume everything is zlib-compressed
+            length = reader.ReadVarInt();
+
+            reader.Position += length;
+            if (reader.ReadFourCC() != "ABMP")
+                return false;
+            length = reader.ReadVarInt();
+            next_pos = reader.Position + length;
+            reader.ReadVarInt(); // compression type, index within 'Fcdr' compression table
+            int unpacked_size = reader.ReadVarInt();
+            using (var abmp = new ZLibStream (reader.Source, CompressionMode.Decompress, true))
+            {
+                var abmp_reader = new Reader (abmp, reader.ByteOrder);
+                if (!ReadABMap (context, abmp_reader))
+                    return false;
+            }
+
+            reader.Position = next_pos;
+            if (reader.ReadFourCC() != "FGEI")
+                return false;
+            reader.ReadVarInt();
+            long base_offset = reader.Position;
+            foreach (var entry in m_dir)
+            {
+                m_index[entry.Id] = entry;
+                if (entry.Offset >= 0)
+                    entry.Offset += base_offset;
+            }
+            var ils_chunk = FindById (2);
+            if (null == ils_chunk)
+                return false;
+            using (var ils = new ZLibStream (reader.Source, CompressionMode.Decompress, true))
+            {
+                uint pos = 0;
+                var ils_reader = new Reader (ils, reader.ByteOrder);
+                while (pos < ils_chunk.UnpackedSize)
+                {
+                    int id = ils_reader.ReadVarInt();
+                    var chunk = m_index[id];
+                    m_ilsMap[id] = ils_reader.ReadBytes ((int)chunk.Size);
+                    pos += ils_reader.GetVarIntLength ((uint)id) + chunk.Size;
+                }
+            }
+            return true;
+        }
+
+        bool ReadABMap (SerializationContext context, Reader reader)
+        {
+            reader.ReadVarInt();
+            reader.ReadVarInt();
+            int count = reader.ReadVarInt();
+            m_dir = new List<DirectorEntry> (count);
+            for (int i = 0; i < count; ++ i)
+            {
+                var entry = new AfterBurnerEntry();
+                entry.Deserialize (context, reader);
+                m_dir.Add (entry);
+            }
+            return true;
+        }
+
+        Reader GetChunkReader (DirectorEntry chunk, Reader reader)
+        {
+            if (-1 == chunk.Offset)
+            {
+                byte[] chunk_data;
+                if (!m_ilsMap.TryGetValue (chunk.Id, out chunk_data))
+                    throw new InvalidFormatException (string.Format ("Can't find chunk {0} in ILS", chunk.FourCC));
+                var input = new BinMemoryStream (chunk_data, null);
+                reader = new Reader (input, reader.ByteOrder);
+            }
+            else
+            {
+                reader.Position = chunk.Offset;
+            }
+            return reader;
+        }
+
         bool ReadKeyTable (SerializationContext context, Reader reader)
         {
-            var key_chunk = MMap.Find ("KEY*");
+            var key_chunk = Find ("KEY*");
             if (null == key_chunk)
                 return false;
-            reader.Position = key_chunk.Offset;
+            reader = GetChunkReader (key_chunk, reader);
             KeyTable.Deserialize (context, reader);
             return true;
         }
 
         bool ReadConfig (SerializationContext context, Reader reader)
         {
-            var config_chunk = MMap.Find ("VWCF") ?? MMap.Find ("DRCF");
+            var config_chunk = Find ("VWCF") ?? Find ("DRCF");
             if (null == config_chunk)
                 return false;
-            reader.Position = config_chunk.Offset;
+            reader = GetChunkReader (config_chunk, reader);
             Config.Deserialize (context, reader);
             context.Version = Config.Version;
             return true;
@@ -125,21 +260,23 @@ namespace GameRes.Formats.Macromedia
 
         bool ReadCasts (SerializationContext context, Reader reader)
         {
+            Reader cas_reader;
             if (context.Version > 1200)
             {
-                var mcsl = MMap.Find ("MCsL");
+                var mcsl = Find ("MCsL");
                 if (mcsl != null)
                 {
-                    reader.Position = mcsl.Offset;
+                    var mcsl_reader = GetChunkReader (mcsl, reader);
                     var cast_list = new CastList();
-                    cast_list.Deserialize (context, reader);
+                    cast_list.Deserialize (context, mcsl_reader);
                     foreach (var entry in cast_list.Entries)
                     {
                         var key_entry = KeyTable.FindByCast (entry.Id, "CAS*");
                         if (key_entry != null)
                         {
-                            var mmap_entry = MMap[key_entry.Id];
+                            var cas_entry = Index[key_entry.Id];
-                            var cast = new Cast (context, reader, mmap_entry);
+                            cas_reader = GetChunkReader (cas_entry, reader);
+                            var cast = new Cast (context, cas_reader, cas_entry);
                             if (!PopulateCast (cast, context, reader, entry))
                                 return false;
                             Casts.Add (cast);
@@ -148,11 +285,12 @@ namespace GameRes.Formats.Macromedia
                     return true;
                 }
             }
-            var cas_chunk = MMap.Find ("CAS*");
+            var cas_chunk = Find ("CAS*");
             if (null == cas_chunk)
                 return false;
             var new_entry = new CastListEntry { Name = "internal", Id = 0x400, MinMember = Config.MinMember };
-            var new_cast = new Cast (context, reader, cas_chunk);
+            cas_reader = GetChunkReader (cas_chunk, reader);
+            var new_cast = new Cast (context, cas_reader, cas_chunk);
             if (!PopulateCast (new_cast, context, reader, new_entry))
                 return false;
             Casts.Add (new_cast);
@@ -162,30 +300,16 @@ namespace GameRes.Formats.Macromedia
         public bool PopulateCast (Cast cast, SerializationContext context, Reader reader, CastListEntry entry)
         {
             cast.Name = entry.Name;
-            /*
-            var lctx_ref = KeyTable.Table.Find (e => e.CastId == entry.Id && (e.FourCC == "Lctx" || e.FourCC == "LctX"));
-            MemoryMapEntry lctx_chunk = null;
-            if (lctx_ref != null)
-                lctx_chunk = MMap[lctx_ref.Id];
-            else
-                lctx_chunk = MMap.Dir.Find (e => e.FourCC == "Lctx" || e.FourCC == "LctX");
-            if (null == lctx_chunk)
-                return false;
-            reader.Position = lctx_chunk.Offset;
-            var lctx = new ScriptContext();
-            lctx.Deserialize (context, reader);
-            cast.Context = lctx;
-            */
             for (int i = 0; i < cast.Index.Length; ++i)
             {
                 int chunk_id = cast.Index[i];
                 if (chunk_id > 0)
                 {
-                    var chunk = MMap[chunk_id];
+                    var chunk = this.Index[chunk_id];
                     var member = new CastMember();
                     member.Id = chunk_id;
-                    reader.Position = chunk.Offset;
+                    var cast_reader = GetChunkReader (chunk, reader);
-                    member.Deserialize (context, reader);
+                    member.Deserialize (context, cast_reader);
                     cast.Members[member.Id] = member;
                 }
             }
@@ -293,11 +417,10 @@ namespace GameRes.Formats.Macromedia
         public string   Name;
         public Dictionary<int, CastMember> Members = new Dictionary<int, CastMember>();
 
-        public Cast (SerializationContext context, Reader reader, MemoryMapEntry entry)
+        public Cast (SerializationContext context, Reader reader, DirectorEntry entry)
         {
             int count = (int)(entry.Size / 4);
             Index = new int[count];
-            reader.Position = entry.Offset;
             Deserialize (context, reader);
         }
 
@@ -391,54 +514,6 @@ namespace GameRes.Formats.Macromedia
         public int      Id;
     }
 
-    internal class ScriptContext
-    {
-        public int EntriesOffset;
-        public int LnamChunkId;
-        public int ValidCount;
-        public ushort Flags;
-        public short FreePtr;
-        public List<ScriptContextMap>   ChunkMap = new List<ScriptContextMap>();
-
-        public void Deserialize (SerializationContext context, Reader reader)
-        {
-            long base_offset = reader.Position;
-            reader = reader.CloneUnless (ByteOrder.BigEndian);
-            reader.Skip (8);
-            int count = reader.ReadI32();
-            reader.Skip (4);
-            EntriesOffset = reader.ReadU16();
-            reader.Skip (14);
-            LnamChunkId = reader.ReadI32();
-            ValidCount = reader.ReadU16();
-            Flags = reader.ReadU16();
-            FreePtr = reader.ReadI16();
-            reader.Position = base_offset + EntriesOffset;
-
-            ChunkMap.Clear();
-            ChunkMap.Capacity = count;
-            for (int i = 0; i < count; ++i)
-            {
-                var entry = new ScriptContextMap();
-                entry.Deserialize (context, reader);
-                ChunkMap.Add (entry);
-            }
-        }
-    }
-
-    internal class ScriptContextMap
-    {
-        public int  Key;
-        public int  ChunkId;
-
-        public void Deserialize (SerializationContext context, Reader reader)
-        {
-            Key = reader.ReadI32();
-            ChunkId = reader.ReadI32();
-            reader.Skip (4);
-        }
-    }
-
     internal class DirectorConfig
     {
         public short Length;
@@ -548,11 +623,9 @@ namespace GameRes.Formats.Macromedia
         public int      ChunkCountMax;
         public int      ChunkCountUsed;
         public int      FreeHead;
-        public readonly List<MemoryMapEntry> Dir = new List<MemoryMapEntry>();
+        public readonly List<DirectorEntry> Dir = new List<DirectorEntry>();
 
-        public MemoryMapEntry this[int index] => Dir[index];
+        public DirectorEntry this[int index] => Dir[index];
-
-        public MemoryMapEntry Find (string four_cc) => Dir.Find (e => e.FourCC == four_cc);
 
         public void Deserialize (SerializationContext context, Reader reader)
         {
@@ -582,10 +655,14 @@ namespace GameRes.Formats.Macromedia
         }
     }
 
-    internal class MemoryMapEntry : Entry
+    internal class DirectorEntry : PackedEntry
     {
         public int      Id;
         public string   FourCC;
+    }
+
+    internal class MemoryMapEntry : DirectorEntry
+    {
         public ushort   Flags;
 
         public MemoryMapEntry (int id = 0)
@@ -596,10 +673,28 @@ namespace GameRes.Formats.Macromedia
         public void Deserialize (SerializationContext context, Reader reader)
         {
             FourCC = reader.ReadFourCC();
-            Size = reader.ReadU32();
+            Size   = reader.ReadU32();
             Offset = reader.ReadU32() + 8;
-            Flags = reader.ReadU16();
+            Flags  = reader.ReadU16();
-            int Next = reader.ReadI32();
+            reader.ReadI32(); // next
+            UnpackedSize = Size;
+            IsPacked = false;
+        }
+    }
+
+    internal class AfterBurnerEntry : DirectorEntry
+    {
+        public int      CompMethod;
+
+        public void Deserialize (SerializationContext context, Reader reader)
+        {
+            Id           = reader.ReadVarInt();
+            Offset       = reader.ReadVarInt();
+            Size         = (uint)reader.ReadVarInt();
+            UnpackedSize = (uint)reader.ReadVarInt();
+            CompMethod   = reader.ReadVarInt(); // assume zlib
+            FourCC       = reader.ReadFourCC();
+            IsPacked     = Size != UnpackedSize;
         }
     }
 
@@ -619,7 +714,7 @@ namespace GameRes.Formats.Macromedia
             SetByteOrder (e);
         }
 
-        public Stream Source { get => m_input; }
+        public Stream Source => m_input;
 
         public ByteOrder ByteOrder { get; private set; }
 
@@ -701,6 +796,32 @@ namespace GameRes.Formats.Macromedia
             return buffer;
         }
 
+        public int ReadVarInt ()
+        {
+            int n = 0;
+            for (int i = 0; i < 5; ++i)
+            {
+                int bits = m_input.ReadByte();
+                if (-1 == bits)
+                    throw new EndOfStreamException();
+                n = n << 7 | bits & 0x7F;
+                if (0 == (bits & 0x80))
+                    return n;
+            }
+            throw new InvalidFormatException();
+        }
+
+        public uint GetVarIntLength (uint i)
+        {
+            uint n = 1;
+            while (i > 0x7F)
+            {
+                i >>= 7;
+                ++n;
+            }
+            return n;
+        }
+
         public Reader CloneUnless (ByteOrder order)
         {
             if (this.ByteOrder != order)

ArcFormats/Macromedia/ImageBITD.cs

@@ -1,8 +1,8 @@
 //! \file       ImageBITD.cs
 //! \date       Fri Jun 26 07:45:01 2015
-//! \brief      Selen image format.
+//! \brief      Macromedia Director image format.
 //
-// Copyright (C) 2015 by morkt
+// Copyright (C) 2015-2023 by morkt
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to
@@ -34,174 +34,9 @@ using GameRes.Utility;
 
 namespace GameRes.Formats.Macromedia
 {
-    [Export(typeof(ImageFormat))]
+    internal class BitdMetaData : ImageMetaData
-    public class BitdFormat : ImageFormat
     {
-        public override string         Tag { get { return "BITD"; } }
+        public byte DepthType;
-        public override string Description { get { return "Selen RLE-compressed bitmap"; } }
-        public override uint     Signature { get { return 0; } }
-
-        public override ImageMetaData ReadMetaData (IBinaryStream stream)
-        {
-            if (stream.Length > 0xffffff)
-                return null;
-            var scanner = new BitdScanner (stream.AsStream);
-            return scanner.GetInfo();
-        }
-
-        public override ImageData Read (IBinaryStream stream, ImageMetaData info)
-        {
-            var reader = new BitdReader (stream.AsStream, info);
-            reader.Unpack();
-            return ImageData.Create (info, reader.Format, null, reader.Data);
-        }
-
-        public override void Write (Stream file, ImageData image)
-        {
-            throw new NotImplementedException ("BitdFormat.Write not implemented");
-        }
-    }
-
-    internal class BitdScanner
-    {
-        Stream  m_input;
-
-        protected Stream Input { get { return m_input; } }
-
-        public BitdScanner (Stream input)
-        {
-            m_input = input;
-        }
-
-        const int MaxScanLine = 2048;
-
-        public ImageMetaData GetInfo ()
-        {
-            int total = 0;
-            var scan_lines = new Dictionary<int, int>();
-            var key_lines = new List<int>();
-            for (;;)
-            {
-                int b = m_input.ReadByte();
-                if (-1 == b)
-                    break;
-                int count = b;
-                if (b > 0x7f)
-                    count = (byte)-(sbyte)b;
-                ++count;
-                if (count > 0x7f)
-                    return null;
-                if (b > 0x7f)
-                {
-                    if (-1 == m_input.ReadByte())
-                        return null;
-                }
-                else
-                    m_input.Seek (count, SeekOrigin.Current);
-
-                key_lines.Clear();
-                key_lines.AddRange (scan_lines.Keys);
-                foreach (var line in key_lines)
-                {
-                    int width = scan_lines[line];
-                    if (width < count)
-                        scan_lines.Remove (line);
-                    else if (width == count)
-                        scan_lines[line] = line;
-                    else
-                        scan_lines[line] = width - count;
-                }
-
-                total += count;
-                if (total <= MaxScanLine && total >= 8)
-                    scan_lines[total] = total;
-                if (total > MaxScanLine && !scan_lines.Any())
-                    return null;
-            }
-            int rem;
-            total = Math.DivRem (total, 4, out rem);
-            if (rem != 0)
-                return null;
-            var valid_lines = from line in scan_lines where line.Key == line.Value
-                              orderby line.Key
-                              select line.Key;
-            bool is_eof = -1 == m_input.ReadByte();
-            foreach (var width in valid_lines)
-            {
-                int height = Math.DivRem (total, width, out rem);
-                if (0 == rem)
-                {
-                    return new ImageMetaData
-                    {
-                        Width = (uint)width,
-                        Height = (uint)height,
-                        BPP = 32,
-                    };
-                }
-            }
-            return null;
-        }
-    }
-
-    internal class BitdReader : BitdScanner
-    {
-        byte[]          m_output;
-        int             m_width;
-        int             m_height;
-
-        public byte[]        Data { get { return m_output; } }
-        public PixelFormat Format { get; private set; }
-
-        public BitdReader (Stream input, ImageMetaData info) : base (input)
-        {
-            m_width = (int)info.Width;
-            m_height = (int)info.Height;
-            m_output = new byte[m_width * m_height * 4];
-            Format = PixelFormats.Bgra32;
-        }
-
-        public void Unpack ()
-        {
-            int stride = m_width * 4;
-            var scan_line = new byte[stride];
-            for (int line = 0; line < m_output.Length; line += stride)
-            {
-                int dst = 0;
-                while (dst < stride)
-                {
-                    int b = Input.ReadByte();
-                    if (-1 == b)
-                        throw new InvalidFormatException ("Unexpected end of file");
-                    int count = b;
-                    if (b > 0x7f)
-                        count = (byte)-(sbyte)b;
-                    ++count;
-                    if (dst + count > stride)
-                        throw new InvalidFormatException();
-                    if (b > 0x7f)
-                    {
-                        b = Input.ReadByte();
-                        if (-1 == b)
-                            throw new InvalidFormatException ("Unexpected end of file");
-                        for (int i = 0; i < count; ++i)
-                            scan_line[dst++] = (byte)b;
-                    }
-                    else
-                    {
-                        Input.Read (scan_line, dst, count);
-                        dst += count;
-                    }
-                }
-                dst = line;
-                for (int x = 0; x < m_width; ++x)
-                {
-                    m_output[dst++] = scan_line[x+m_width*3];
-                    m_output[dst++] = scan_line[x+m_width*2];
-                    m_output[dst++] = scan_line[x+m_width];
-                    m_output[dst++] = scan_line[x];
-                }
-            }
-        }
     }
 
     internal class BitdDecoder : IImageDecoder
@@ -216,13 +51,13 @@ namespace GameRes.Formats.Macromedia
         BitmapPalette   m_palette;
 
         public Stream            Source => m_input;
-        public ImageFormat SourceFormat => null;
+        public ImageFormat SourceFormat { get; private set; }
         public ImageMetaData       Info => m_info;
         public ImageData          Image => m_image ?? (m_image = GetImageData());
         public PixelFormat       Format { get; private set; }
         public byte[]      AlphaChannel { get; set; }
 
-        public BitdDecoder (Stream input, ImageMetaData info, BitmapPalette palette)
+        public BitdDecoder (Stream input, BitdMetaData info, BitmapPalette palette)
         {
             m_input = input;
             m_info = info;
@@ -235,23 +70,55 @@ namespace GameRes.Formats.Macromedia
                    : info.BPP ==  4 ? PixelFormats.Indexed4
                    : info.BPP ==  8 ? PixelFormats.Indexed8
                    : info.BPP == 16 ? PixelFormats.Bgr555
-                                    : PixelFormats.Bgr32;
+                   :  info.DepthType == 0x87 // i have no clue what this is
+                   || info.DepthType == 0x8A ? PixelFormats.Bgra32   // depth type 0x87/0x8A
+                                             : PixelFormats.Bgra32; // depth type 0x82/84/85/86/8C
             m_palette = palette;
         }
 
+        private BitdDecoder (Stream input, ImageMetaData info, byte[] alpha_channel)
+        {
+            m_input = input;
+            m_info = info;
+            m_width = info.iWidth;
+            m_height = info.iHeight;
+            m_stride = (m_width * m_info.BPP + 7) / 8;
+            Format = PixelFormats.Bgra32;
+            AlphaChannel = alpha_channel;
+            SourceFormat = ImageFormat.Jpeg;
+        }
+
+        public static IImageDecoder FromJpeg (Stream input, ImageMetaData info, byte[] alpha_channel)
+        {
+            return new BitdDecoder (input, info, alpha_channel);
+        }
+
         protected ImageData GetImageData ()
         {
+            BitmapSource bitmap = null;
             m_input.Position = 0;
-            if (Info.BPP <= 8)
+            if (SourceFormat == ImageFormat.Jpeg)
+            {
+                var decoder = new JpegBitmapDecoder (m_input, BitmapCreateOptions.None, BitmapCacheOption.OnLoad);
+                bitmap = decoder.Frames[0];
+                if (null == AlphaChannel)
+                    return new ImageData (bitmap, m_info);
+            }
+            else if (Info.BPP > 8)
+                UnpackChannels (Info.BPP / 8);
+            else if (m_output.Length != m_input.Length)
                 Unpack8bpp();
             else
-                UnpackChannels (Info.BPP / 8);
+                m_input.Read (m_output, 0, m_output.Length);
+
             if (AlphaChannel != null)
             {
-                if (Info.BPP != 32)
+                if (Info.BPP != 32 || bitmap != null)
                 {
-                    BitmapSource bitmap = BitmapSource.Create (Info.iWidth, Info.iHeight, ImageData.DefaultDpiX, ImageData.DefaultDpiY, Format, m_palette, m_output, m_stride);
+                    if (bitmap == null)
-                    bitmap = new FormatConvertedBitmap (bitmap, PixelFormats.Bgr32, null, 0);
+                        bitmap = BitmapSource.Create (m_width, m_height, ImageData.DefaultDpiX, ImageData.DefaultDpiY, Format, m_palette, m_output, m_stride);
+                    if (Info.BPP != 32)
+                        bitmap = new FormatConvertedBitmap (bitmap, PixelFormats.Bgr32, null, 0);
                     m_stride = bitmap.PixelWidth * 4;
                     m_output = new byte[bitmap.PixelHeight * m_stride];
                     bitmap.CopyPixels (m_output, m_stride, 0);
@@ -324,7 +191,8 @@ namespace GameRes.Formats.Macromedia
                 {
                     int b = m_input.ReadByte();
                     if (-1 == b)
-                        throw new InvalidFormatException ("Unexpected end of file");
+                        break; // one in 5000 images somehow stumbles here
+//                        throw new InvalidFormatException ("Unexpected end of file");
                     int count = b;
                     if (b > 0x7f)
                         count = (byte)-(sbyte)b;

ArcFormats/Mebius/AudioKOE.cs

@@ -32,7 +32,7 @@ using GameRes.Utility;
 namespace GameRes.Formats.Mebius
 {
     [Export(typeof(AudioFormat))]
-    [ExportMetadata("Priority", -1)]
+    [ExportMetadata("Priority", 1)]
     public class KoeAudio : AudioFormat
     {
         public override string         Tag { get { return "KOE/MEBIUS"; } }
@@ -65,8 +65,68 @@ namespace GameRes.Formats.Mebius
             return new WaveInput (data);
         }
 
-        static readonly Dictionary<string, byte[]> DefaultKeys = new Dictionary<string, byte[]> {
+        Dictionary<string, byte[]> DefaultKeys => SchemeMap["Mebinya!"];
-            { "koe", new byte[] {
+
+        static readonly Dictionary<string, Dictionary<string, byte[]>> SchemeMap =
+            new Dictionary<string, Dictionary<string, byte[]>> {
+            { "Mebinya!", new Dictionary<string, byte[]> {
+                { "koe", new byte[] {
+                0xCE, 0xC5, 0x94, 0xE8, 0xD5, 0x7F, 0xEB, 0xF4, 0x96, 0xCA, 0xAA, 0x80, 0xAC, 0x45, 0x60, 0x58,
+                0x71, 0x50, 0xDD, 0x72, 0x20, 0x39, 0x08, 0x73, 0xFE, 0x46, 0x07, 0xC5, 0x78, 0x77, 0xC0, 0x23,
+                0x49, 0x9F, 0xFC, 0xD1, 0x9A, 0x0F, 0x99, 0x7F, 0x3E, 0x7B, 0xAE, 0xF4, 0x66, 0xEE, 0x14, 0x94,
+                0x75, 0xD0, 0x0E, 0xD8, 0x64, 0x60, 0xB4, 0x3B, 0x40, 0x33, 0xC3, 0x4E, 0x40, 0x0E, 0xE4, 0x6C,
+                0x8D, 0x26, 0xBA, 0xB0, 0x17, 0xA5, 0x40, 0xB7, 0x27, 0x80, 0x79, 0x58, 0x92, 0xF8, 0x79, 0x3E,
+                0x2A, 0xDA, 0xC8, 0x29, 0xD3, 0x43, 0x66, 0xC0, 0xE5, 0x16, 0xAB, 0x25, 0x35, 0x68, 0x60, 0xC1,
+                0x77, 0x6E, 0x2B, 0x0E, 0x50, 0x58, 0xDC, 0xAE, 0xC5, 0x97, 0xE9, 0x27, 0xE1, 0xF3, 0x03, 0xA2,
+                0x43, 0x77, 0x13, 0xF0, 0xEC, 0x8C, 0x40, 0xB4, 0x7F, 0x62, 0x8B, 0x84, 0x40, 0x68, 0xAF, 0xD2,
+                0x10, 0xF2, 0xFE, 0x79, 0x3D, 0x63, 0x3D, 0xB4, 0x43, 0x65, 0xB8, 0x5F, 0x77, 0x13, 0x32, 0x56,
+                0xA4, 0x93, 0xC9, 0x3D, 0x9F, 0x89, 0xFE, 0x0B, 0xD0, 0x6C, 0x81, 0x2D, 0x3F, 0x94, 0xDD, 0x16,
+                0x1A, 0x12, 0x3A, 0x83, 0xC7, 0x26, 0xC3, 0xE0, 0xFE, 0xF1, 0xEC, 0x82, 0x6C, 0xAF, 0xA0, 0x30,
+                0xEB, 0xFD, 0x1A, 0xA1, 0xD0, 0xA9, 0xEC, 0x7A, 0x52, 0x6D, 0x83, 0xE4, 0x84, 0x97, 0x8F, 0x44,
+                0x89, 0x0E, 0xB7, 0xC1, 0x4F, 0xA1, 0x89, 0x8C, 0x09, 0xA6, 0xE5, 0x98, 0x4C, 0xC3, 0x7A, 0xCA,
+                0xE6, 0x6D, 0x06, 0xB7, 0x5B, 0x82, 0x6C, 0x02, 0x2E, 0x03, 0x57, 0xF3, 0xD6, 0x3D, 0x79, 0x5B,
+                0x87, 0x0E, 0xA2, 0x4E, 0xA6, 0xFE, 0xB8, 0x56, 0xA6, 0x55, 0xD3, 0x2B, 0x17, 0x6F, 0x7F, 0x84,
+                0x16, 0xF7, 0xE6, 0x99, 0x8A, 0x4E, 0x73, 0xDE, 0x45, 0x2E, 0x1A, 0xA6, 0xEF, 0x78, 0x67, 0x1A,
+                } },
+                { "mse", new byte[] {
+                0x40, 0xBA, 0x96, 0x7E, 0x07, 0xE1, 0x92, 0x95, 0x7E, 0x95, 0x17, 0x47, 0x3D, 0x1C, 0x08, 0x94,
+                0x02, 0xA5, 0x39, 0x7D, 0x95, 0xCB, 0xD8, 0x57, 0x09, 0x52, 0x67, 0xFD, 0x86, 0x57, 0xFD, 0x81,
+                0x04, 0xB9, 0x70, 0x54, 0x14, 0xC7, 0x8E, 0xA5, 0xA0, 0x11, 0xF5, 0xE2, 0xC5, 0x6E, 0xDB, 0x01,
+                0xA8, 0x8C, 0xA9, 0x25, 0xEB, 0x98, 0xD6, 0xBA, 0xAD, 0xD9, 0x62, 0x00, 0xAE, 0x50, 0xCA, 0x3E,
+                0x04, 0xAA, 0xF7, 0x98, 0xF9, 0x2C, 0xAE, 0xA4, 0x11, 0xCE, 0xF8, 0xCC, 0xAD, 0xB8, 0x07, 0xA5,
+                0xE8, 0xDF, 0x28, 0x2A, 0xA1, 0xE4, 0x81, 0x1F, 0x35, 0x7B, 0x4C, 0x7F, 0xFA, 0x04, 0x75, 0x31,
+                0x77, 0x0D, 0xD1, 0x79, 0xD3, 0x68, 0x2C, 0xDB, 0x16, 0x27, 0xBB, 0xD5, 0x2A, 0xFB, 0x2C, 0xBC,
+                0xB1, 0x70, 0xE2, 0x1C, 0xA8, 0xF6, 0x1E, 0x53, 0xDA, 0xA0, 0x89, 0xED, 0xB9, 0x25, 0x0A, 0x55,
+                0x08, 0x01, 0x37, 0xE7, 0x6B, 0xB4, 0xDB, 0x18, 0xE2, 0x13, 0x6B, 0x8E, 0x25, 0x98, 0x40, 0x05,
+                0xE7, 0x32, 0x1F, 0x4B, 0xA9, 0x7C, 0xC8, 0x24, 0x51, 0x54, 0x16, 0xFD, 0x6F, 0xC8, 0x67, 0x2B,
+                0xD2, 0xCD, 0x78, 0x18, 0xC2, 0xB0, 0xB6, 0xAA, 0x25, 0xB2, 0x4E, 0xCD, 0x3A, 0xD7, 0x0D, 0x43,
+                0x64, 0xBD, 0x35, 0x52, 0xFC, 0x07, 0x70, 0x67, 0xBE, 0x48, 0xFB, 0xA9, 0xD2, 0x67, 0xC3, 0xB8,
+                0x6A, 0xDC, 0x76, 0x04, 0x0E, 0xDD, 0xD3, 0xEB, 0x7A, 0x49, 0x39, 0xAC, 0xBD, 0xE5, 0x31, 0xBB,
+                0x71, 0xCC, 0x91, 0x8A, 0xB1, 0x09, 0x57, 0xF3, 0x39, 0xD2, 0x5E, 0xAB, 0x4F, 0x5F, 0x24, 0x86,
+                0xD5, 0x3D, 0xA8, 0xE7, 0x36, 0x23, 0x21, 0x32, 0x76, 0x3C, 0x98, 0x0A, 0x34, 0x51, 0x1E, 0xB8,
+                0x51, 0x40, 0x34, 0x93, 0x0B, 0x5C, 0x94, 0x24, 0x50, 0x6A, 0x72, 0x85, 0x04, 0xF1, 0xE5, 0x20,
+                } },
+                { "bgm", new byte[] {
+                0x16, 0x83, 0x0A, 0x4D, 0x6E, 0x39, 0xBF, 0xD8, 0x9C, 0x2B, 0x9E, 0x9F, 0xAE, 0x13, 0x8C, 0x63,
+                0xBE, 0x53, 0x95, 0x2E, 0x61, 0xB3, 0xFC, 0x26, 0x1C, 0xA5, 0xBF, 0x99, 0x69, 0x29, 0x3C, 0x99,
+                0xD7, 0x1E, 0x8B, 0xFD, 0xBD, 0x98, 0xC9, 0x12, 0x0E, 0x93, 0x5F, 0x59, 0x4E, 0x89, 0x7B, 0x26,
+                0xA7, 0x53, 0x50, 0xF1, 0xB6, 0x52, 0x5A, 0xA6, 0x6D, 0xCD, 0x20, 0xD9, 0xC3, 0x82, 0xCB, 0x21,
+                0xFD, 0x4D, 0x8B, 0xFA, 0x49, 0xEA, 0xC3, 0x7C, 0x81, 0x42, 0xEE, 0x38, 0xC3, 0xAB, 0xE0, 0x1A,
+                0xBD, 0x9F, 0xB4, 0x98, 0x4F, 0x59, 0x60, 0x8D, 0xEE, 0x41, 0x92, 0x87, 0xEB, 0x30, 0x2A, 0x66,
+                0xF4, 0x69, 0xA2, 0xA4, 0x0F, 0x53, 0xB6, 0x04, 0x4E, 0x4A, 0xB8, 0x9E, 0x8B, 0x23, 0xE0, 0xF8,
+                0xE6, 0xA2, 0x1F, 0xA4, 0x46, 0x9B, 0x34, 0x09, 0x33, 0xE3, 0x0B, 0x66, 0xB7, 0xCC, 0x1F, 0xA9,
+                0x1F, 0xEE, 0xF6, 0x1D, 0x42, 0x55, 0xE6, 0x19, 0x44, 0x61, 0xBA, 0xAE, 0x57, 0xFC, 0x6D, 0x08,
+                0xFE, 0x6B, 0x84, 0x5C, 0x69, 0x50, 0xD0, 0xCC, 0xC3, 0xBC, 0x92, 0x7C, 0x33, 0x59, 0x4D, 0x2D,
+                0x50, 0x00, 0x47, 0xCE, 0x4C, 0xDB, 0x7A, 0xB0, 0x25, 0x61, 0x07, 0x55, 0x8A, 0xAD, 0x50, 0x0B,
+                0xD3, 0x2D, 0x6C, 0xC9, 0x39, 0x94, 0x82, 0x0F, 0x9B, 0xF9, 0x45, 0x95, 0x1C, 0xBA, 0xA5, 0xB9,
+                0xD2, 0x60, 0xE3, 0xE3, 0xC7, 0x34, 0xAA, 0x43, 0x27, 0xC7, 0xC2, 0x3D, 0xBD, 0x8A, 0xA6, 0x4B,
+                0xA9, 0x3F, 0xEF, 0xBB, 0x6B, 0xE4, 0x6B, 0x89, 0x2A, 0xE9, 0xD1, 0xC0, 0xE5, 0x3A, 0xED, 0x1A,
+                0x61, 0xF9, 0xB3, 0xCC, 0x03, 0x0F, 0x82, 0xCD, 0x74, 0x36, 0x2A, 0xD8, 0x3E, 0x4E, 0xE0, 0x17,
+                0x37, 0x1B, 0x41, 0xC2, 0xE8, 0xA7, 0x81, 0x7C, 0xD3, 0x02, 0xFD, 0x51, 0xB4, 0x02, 0x43, 0x9E,
+                } },
+            } },
+            { "Tomodachi Ijou Koibito Miman", new Dictionary<string, byte[]> {
+                { "koe", new byte[] {
                 0x15, 0xEE, 0x1F, 0x83, 0x32, 0x20, 0xF8, 0x17, 0x53, 0xE3, 0x7B, 0xC0, 0x6A, 0x75, 0x93, 0xA5,
                 0x79, 0x32, 0x36, 0x7A, 0x76, 0xC5, 0xF4, 0x06, 0xC5, 0x08, 0xF5, 0x1E, 0xE4, 0xD5, 0xED, 0x72,
                 0x0B, 0xEC, 0x2A, 0x52, 0x6D, 0x87, 0xC3, 0x55, 0xD9, 0xC0, 0x07, 0x7A, 0x5E, 0x84, 0x35, 0x38,
@@ -83,8 +143,8 @@ namespace GameRes.Formats.Mebius
                 0x5A, 0xAD, 0xE8, 0xFB, 0x78, 0x8B, 0x76, 0xD2, 0x86, 0x7B, 0x79, 0x0B, 0x96, 0xC4, 0x51, 0x04,
                 0x43, 0x30, 0x20, 0x3F, 0x19, 0x19, 0x88, 0xE3, 0x27, 0x10, 0x65, 0xFE, 0xC8, 0x4A, 0x11, 0x67,
                 0x01, 0x55, 0x46, 0xEE, 0x80, 0x68, 0xC9, 0xC1, 0x1B, 0x4C, 0x49, 0x14, 0xC9, 0x95, 0xA9, 0x7F,
-            } },
+                } },
-            { "mse", new byte[] {
+                { "mse", new byte[] {
                 0x06, 0xDE, 0xEF, 0x76, 0xD2, 0xDA, 0xE7, 0x95, 0x7A, 0x87, 0x6D, 0x7C, 0xF6, 0x17, 0x44, 0x9F,
                 0x08, 0xD2, 0xC5, 0x89, 0xDC, 0xDE, 0xA1, 0x0F, 0x2D, 0xCB, 0xCA, 0xB8, 0x6E, 0xBB, 0x7F, 0x8A,
                 0x9E, 0x63, 0x70, 0x58, 0xCC, 0xA8, 0x61, 0x34, 0x68, 0x98, 0xD8, 0xB3, 0x74, 0x18, 0x2C, 0x9B,
@@ -101,8 +161,8 @@ namespace GameRes.Formats.Mebius
                 0x7B, 0x65, 0x21, 0x24, 0x42, 0x5C, 0x37, 0x4F, 0x64, 0x45, 0x58, 0x0C, 0xBC, 0xC1, 0xB7, 0xAD,
                 0xC7, 0xB6, 0xE3, 0x21, 0xBB, 0xC8, 0xD2, 0x15, 0x1F, 0xF1, 0x39, 0x3F, 0x87, 0x86, 0x88, 0xBE,
                 0x84, 0xD7, 0x1A, 0x63, 0xD5, 0x51, 0x63, 0xDB, 0x74, 0x39, 0x4C, 0x12, 0x12, 0xF1, 0x6E, 0x2C,
-            } },
+                } },
-            { "bgm", new byte[] {
+                { "bgm", new byte[] {
                 0xB0, 0x6F, 0xA4, 0xD7, 0x8B, 0x81, 0xBD, 0xF3, 0x82, 0xAF, 0x95, 0x6B, 0x9D, 0x3E, 0x88, 0x73,
                 0xB8, 0xF9, 0xD8, 0x09, 0x31, 0xF3, 0x84, 0xDA, 0xCC, 0xAF, 0x54, 0x60, 0xFD, 0x97, 0x04, 0xA6,
                 0x05, 0x65, 0x20, 0x9A, 0xA7, 0x62, 0xD9, 0xD7, 0x5C, 0x98, 0x6F, 0x2D, 0x3A, 0x6E, 0x07, 0xF8,
@@ -119,6 +179,7 @@ namespace GameRes.Formats.Mebius
                 0x03, 0x7A, 0x14, 0x10, 0x32, 0x7B, 0xF1, 0x33, 0xDE, 0xBA, 0x52, 0x74, 0xC7, 0x6E, 0xF8, 0x7E,
                 0x4C, 0x2C, 0x58, 0x3B, 0xA9, 0x7A, 0x51, 0x5C, 0xFD, 0xA5, 0xCF, 0x67, 0xB8, 0x34, 0x85, 0x3D,
                 0x7D, 0x93, 0xE9, 0x7E, 0x9E, 0x6E, 0xC3, 0xB2, 0xB1, 0xD0, 0x5C, 0x83, 0x61, 0x6F, 0x27, 0x18,
+                } },
             } },
         };
     }

ArcFormats/Nekopack/ArcNEKO.cs

@@ -123,7 +123,7 @@ namespace GameRes.Formats.Neko
         static string[] s_known_dir_names = {
             "image/actor", "image/back", "image/mask", "image/visual", "image/actor/big",
             "image/face", "image/actor/b", "image/actor/bb", "image/actor/s", "image/actor/ss",
-            "sound/bgm", "sound/env", "sound/se", "voice", "script", "system", "count",
+            "sound/bgm", "sound/env", "sound/se", "sound/bgv", "voice", "script", "system", "count",
         };
 
         static Lazy<string[]> s_known_file_names = new Lazy<string[]> (ReadNekoPackLst);

ArcFormats/Psp/ArcQPK.cs

@@ -0,0 +1,103 @@
+//! \file       ArcQPK.cs
+//! \date       2023 Sep 13
+//! \brief      PSP resource archive.
+//
+// Copyright (C) 2023 by morkt
+//
+// 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.
+//
+
+using GameRes.Compression;
+using System;
+using System.Collections.Generic;
+using System.ComponentModel.Composition;
+using System.IO;
+
+namespace GameRes.Formats.Psp
+{
+    [Export(typeof(ArchiveFormat))]
+    public class PakOpener : ArchiveFormat
+    {
+        public override string         Tag => "QPK";
+        public override string Description => "PSP resource archive";
+        public override uint     Signature => 0x4B5051; // 'QPK'
+        public override bool  IsHierarchic => false;
+        public override bool      CanWrite => false;
+
+        public override ArcFile TryOpen (ArcView file)
+        {
+            var index_name = Path.ChangeExtension (file.Name, "QPI");
+            List<Entry> dir;
+            using (var index = VFS.OpenView (index_name))
+            {
+                if (!index.View.AsciiEqual (0, "QPI\0"))
+                    return null;
+                int count = index.View.ReadInt32 (4);
+                if (!IsSaneCount (count))
+                    return null;
+
+                var base_name = Path.GetFileNameWithoutExtension (file.Name);
+                string ext = "";
+                string type = "";
+                if ("TGA" == base_name)
+                {
+                    ext = ".tga";
+                    type = "image";
+                }
+                dir = new List<Entry> (count);
+                uint index_pos = 0x1C;
+                for (int i = 0; i < count; ++i)
+                {
+                    uint offset = index.View.ReadUInt32 (index_pos);
+                    uint size   = index.View.ReadUInt32 (index_pos+4);
+                    if (offset > file.MaxOffset)
+                        return null;
+                    index_pos += 8;
+                    if ((size & 0x80000000) != 0 || size == 0)
+                        continue;
+                    var entry = new PackedEntry {
+                        Name = string.Format ("{0}#{1:D5}{2}", base_name, i, ext),
+                        Type = type,
+                        Offset = offset,
+                        UnpackedSize = size & 0x3FFFFFFF,
+                        IsPacked = (size & 0x40000000) != 0,
+                    };
+                    dir.Add (entry);
+                }
+                long last_offset = file.MaxOffset;
+                for (int i = dir.Count - 1; i >= 0; --i)
+                {
+                    dir[i].Size = (uint)(last_offset - dir[i].Offset);
+                    last_offset = dir[i].Offset;
+                }
+                return new ArcFile (file, this, dir);
+            }
+        }
+
+        public override Stream OpenEntry (ArcFile arc, Entry entry)
+        {
+            var pent = (PackedEntry)entry;
+            if (!pent.IsPacked || !arc.File.View.AsciiEqual (pent.Offset, "CZL\0"))
+                return base.OpenEntry (arc, pent);
+            uint size = arc.File.View.ReadUInt32 (pent.Offset+4);
+            var input = arc.File.CreateStream (pent.Offset+12, size);
+            return new ZLibStream (input, CompressionMode.Decompress);
+        }
+    }
+}

ArcFormats/StudioJikkenshitsu/ImageDAT.cs

@@ -133,7 +133,7 @@ namespace GameRes.Formats.Jikkenshitsu
             return new GUI.WidgetSJDAT (DefaultScheme.KnownSchemes.Keys);
         }
 
-        byte[] QueryKey (string filename)
+        internal byte[] QueryKey (string filename)
         {
             var options = Query<SjOptions> (arcStrings.ArcImageEncrypted);
             return options.Key;

ArcFormats/StudioJikkenshitsu/ImageGRC.cs

@@ -28,6 +28,8 @@ using System.IO;
 using System.Windows.Media;
 using System.Windows.Media.Imaging;
 
+// [020412][Ciel] Maid Hunter Zero One ~Nora Maid~
+
 namespace GameRes.Formats.Jikkenshitsu
 {
     internal class GrcMetaData : ImageMetaData
@@ -38,6 +40,8 @@ namespace GameRes.Formats.Jikkenshitsu
         public int  DataLength;
         public int  AlphaOffset;
         public int  AlphaLength;
+        public bool IsEncrypted;
+        public byte[] Key;
     }
 
     [Export(typeof(ImageFormat))]
@@ -47,15 +51,24 @@ namespace GameRes.Formats.Jikkenshitsu
         public override string Description { get { return "Studio Jikkenshitsu image format"; } }
         public override uint     Signature { get { return 0x08; } }
 
+        public GrcFormat ()
+        {
+            Signatures = new[] { 0x08u, 0x8008u };
+        }
+
+        static readonly ResourceInstance<SpDatFormat> SpeedFormat = new ResourceInstance<SpDatFormat> ("DAT/SPEED");
+
+        byte[] DefaultKey = null;
+
         public override ImageMetaData ReadMetaData (IBinaryStream file)
         {
             if (!file.Name.HasExtension (".grc"))
                 return null;
             var header = file.ReadHeader (0x20);
-            int bpp = header.ToInt32 (0);
+            int bpp = header[0];
             if (bpp != 8)
                 return null;
-            return new GrcMetaData {
+            var info = new GrcMetaData {
                 Width  = header.ToUInt16 (4),
                 Height = header.ToUInt16 (6),
                 BPP = bpp,
@@ -65,7 +78,16 @@ namespace GameRes.Formats.Jikkenshitsu
                 DataLength = header.ToInt32 (20),
                 AlphaOffset = header.ToInt32 (24),
                 AlphaLength = header.ToInt32 (28),
+                IsEncrypted = (header[1] & 0x80) != 0,
             };
+            if (info.IsEncrypted)
+            {
+                DefaultKey = DefaultKey ?? SpeedFormat.Value.QueryKey (file.Name);
+                if (null == DefaultKey)
+                    return null;
+                info.Key = DefaultKey;
+            }
+            return info;
         }
 
         public override ImageData Read (IBinaryStream file, ImageMetaData info)
@@ -96,12 +118,25 @@ namespace GameRes.Formats.Jikkenshitsu
             m_info = info;
             m_stride = m_info.iWidth * m_info.BPP / 8;
             m_output = new byte[m_stride * m_info.iHeight];
+            Format = PixelFormats.Indexed8;
         }
 
         public ImageData Unpack ()
         {
+            if (m_info.IsEncrypted)
+            {
+                int packed_size = (int)(m_input.Length - 0x20);
+                m_input.Position = 0x20;
+                using (var enc = new InputProxyStream (m_input.AsStream, true))
+                using (var dec = new InputCryptoStream (enc, new SjTransform (m_info.Key)))
+                {
+                    var data = new byte[m_input.Length];
+                    dec.Read (data, 0x20, packed_size);
+                    // memory stream is not disposed, not a big deal
+                    m_input = new BinMemoryStream (data, m_input.Name);
+                }
+            }
             m_input.Position = 0x20;
-            Format = PixelFormats.Indexed8;
 
             if (8 == m_info.BPP)
                 Palette = ImageFormat.ReadPalette (m_input.AsStream);

Experimental/Microsoft/ArcEXE.cs

@@ -29,10 +29,12 @@ using System.Collections.Generic;
 using System.ComponentModel.Composition;
 using System.IO;
 using System.Linq;
+using System.Text;
 
 namespace GameRes.Formats.Microsoft
 {
     [Export(typeof(ArchiveFormat))]
+    [ExportMetadata("Priority", -1)]
     public class ExeOpener : ArchiveFormat
     {
         public override string         Tag { get => "EXE"; }
@@ -49,6 +51,7 @@ namespace GameRes.Formats.Microsoft
         static readonly Dictionary<string, string> RuntimeTypeMap = new Dictionary<string, string>() {
             { "#2",  "RT_BITMAP" },
             { "#10", "RT_RCDATA" },
+            { "#16", "RT_VERSION" },
         };
 
         static readonly Dictionary<string, string> ExtensionTypeMap = new Dictionary<string, string>() {
@@ -60,6 +63,8 @@ namespace GameRes.Formats.Microsoft
             { "#10",  ".BIN" },
         };
 
+        bool OpenRtVersionAsText = true;
+
         public override ArcFile TryOpen (ArcView file)
         {
             if (!file.View.AsciiEqual (0, "MZ") || VFS.IsVirtual)
@@ -85,7 +90,7 @@ namespace GameRes.Formats.Microsoft
                         var entry = Create<ResourceEntry> (full_name);
                         entry.NativeName = name;
                         entry.NativeType = type;
-                        entry.Offset = 0;
+                        entry.Offset = 0; // bogus XXX
                         entry.Size = res.GetResourceSize (name, type);
                         dir.Add (entry);
                     }
@@ -111,6 +116,8 @@ namespace GameRes.Formats.Microsoft
             var data = rarc.Accessor.GetResource (rent.NativeName, rent.NativeType);
             if (null == data)
                 return Stream.Null;
+            if (rent.NativeType == "#16" && OpenRtVersionAsText)
+                return OpenVersion (data, rent.Name);
             return new BinMemoryStream (data, rent.Name);
         }
 
@@ -130,7 +137,7 @@ namespace GameRes.Formats.Microsoft
             int bits_length = bitmap.ToInt32 (0x22);
             int bits_pos = length - bits_length;
             if (bits_length == 0)
-                bits_pos = bitmap.ToInt32 (14) + 22;
+                bits_pos = bitmap.ToInt32 (14) + 14;
             LittleEndian.Pack (bits_pos, bitmap, 10);
 
             var bm = new BinMemoryStream (bitmap, 0, length, entry.Name);
@@ -150,6 +157,70 @@ namespace GameRes.Formats.Microsoft
                 id = id.Substring (1).PadLeft (5, '0');
             return id;
         }
+
+        static readonly byte[] VS_VERSION_INFO = Encoding.Unicode.GetBytes ("VS_VERSION_INFO");
+
+        Stream OpenVersion (byte[] data, string name)
+        {
+            var input = new BinMemoryStream (data, name);
+            for (;;)
+            {
+                if (input.ReadUInt16() != data.Length)
+                    break;
+                int value_length = input.ReadUInt16();
+                int type = input.ReadUInt16();
+                if (0 == value_length || type != 0)
+                    break;
+                if (input.ReadCString (Encoding.Unicode) != "VS_VERSION_INFO")
+                    break;
+                long pos = (input.Position + 3) & -4L;
+                input.Position = pos;
+                if (input.ReadUInt32() != 0xFEEF04BDu)
+                    break;
+                input.Position = pos + value_length;
+                int str_info_length = input.ReadUInt16();
+                value_length = input.ReadUInt16();
+                type = input.ReadUInt16();
+                if (value_length != 0)
+                    break;
+                if (input.ReadCString (Encoding.Unicode) != "StringFileInfo")
+                    break;
+                pos = (input.Position + 3) & -4L;
+                input.Position = pos;
+                int info_length = input.ReadUInt16();
+                long end_pos = pos + info_length;
+                value_length = input.ReadUInt16();
+                type = input.ReadUInt16();
+                if (value_length != 0)
+                    break;
+                var output = new MemoryStream();
+                using (var text = new StreamWriter (output, new UTF8Encoding (false), 512, true))
+                {
+                    string block_name = input.ReadCString (Encoding.Unicode);
+                    text.WriteLine ("BLOCK \"{0}\"\n{{", block_name);
+                    long next_pos = (input.Position + 3) & -4L;
+                    while (next_pos < end_pos)
+                    {
+                        input.Position = next_pos;
+                        info_length = input.ReadUInt16();
+                        value_length = input.ReadUInt16();
+                        type = input.ReadUInt16();
+                        next_pos = (next_pos + info_length + 3) & -4L;
+                        string key = input.ReadCString (Encoding.Unicode);
+                        input.Position = (input.Position + 3) & -4L;
+                        string value = value_length != 0 ? input.ReadCString (value_length * 2, Encoding.Unicode)
+                                                         : String.Empty;
+                        text.WriteLine ("\tVALUE \"{0}\", \"{1}\"", key, value);
+                    }
+                    text.WriteLine ("}");
+                }
+                input.Dispose();
+                output.Position = 0;
+                return output;
+            }
+            input.Position = 0;
+            return input;
+        }
     }
 
     internal class ResourceEntry : Entry

GameRes/ArcView.cs

@@ -42,6 +42,13 @@ namespace GameRes
             encoding.DecoderFallback = DecoderFallback.ExceptionFallback;
             return encoding;
         }
+
+        public static bool IsUtf16 (this Encoding enc)
+        {
+            // enc.WindowsCodePage property might throw an exception for some encodings, while
+            // CodePage is just a direct field access.
+            return (enc.CodePage == 1200 || enc.CodePage == 1201); // enc is UnicodeEncoding
+        }
     }
 
     public static class StreamExtension
@@ -440,9 +447,7 @@ namespace GameRes
                 {
                     byte* s = m_mem + (offset - m_offset);
                     uint string_length = 0;
-                    // enc.WindowsCodePage property might throw an exception for some encodings, while
+                    if (enc.IsUtf16()) // for UTF-16 encodings stop marker is 2-bytes long
-                    // CodePage is just a direct field access.
-                    if (enc.CodePage == 1200 || enc.CodePage == 1201) // for UTF-16 encodings stop marker is 2-bytes long
                     {
                         ushort* u = (ushort*)s;
                         while (string_length + 1 < size && 0 != u[string_length >> 1])

GameRes/BinaryStream.cs

@@ -589,14 +589,13 @@ namespace GameRes
 
         public string ReadCString (int length, Encoding enc)
         {
-            length = Math.Min (length, m_length - m_position);
             int start = m_start+m_position;
-            int i = Array.IndexOf<byte> (m_source, 0, start, length);
+            length = Math.Min (length, m_length - m_position);
-            if (-1 == i)
+            int eos_pos = FindEoS (start, length, enc);
-                i = start+length;
+            if (-1 == eos_pos)
-            string s = enc.GetString (m_source, start, i-start);
+                eos_pos = start+length;
             m_position += length;
-            return s;
+            return enc.GetString (m_source, start, eos_pos-start);
         }
 
         public string ReadCString ()
@@ -607,17 +606,19 @@ namespace GameRes
         public string ReadCString (Encoding enc)
         {
             int start = m_start+m_position;
-            int eos_pos = Array.IndexOf<byte> (m_source, 0, start, m_length-m_position);
+            int length = m_length-m_position;
+            int eos_pos = FindEoS (start, length, enc);
             int count;
             if (-1 == eos_pos)
             {
-                count = m_length - m_position;
+                count = length;
                 m_position = m_length;
             }
             else
             {
                 count = eos_pos - start;
-                m_position += count + 1;
+                int eos_size = enc.IsUtf16() ? 2 : 1;
+                m_position += count + eos_size;
             }
             return enc.GetString (m_source, start, count);
         }
@@ -631,6 +632,27 @@ namespace GameRes
             return buffer;
         }
 
+        internal int FindEoS (int start, int length, Encoding enc)
+        {
+            int eos_pos = -1;
+            if (enc.IsUtf16())
+            {
+                for (int i = start+1; i < start+length; i += 2)
+                {
+                    if (m_source[i-1] == 0 && m_source[i] == 0)
+                    {
+                        eos_pos = i - 1;
+                        break;
+                    }
+                }
+            }
+            else
+            {
+                eos_pos = Array.IndexOf<byte> (m_source, 0, start, length);
+            }
+            return eos_pos;
+        }
+
         #region IO.Stream Members
         public override bool CanRead  { get { return true; } }
         public override bool CanSeek  { get { return true; } }

Legacy/Bom/ImageGRP.cs

@@ -2,7 +2,7 @@
 //! \date       2018 Mar 30
 //! \brief      BOM image format.
 //
-// Copyright (C) 2018 by morkt
+// Copyright (C) 2018-2023 by morkt
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to
@@ -27,6 +27,9 @@ using System.ComponentModel.Composition;
 using System.IO;
 using System.Windows.Media;
 
+// [020705][BOM] Ikihaji@
+// [021025][Crystal Vision] Confession ~Hajimete no Kokuhaku~
+
 namespace GameRes.Formats.Bom
 {
     internal class GrpMetaData : ImageMetaData
@@ -71,8 +74,7 @@ namespace GameRes.Formats.Bom
         public override ImageData Read (IBinaryStream file, ImageMetaData info)
         {
             var reader = new GrpReader (file, (GrpMetaData)info);
-            var pixels = reader.Unpack();
+            return reader.Unpack();
-            return ImageData.Create (info, reader.Format, null, pixels);
         }
 
         public override void Write (Stream file, ImageData image)
@@ -87,24 +89,38 @@ namespace GameRes.Formats.Bom
         GrpMetaData     m_info;
         byte[]          m_output;
 
+        public PixelFormat Format { get; private set; }
+
         public GrpReader (IBinaryStream file, GrpMetaData info)
         {
             m_input = file;
             m_info = info;
             m_output = new byte[m_info.Stride * (int)m_info.Height];
+            Format = info.BPP == 16 ? PixelFormats.Bgr555
+                   : info.BPP == 24 ? PixelFormats.Bgr24
+                   : info.BPP == 32 ? PixelFormats.Bgra32
+                                    : PixelFormats.Gray8;
         }
 
         int     m_dst;
 
-        public byte[] Unpack ()
+        public ImageData Unpack ()
         {
             m_input.Position = m_info.DataOffset;
             uint size = m_input.ReadUInt32();
             if ((size & 0x80000000) != 0)
             {
                 m_input.Read (m_output, 0, m_output.Length);
-                return m_output;
             }
+            else
+            {
+                UnpackLz();
+            }
+            return ImageData.Create (m_info, Format, null, m_output, m_info.Stride);
+        }
+
+        void UnpackLz ()
+        {
             Init();
             var frame = new byte[0x1000];
             for (int i = 0; i < 0xFC0; ++i)
@@ -113,12 +129,11 @@ namespace GameRes.Formats.Bom
             m_dst = 0;
             while (m_dst < m_output.Length)
             {
-                int ctl = sub_408BE0();
+                int ctl = GetControlWord();
                 if (ctl >= 0x100)
                 {
-                    v5 = 0;
                     int count = ctl - 0xFD;
-                    int offset = (frame_pos - sub_408E50() - 1) & 0xFFF;
+                    int offset = (frame_pos - GetOffset() - 1) & 0xFFF;
                     for (int i = 0; i < count; ++i)
                     {
                         byte v = frame[(offset + i) & 0xFFF];
@@ -128,125 +143,170 @@ namespace GameRes.Formats.Bom
                 }
                 else
                 {
-                    PutByte (m_dst, ctl);
+                    PutByte (ctl);
                     frame[frame_pos++ & 0xFFF] = (byte)ctl;
                 }
             }
-            return m_output;
         }
 
-        int     dword_6FFE54;
         int     dword_6FF460;
+        int     dword_6FFE54;
         int     dword_709868;
-        int     dword_703E64;
+
-        int     m_cached_bits;
+        int[]   dword_6FF464 = new int[636];
+        int[]   dword_703E68 = new int[635];
+        int[]   dword_70986C = new int[953];
 
         void Init ()
         {
             dword_6FFE54 = -1;
             dword_6FF460 = 0;
             dword_709868 = 0;
-            dword_703E64 = 0;
 
-            int v0 = 0;
             for (int i = 0; i < 318; ++i)
             {
                 dword_6FF464[i] = 1;
-                dword_70A258[i] = i;
+                dword_70986C[i + 635] = i;
                 dword_703E68[i] = i + 635;
             }
             int v1 = 0;
             int v2 = 318;
             for (int i = 0; i <= 316; ++i)
             {
-                v4 = dword_6FF464[v1] + dword_6FF468[v1];
+                int v4 = dword_6FF464[v1] + dword_6FF464[v1 + 1];
-                dword_70986C[v1 + 1] = v2;
-                dword_6FF95C[i] = v4;
-                dword_704360[i] = v1;
                 dword_70986C[v1] = v2;
+                dword_70986C[v1 + 1] = v2;
+                dword_6FF464[i + 318] = v4;
+                dword_703E68[i + 318] = v1;
                 v1 += 2;
                 ++v2;
             }
-            dword_70A254 = 0;
+            dword_70986C[634] = 0;
             m_cached_bits = 0;
-            byte_7137B4 = 0;
             m_bits = 0;
-            dword_7137B0 = 0;
+            dword_6FF464[635] = 0xFFFF;
-            dword_6FFE50 = 0xFFFF;
         }
 
-        int[] dword_704360 = new int[317];
+        int GetControlWord ()
-        int[] dword_6FF95C = new int[317];
-        int[] dword_70986C = new int[634];
-
-        int sub_408BE0 ()
         {
-            for (int i = dword_704360[316]; i < 635; i = dword_703E68[GetNextBit() + i])
+            int ctl;
+            for (ctl = dword_703E68[634]; ctl < 635; ctl = dword_703E68[GetNextBit() + ctl])
                 ;
-            int ctl = i - 635;
+            ctl -= 635;
             sub_408C80 (ctl);
             return ctl;
         }
 
+        int GetOffset ()
+        {
+            int v0 = GetByte();
+            int v1 = byte_438D10[v0] - 2;
+            int v2 = byte_438C10[v0] << 6;
+            int bits = GetBits (v1);
+            return v2 | (((v0 << v1) & 0xFF) | (bits & 0xFF)) & 0x3F;
+        }
+
+        static readonly byte[] byte_438C10 = new byte[] {
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+            3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5,
+            6, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9,
+            0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0A, 0x0B, 0x0B, 0x0B, 0x0B, 0x0B, 0x0B, 0x0B, 0x0B,
+            0x0C, 0x0C, 0x0C, 0x0C, 0x0D, 0x0D, 0x0D, 0x0D, 0x0E, 0x0E, 0x0E, 0x0E, 0x0F, 0x0F, 0x0F, 0x0F,
+            0x10, 0x10, 0x10, 0x10, 0x11, 0x11, 0x11, 0x11, 0x12, 0x12, 0x12, 0x12, 0x13, 0x13, 0x13, 0x13,
+            0x14, 0x14, 0x14, 0x14, 0x15, 0x15, 0x15, 0x15, 0x16, 0x16, 0x16, 0x16, 0x17, 0x17, 0x17, 0x17,
+            0x18, 0x18, 0x19, 0x19, 0x1A, 0x1A, 0x1B, 0x1B, 0x1C, 0x1C, 0x1D, 0x1D, 0x1E, 0x1E, 0x1F, 0x1F,
+            0x20, 0x20, 0x21, 0x21, 0x22, 0x22, 0x23, 0x23, 0x24, 0x24, 0x25, 0x25, 0x26, 0x26, 0x27, 0x27,
+            0x28, 0x28, 0x29, 0x29, 0x2A, 0x2A, 0x2B, 0x2B, 0x2C, 0x2C, 0x2D, 0x2D, 0x2E, 0x2E, 0x2F, 0x2F,
+            0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x3F,
+        };
+        static readonly byte[] byte_438D10 = new byte[] {
+            3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+            4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
+            4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+            5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
+            5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+            6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+            7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
+            7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
+        };
+
         int     m_bits;
+        int     m_cached_bits;
 
         int GetNextBit ()
         {
-            if (m_cached_bits <= 8)
+            FillBitCache();
-            {
-                byte v = m_input.ReadUInt8();
-                m_bits |= (v << (8 - m_cached_bits));
-                m_cached_bits += 8;
-            }
             m_bits <<= 1;
             m_cached_bits--;
             return (m_bits >> 16) & 1;
         }
 
+        int GetByte()
+        {
+            FillBitCache();
+            int result = m_bits >> 8;
+            m_bits <<= 8;
+            m_cached_bits -= 8;
+            return result & 0xFF;
+        }
+
+        int GetBits (int n)
+        {
+            FillBitCache();
+            int bits = m_bits << n;
+            m_cached_bits -= n;
+            int result = m_bits >> BitShiftTable[n];
+            m_bits = bits;
+            return result & BitMaskTable[n];
+        }
+
+        void FillBitCache ()
+        {
+            if (m_cached_bits <= 8)
+            {
+                int v = m_input.ReadByte();
+                if (-1 == v)
+                    v = 0;
+                m_bits |= v << (8 - m_cached_bits);
+                m_cached_bits += 8;
+            }
+        }
+
+        static readonly ushort[] BitMaskTable = new ushort[] {
+            0, 1, 3, 7, 0x0F, 0x1F, 0x3F, 0x7F, 0x0FF, 0x1FF, 0x3FF, 0x7FF, 0x0FFF, 0x1FFF, 0x3FFF, 0x0FFF, 0xFFFF
+        };
+        static readonly byte[] BitShiftTable = new byte[] {
+            0x10, 0x0F, 0x0E, 0x0D, 0x0C, 0x0B, 0x0A, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0
+        };
+
         void sub_408C80 (int a1)
         {
-            unsigned int v2; // ecx@4
+            if (dword_6FF464[634] == 0x8000)
-            unsigned int v3; // esi@4
-            int *v4; // ecx@5
-            unsigned int v5; // eax@6
-            int v6; // eax@7
-            int v7; // ecx@7
-            int v8; // eax@7
-            int v9; // esi@9
-
-            if (dword_6FF95C[316] == 0x8000)
                 sub_408D50();
-            int v1 = dword_70A258[a1];
+            int v1 = dword_70986C[a1 + 635];
             do
             {
-                v2 = dword_6FF464[v1] + 1;
+                int v2 = ++dword_6FF464[v1];
-                dword_6FF464[v1] = v2;
+                int v3 = v2;
-                v3 = v2;
+                if (v2 > dword_6FF464[v1 + 1])
-                if ( v2 > dword_6FF468[v1] )
                 {
-                    v4 = &dword_6FF46C[v1 + 1];
+                    int v4 = v1 + 2; // &dword_6FF464[v1 + 2];
-                    if ( v3 > dword_6FF46C[v1] )
+                    while (v3 > dword_6FF464[v4++])
-                    {
+                        ;
-                        do
+                    dword_6FF464[v1] = dword_6FF464[v4 - 2];
-                        {
+                    dword_6FF464[v4 - 2] = v3;
-                            v5 = *v4;
+                    int v6 = v4; // v4 - dword_6FF464;
-                            ++v4;
+                    int v7 = dword_703E68[v1];
-                        }
+                    int v8 = v6 - 2;
-                        while ( v3 > v5 );
-                    }
-                    dword_6FF464[v1] = *(v4 - 2);
-                    *(v4 - 2) = v3;
-                    v6 = v4 - dword_6FF464;
-                    v7 = dword_703E68[v1];
-                    v8 = v6 - 2;
                     dword_70986C[v7] = v8;
-                    if ( v7 < 635 )
+                    if (v7 < 635)
-                        dword_709870[v7] = v8;
+                        dword_70986C[v7 + 1] = v8;
-                    v9 = dword_703E68[v8];
+                    int v9 = dword_703E68[v8];
                     dword_703E68[v8] = v7;
                     dword_70986C[v9] = v1;
-                    if ( v9 < 635 )
+                    if (v9 < 635)
-                        dword_709870[v9] = v1;
+                        dword_70986C[v9 + 1] = v1;
                     dword_703E68[v1] = v9;
                     v1 = v8;
                 }
@@ -257,94 +317,60 @@ namespace GameRes.Formats.Bom
 
         void sub_408D50 ()
         {
-            int v3; // ecx@2
-            int v4; // edi@3
-            int v5; // ecx@5
-            int *v6; // ebx@5
-            unsigned int v7; // eax@6
-            int *v8; // edx@6
-            int v9; // ecx@6
-            int *v10; // edi@6
-            unsigned int v11; // ebp@7
-            int v12; // ecx@8
-            int *i; // edi@8
-            int *v14; // eax@10
-            int *v15; // ecx@10
-            int v16; // edx@13
-            int *v17; // ecx@13
-            int v18; // eax@14
-            int v19; // [sp+10h] [bp-8h]@5
-            signed int v20; // [sp+14h] [bp-4h]@5
-
-            int v1 = 0;
             int v2 = 0;
             for (int i = 0; i < 635; ++i)
             {
                 int v3 = dword_703E68[i];
                 if (v3 >= 635)
                 {
-                    v4 = dword_6FF464[i];
+                    int v4 = dword_6FF464[i];
                     dword_703E68[v2] = v3;
-                    dword_6FF464[v2] = (int)((uint)(v4 + 1) >> 1);
+                    dword_6FF464[v2] = (v4 + 1) >> 1;
                     ++v2;
                 }
             }
             int v5 = 318;
-            v19 = 0;
+            int v19 = 0;
-            v20 = 318;
+            int v6 = 0; // dword_6FF464;
-            v6 = dword_6FF464;
+            int v1 = 0;
-            do
+            while (v1 < 317)
             {
-                v7 = *v6 + v6[1];
+                int v7 = dword_6FF464[v6] + dword_6FF464[v6 + 1];
-                v8 = &dword_6FF95C[v1];
+                int v9 = v5;
-                v9 = v5 - 1;
+                int v10 = v1 + 317; // &dword_6FF464[v1 + 317];
-                v10 = &dword_6FF95C[v1 - 1];
+                dword_6FF464[v1 + 318] = v7;
-                dword_6FF95C[v1] = v7;
+                while (v7 < dword_6FF464[v10])
-                if ( v7 < *v10 )
                 {
-                    do
+                    --v10;
-                    {
+                    --v9;
-                        v11 = *(v10 - 1);
-                        --v10;
-                        --v9;
-                    }
-                    while ( v7 < v11 );
                 }
-                v12 = v9 + 1;
+                int p = v9; // &dword_6FF464[v9]
-                for ( i = &dword_6FF464[v12]; v8 > i; --v8 )
+                for (int v8 = v1 + 318; v8 > p; --v8)
-                    *v8 = *(v8 - 1);
+                    dword_6FF464[v8] = dword_6FF464[v8 - 1];
-                *i = v7;
+                dword_6FF464[p] = v7;
-                v14 = &dword_704360[v1];
+
-                v15 = &dword_703E68[v12];
+                int v14 = v1 + 318; // &dword_703E68[v1 + 318];
-                if ( &dword_704360[v1] > v15 )
+                int v15 = v9; // &dword_703E68[v9];
+                while (v14 > v15)
                 {
-                    do
+                    dword_703E68[v14] = dword_703E68[v14 - 1];
-                    {
+                    --v14;
-                        *v14 = *(v14 - 1);
-                        --v14;
-                    }
-                    while ( v14 > v15 );
                 }
                 v6 += 2;
-                *v15 = v19;
+                dword_703E68[v15] = v19;
-                ++v1;
-                v5 = v20 + 1;
                 v19 += 2;
-                ++v20;
+                ++v5;
+                ++v1;
             }
-            while ( v1 < 317 );
+            int v16 = 0;
-            v16 = 0;
+            for (int i = 0; i < 635; ++i)
-            v17 = dword_703E68;
-            do
             {
-                v18 = *v17;
+                int v18 = dword_703E68[i];
-                if ( *v17 < 635 )
+                if (v18 < 635)
                     dword_70986C[v18 + 1] = v16;
                 dword_70986C[v18] = v16;
-                ++v17;
                 ++v16;
             }
-            while ( (signed int)v17 < (signed int)&unk_704854 );
         }
 
         void PutByte (int a1)
@@ -377,7 +403,8 @@ namespace GameRes.Formats.Bom
                 }
                 else
                 {
-                    m_output[m_dst++] = (byte)dword_6FFE54;
+                    if (m_dst < m_output.Length)
+                        m_output[m_dst++] = (byte)dword_6FFE54;
                     dword_6FFE54 = a1;
                 }
             }

Legacy/Discovery/ArcDAT.cs

@@ -33,6 +33,7 @@ using GameRes.Compression;
 
 // [000225][Discovery] Tsukiyo no Hitomi wa Kurenai ni
 // [001102][Discovery] Twins Rhapsody
+// [020414][Studio Air] Tamayura
 
 namespace GameRes.Formats.Discovery
 {
@@ -43,6 +44,7 @@ namespace GameRes.Formats.Discovery
         public int      BPP;
         public int      Colors;
         public int      Extra;
+        public bool     IsMask;
     }
 
     internal class EDataEntry : PackedEntry
@@ -102,12 +104,14 @@ namespace GameRes.Formats.Discovery
                 var entry = FormatCatalog.Instance.Create<BDataEntry> (name);
                 entry.Size         = index.ToUInt32 (index_offset+4);
                 entry.UnpackedSize = index.ToUInt32 (index_offset+8);
+                entry.IsPacked     = entry.Size != entry.UnpackedSize;
                 entry.Offset       = index.ToUInt32 (index_offset+0xC);
                 if (!entry.CheckPlacement (file.MaxOffset))
                     return null;
                 entry.Width  = index.ToUInt32 (index_offset+0x10);
                 entry.Height = index.ToUInt32 (index_offset+0x14);
                 entry.BPP    = index[index_offset+1];
+                entry.IsMask = index[index_offset+2] == 1;
                 entry.Extra  = index.ToUInt16 (index_offset+0x28);
                 entry.Colors = index.ToUInt16 (index_offset+0x2A);
                 dir.Add (entry);
@@ -263,6 +267,8 @@ namespace GameRes.Formats.Discovery
         ImageData       m_image;
         int             m_colors;
         int             m_extra;
+        bool            m_is_packed;
+        bool            m_is_mask;
 
         public Stream            Source { get { m_input.Position = 0; return m_input.AsStream; } }
         public ImageFormat SourceFormat { get { return null; } }
@@ -276,12 +282,17 @@ namespace GameRes.Formats.Discovery
         public BDataDecoder (ArcFile arc, BDataEntry entry)
         {
             Info = new ImageMetaData { Width = entry.Width, Height = entry.Height, BPP = entry.BPP };
+            m_is_packed = entry.IsPacked;
+            m_is_mask = entry.IsMask;
             uint total_size = entry.Size;
             total_size += (uint)entry.Colors * 4;
             if (entry.Extra > 0)
                 total_size += 10 * (uint)entry.Extra + 2;
-            Stride = ((int)entry.Width * entry.BPP / 8 + 3) & ~3;
+            int bpp = m_is_mask ? 8 : entry.BPP;
-            if (8 == entry.BPP)
+            Stride = ((int)entry.Width * bpp / 8 + 3) & ~3;
+            if (m_is_mask)
+                Format = PixelFormats.Gray8;
+            else if (8 == entry.BPP)
                 Format = PixelFormats.Indexed8;
             else
                 Format = PixelFormats.Bgr24;
@@ -298,9 +309,15 @@ namespace GameRes.Formats.Discovery
                 Palette = ImageFormat.ReadPalette (m_input.AsStream, m_colors);
             if (m_extra > 0)
                 m_input.Seek (10 * m_extra + 2, SeekOrigin.Current);
-            using (var lzss = new LzssStream (m_input.AsStream, LzssMode.Decompress, true))
+            if (m_is_packed)
-                lzss.Read (m_output, 0, m_output.Length);
+            {
-            return ImageData.CreateFlipped (Info, Format, Palette, m_output, Stride);
+                using (var lzss = new LzssStream (m_input.AsStream, LzssMode.Decompress, true))
+                    lzss.Read (m_output, 0, m_output.Length);
+            }
+            else
+                m_input.Read (m_output, 0, m_output.Length);
+            return m_is_mask ? ImageData.Create (Info, Format, Palette, m_output, Stride)
+                             : ImageData.CreateFlipped (Info, Format, Palette, m_output, Stride);
         }
 
         bool m_disposed = false;

Legacy/Koei/ArcYK.cs

@@ -0,0 +1,206 @@
+//! \file       ArcYK.cs
+//! \date       2023 Sep 10
+//! \brief      Koei data archive.
+//
+// Copyright (C) 2023 by morkt
+//
+// 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.
+//
+
+using GameRes.Utility;
+using System.Collections.Generic;
+using System.ComponentModel.Composition;
+using System.IO;
+using System.Windows.Media;
+
+// [990312][Koei] Yakusoku no Kizuna
+
+namespace GameRes.Formats.Koei
+{
+    internal class YkArchive : ArcFile
+    {
+        public readonly string YkName;
+
+        public YkArchive (ArcView arc, ArchiveFormat impl, ICollection<Entry> dir, string name)
+            : base (arc, impl, dir)
+        {
+            YkName = name;
+        }
+    }
+
+    internal class YkEntry : Entry
+    {
+        public int Id;
+    }
+
+    [Export(typeof(ArchiveFormat))]
+    public partial class YkOpener : ArchiveFormat
+    {
+        public override string         Tag => "YK";
+        public override string Description => "Koei resource archive";
+        public override uint     Signature => 0;
+        public override bool  IsHierarchic => false;
+        public override bool      CanWrite => false;
+
+        public override ArcFile TryOpen (ArcView file)
+        {
+            if (!file.Name.HasExtension (".YK"))
+                return null;
+            var name = Path.GetFileNameWithoutExtension (file.Name).ToUpperInvariant();
+            List<Entry> dir = null;
+            if ("DATA01" == name)
+                dir = GetData01Index (file);
+            else if (OffsetTable.ContainsKey (name))
+                dir = GetDataIndex (file, OffsetTable[name], name);
+            if (null == dir)
+                return null;
+            return new YkArchive (file, this, dir, name);
+        }
+
+        List<Entry> GetData01Index (ArcView file)
+        {
+            int count = (int)(file.MaxOffset / 0x4B400);
+            if (!IsSaneCount (count) || count * 0x4B400 != file.MaxOffset)
+                return null;
+            uint offset = 0;
+            var dir = new List<Entry> (count);
+            for (int i = 0; i < count; ++i)
+            {
+                var entry = new Entry {
+                    Name = string.Format ("{0:D5}.BMP", i),
+                    Type = "image",
+                    Offset = offset,
+                    Size = 0x4B400
+                };
+                dir.Add (entry);
+                offset += 0x4B400;
+            }
+            return dir;
+        }
+
+        List<Entry> GetDataIndex (ArcView file, uint[] offsets, string name)
+        {
+            var dir = new List<Entry> (offsets.Length);
+            uint current_offset = 0;
+            for (int i = 0; i < offsets.Length; ++i)
+            {
+                var entry = new YkEntry {
+                    Name = string.Format ("{0}#{1:D4}", name, i),
+                    Offset = current_offset,
+                    Size = offsets[i] - current_offset,
+                    Id = i
+                };
+                if (!entry.CheckPlacement (file.MaxOffset))
+                    return null;
+                if ("DATA02" == name && (i >= 11 || Data02Images.ContainsKey (i)))
+                {
+                    entry.Name += ".BMP";
+                    entry.Type = "image";
+                }
+                else if (IsAudio.Contains (name))
+                {
+                    entry.Name += ".WAV";
+                    entry.Type = "audio";
+                }
+                dir.Add (entry);
+                current_offset = offsets[i];
+            }
+            return dir;
+        }
+
+        public override Stream OpenEntry (ArcFile arc, Entry entry)
+        {
+            var yarc = (YkArchive)arc;
+            if ("DATA03" == yarc.YkName)
+            {
+                var data = arc.File.View.ReadBytes (entry.Offset, entry.Size);
+                DecryptData03 (data);
+                return new BinMemoryStream (data, entry.Name);
+            }
+            else if (IsAudio.Contains (yarc.YkName))
+                return OpenAudio (arc, entry);
+            else
+                return base.OpenEntry (arc, entry);
+        }
+
+        public override IImageDecoder OpenImage (ArcFile arc, Entry entry)
+        {
+            var yarc = (YkArchive)arc;
+            if (yarc.YkName == "DATA02")
+                return OpenData02Image (arc, (YkEntry)entry);
+            else if (yarc.YkName != "DATA01")
+                return base.OpenImage (arc, entry);
+            var input = arc.File.CreateStream (entry.Offset, entry.Size);
+            return new YkImageDecoder (input, new ImageMetaData { Width = 640, Height = 480, BPP = 8 });
+        }
+
+        IImageDecoder OpenData02Image (ArcFile arc, YkEntry entry)
+        {
+            ImageMetaData info;
+            if (entry.Id >= 189)
+                info = new ImageMetaData { Width = 128, Height = 192, BPP = 8 };
+            else if (!Data02Images.TryGetValue (entry.Id, out info) || null == info)
+                return base.OpenImage (arc, entry);
+            var input = arc.File.CreateStream (entry.Offset, entry.Size);
+            return new YkImageDecoder (input, info);
+        }
+
+        static readonly byte[] RiffHeader = new byte[] {
+            (byte)'R', (byte)'I', (byte)'F', (byte)'F', 0, 0, 0, 0,
+            (byte)'W', (byte)'A', (byte)'V', (byte)'E', (byte)'f', (byte)'m', (byte)'t', (byte)' ',
+        };
+
+        Stream OpenAudio (ArcFile arc, Entry entry)
+        {
+            var header = RiffHeader.Clone() as byte[];
+            LittleEndian.Pack (entry.Size+8u, header, 4);
+            var wave = arc.File.CreateStream (entry.Offset, entry.Size);
+            return new PrefixStream (header, wave);
+        }
+
+        unsafe void DecryptData03 (byte[] data)
+        {
+            int count = data.Length >> 2;
+            fixed (byte* data8 = &data[0])
+            {
+                uint* data32 = (uint*)data8;
+                while (count --> 0)
+                {
+                    *data32++ ^= 0x12C4D65u;
+                }
+            }
+        }
+    }
+
+    internal class YkImageDecoder : BinaryImageDecoder
+    {
+        public YkImageDecoder (IBinaryStream input, ImageMetaData info) : base (input, info)
+        {
+        }
+
+        protected override ImageData GetImageData ()
+        {
+            m_input.Position = 0;
+            var palette = ImageFormat.ReadPalette (m_input.AsStream);
+            int size = Info.iWidth * Info.iHeight;
+            var pixels = m_input.ReadBytes (size);
+            return ImageData.CreateFlipped (Info, PixelFormats.Indexed8, palette, pixels, Info.iWidth);
+        }
+    }
+}

Legacy/Koei/YkTables.cs

@@ -0,0 +1,923 @@
+//! \file       YkTables.cs
+//! \date       2023 Sep 10
+//! \brief      Koei data archives specifics.
+//
+
+using System.Collections.Generic;
+
+namespace GameRes.Formats.Koei
+{
+  public partial class YkOpener
+  {
+    internal static readonly HashSet<string> IsAudio = new HashSet<string> {
+      "DATA05", "DATA06", "DATA07", "DATA08", "DATA09", "DATA10", "DATA11", "DATA12", "DATA13", "DATA14", "DATA15",
+    };
+    internal static readonly Dictionary<int, ImageMetaData> Data02Images = new Dictionary<int, ImageMetaData>
+    {
+      {  0, new ImageMetaData { Width = 0x168, Height = 0x90, BPP = 8 } },
+      {  1, new ImageMetaData { Width = 0x510, Height = 0x3C0, BPP = 8 } },
+      {  2, new ImageMetaData { Width = 0x240, Height = 0x3C0, BPP = 8 } },
+      {  3, new ImageMetaData { Width = 0x280, Height = 0x286, BPP = 8 } },
+      {  4, null },
+      {  9, null },
+      { 10, null },
+      { 11, new ImageMetaData { Width = 888, Height = 480, BPP = 8 } },
+      { 12, new ImageMetaData { Width = 888, Height = 480, BPP = 8 } },
+      { 13, new ImageMetaData { Width = 888, Height = 480, BPP = 8 } },
+      { 14, new ImageMetaData { Width = 908, Height = 480, BPP = 8 } },
+      { 15, new ImageMetaData { Width = 544, Height = 480, BPP = 8 } },
+      { 16, new ImageMetaData { Width = 544, Height = 480, BPP = 8 } },
+      { 17, new ImageMetaData { Width = 304, Height = 480, BPP = 8 } },
+      { 18, new ImageMetaData { Width = 304, Height = 480, BPP = 8 } },
+      { 19, new ImageMetaData { Width = 312, Height = 480, BPP = 8 } },
+      { 20, new ImageMetaData { Width = 312, Height = 480, BPP = 8 } },
+      { 21, new ImageMetaData { Width = 304, Height = 480, BPP = 8 } },
+      { 22, new ImageMetaData { Width = 304, Height = 480, BPP = 8 } },
+      { 23, new ImageMetaData { Width = 304, Height = 480, BPP = 8 } },
+      { 24, new ImageMetaData { Width = 888, Height = 480, BPP = 8 } },
+      { 25, new ImageMetaData { Width = 236, Height = 480, BPP = 8 } },
+      { 26, new ImageMetaData { Width = 900, Height = 480, BPP = 8 } },
+      { 27, new ImageMetaData { Width = 860, Height = 480, BPP = 8 } },
+      { 28, new ImageMetaData { Width = 860, Height = 480, BPP = 8 } },
+      { 29, new ImageMetaData { Width = 860, Height = 480, BPP = 8 } },
+      { 30, new ImageMetaData { Width = 332, Height = 480, BPP = 8 } },
+      { 31, new ImageMetaData { Width = 204, Height = 480, BPP = 8 } },
+      { 32, new ImageMetaData { Width = 392, Height = 480, BPP = 8 } },
+      { 33, new ImageMetaData { Width = 880, Height = 480, BPP = 8 } },
+      { 34, new ImageMetaData { Width = 880, Height = 480, BPP = 8 } },
+      { 35, new ImageMetaData { Width = 332, Height = 480, BPP = 8 } },
+      { 36, new ImageMetaData { Width = 224, Height = 480, BPP = 8 } },
+      { 37, new ImageMetaData { Width = 356, Height = 480, BPP = 8 } },
+      { 38, new ImageMetaData { Width = 252, Height = 480, BPP = 8 } },
+      { 39, new ImageMetaData { Width = 292, Height = 480, BPP = 8 } },
+      { 40, new ImageMetaData { Width = 936, Height = 480, BPP = 8 } },
+      { 41, new ImageMetaData { Width = 960, Height = 480, BPP = 8 } },
+      { 42, new ImageMetaData { Width = 596, Height = 480, BPP = 8 } },
+      { 43, new ImageMetaData { Width = 940, Height = 480, BPP = 8 } },
+      { 44, new ImageMetaData { Width = 996, Height = 480, BPP = 8 } },
+      { 45, new ImageMetaData { Width = 936, Height = 480, BPP = 8 } },
+      { 46, new ImageMetaData { Width = 332, Height = 480, BPP = 8 } },
+      { 47, new ImageMetaData { Width = 372, Height = 480, BPP = 8 } },
+      { 48, new ImageMetaData { Width = 304, Height = 480, BPP = 8 } },
+      { 49, new ImageMetaData { Width = 452, Height = 480, BPP = 8 } },
+      { 50, new ImageMetaData { Width = 344, Height = 480, BPP = 8 } },
+      { 51, new ImageMetaData { Width = 936, Height = 480, BPP = 8 } },
+      { 52, new ImageMetaData { Width = 292, Height = 480, BPP = 8 } },
+      { 53, new ImageMetaData { Width = 252, Height = 480, BPP = 8 } },
+      { 54, new ImageMetaData { Width = 996, Height = 480, BPP = 8 } },
+      { 55, new ImageMetaData { Width = 908, Height = 480, BPP = 8 } },
+      { 56, new ImageMetaData { Width = 232, Height = 480, BPP = 8 } },
+      { 57, new ImageMetaData { Width = 232, Height = 480, BPP = 8 } },
+      { 58, new ImageMetaData { Width = 244, Height = 480, BPP = 8 } },
+      { 59, new ImageMetaData { Width = 372, Height = 480, BPP = 8 } },
+      { 60, new ImageMetaData { Width = 392, Height = 480, BPP = 8 } },
+      { 61, new ImageMetaData { Width = 948, Height = 480, BPP = 8 } },
+      { 62, new ImageMetaData { Width = 212, Height = 480, BPP = 8 } },
+      { 63, new ImageMetaData { Width = 908, Height = 480, BPP = 8 } },
+      { 64, new ImageMetaData { Width = 908, Height = 480, BPP = 8 } },
+      { 65, new ImageMetaData { Width = 352, Height = 480, BPP = 8 } },
+      { 66, new ImageMetaData { Width = 352, Height = 480, BPP = 8 } },
+      { 67, new ImageMetaData { Width = 312, Height = 480, BPP = 8 } },
+      { 68, new ImageMetaData { Width = 944, Height = 480, BPP = 8 } },
+      { 69, new ImageMetaData { Width = 944, Height = 480, BPP = 8 } },
+      { 70, new ImageMetaData { Width = 336, Height = 480, BPP = 8 } },
+      { 71, new ImageMetaData { Width = 944, Height = 480, BPP = 8 } },
+      { 72, new ImageMetaData { Width = 304, Height = 480, BPP = 8 } },
+      { 73, new ImageMetaData { Width = 304, Height = 480, BPP = 8 } },
+      { 74, new ImageMetaData { Width = 372, Height = 480, BPP = 8 } },
+      { 75, new ImageMetaData { Width = 284, Height = 480, BPP = 8 } },
+      { 76, new ImageMetaData { Width = 332, Height = 480, BPP = 8 } },
+      { 77, new ImageMetaData { Width = 284, Height = 480, BPP = 8 } },
+      { 78, new ImageMetaData { Width = 944, Height = 480, BPP = 8 } },
+      { 79, new ImageMetaData { Width = 264, Height = 480, BPP = 8 } },
+      { 80, new ImageMetaData { Width = 284, Height = 480, BPP = 8 } },
+      { 81, new ImageMetaData { Width = 312, Height = 480, BPP = 8 } },
+      { 82, new ImageMetaData { Width = 1008, Height = 480, BPP = 8 } },
+      { 83, new ImageMetaData { Width = 968, Height = 480, BPP = 8 } },
+      { 84, new ImageMetaData { Width = 608, Height = 480, BPP = 8 } },
+      { 85, new ImageMetaData { Width = 264, Height = 480, BPP = 8 } },
+      { 86, new ImageMetaData { Width = 272, Height = 480, BPP = 8 } },
+      { 87, new ImageMetaData { Width = 392, Height = 480, BPP = 8 } },
+      { 88, new ImageMetaData { Width = 372, Height = 480, BPP = 8 } },
+      { 89, new ImageMetaData { Width = 552, Height = 480, BPP = 8 } },
+      { 90, new ImageMetaData { Width = 324, Height = 480, BPP = 8 } },
+      { 91, new ImageMetaData { Width = 524, Height = 480, BPP = 8 } },
+      { 92, new ImageMetaData { Width = 968, Height = 480, BPP = 8 } },
+      { 93, new ImageMetaData { Width = 344, Height = 480, BPP = 8 } },
+      { 94, new ImageMetaData { Width = 304, Height = 480, BPP = 8 } },
+      { 95, new ImageMetaData { Width = 968, Height = 480, BPP = 8 } },
+      { 96, new ImageMetaData { Width = 272, Height = 480, BPP = 8 } },
+      { 97, new ImageMetaData { Width = 304, Height = 480, BPP = 8 } },
+      { 98, new ImageMetaData { Width = 968, Height = 480, BPP = 8 } },
+      { 99, new ImageMetaData { Width = 968, Height = 480, BPP = 8 } },
+      {100, new ImageMetaData { Width = 344, Height = 480, BPP = 8 } },
+      {101, new ImageMetaData { Width = 368, Height = 480, BPP = 8 } },
+      {102, new ImageMetaData { Width = 476, Height = 480, BPP = 8 } },
+      {103, new ImageMetaData { Width = 476, Height = 480, BPP = 8 } },
+      {104, new ImageMetaData { Width = 512, Height = 480, BPP = 8 } },
+      {105, new ImageMetaData { Width = 512, Height = 480, BPP = 8 } },
+      {106, new ImageMetaData { Width = 324, Height = 480, BPP = 8 } },
+      {107, new ImageMetaData { Width = 324, Height = 480, BPP = 8 } },
+      {108, new ImageMetaData { Width = 392, Height = 480, BPP = 8 } },
+      {109, new ImageMetaData { Width = 968, Height = 480, BPP = 8 } },
+      {110, new ImageMetaData { Width = 1196, Height = 480, BPP = 8 } },
+      {111, new ImageMetaData { Width = 968, Height = 480, BPP = 8 } },
+      {112, new ImageMetaData { Width = 968, Height = 480, BPP = 8 } },
+      {113, new ImageMetaData { Width = 404, Height = 480, BPP = 8 } },
+      {114, new ImageMetaData { Width = 324, Height = 480, BPP = 8 } },
+      {115, new ImageMetaData { Width = 976, Height = 480, BPP = 8 } },
+      {116, new ImageMetaData { Width = 976, Height = 480, BPP = 8 } },
+      {117, new ImageMetaData { Width = 224, Height = 480, BPP = 8 } },
+      {118, new ImageMetaData { Width = 384, Height = 480, BPP = 8 } },
+      {119, new ImageMetaData { Width = 392, Height = 480, BPP = 8 } },
+      {120, new ImageMetaData { Width = 976, Height = 480, BPP = 8 } },
+      {121, new ImageMetaData { Width = 384, Height = 480, BPP = 8 } },
+      {122, new ImageMetaData { Width = 296, Height = 480, BPP = 8 } },
+      {123, new ImageMetaData { Width = 976, Height = 480, BPP = 8 } },
+      {124, new ImageMetaData { Width = 976, Height = 480, BPP = 8 } },
+      {125, new ImageMetaData { Width = 976, Height = 480, BPP = 8 } },
+      {126, new ImageMetaData { Width = 324, Height = 480, BPP = 8 } },
+      {127, new ImageMetaData { Width = 324, Height = 480, BPP = 8 } },
+      {128, new ImageMetaData { Width = 332, Height = 480, BPP = 8 } },
+      {129, new ImageMetaData { Width = 992, Height = 480, BPP = 8 } },
+      {130, new ImageMetaData { Width = 992, Height = 480, BPP = 8 } },
+      {131, new ImageMetaData { Width = 272, Height = 480, BPP = 8 } },
+      {132, new ImageMetaData { Width = 284, Height = 480, BPP = 8 } },
+      {133, new ImageMetaData { Width = 384, Height = 480, BPP = 8 } },
+      {134, new ImageMetaData { Width = 184, Height = 480, BPP = 8 } },
+      {135, new ImageMetaData { Width = 984, Height = 480, BPP = 8 } },
+      {136, new ImageMetaData { Width = 992, Height = 480, BPP = 8 } },
+      {137, new ImageMetaData { Width = 656, Height = 480, BPP = 8 } },
+      {138, new ImageMetaData { Width = 544, Height = 480, BPP = 8 } },
+      {139, new ImageMetaData { Width = 480, Height = 480, BPP = 8 } },
+      {140, new ImageMetaData { Width = 404, Height = 480, BPP = 8 } },
+      {141, new ImageMetaData { Width = 524, Height = 480, BPP = 8 } },
+      {142, new ImageMetaData { Width = 404, Height = 480, BPP = 8 } },
+      {143, new ImageMetaData { Width = 312, Height = 480, BPP = 8 } },
+      {144, new ImageMetaData { Width = 444, Height = 480, BPP = 8 } },
+      {145, new ImageMetaData { Width = 640, Height = 480, BPP = 8 } },
+      {146, new ImageMetaData { Width = 392, Height = 480, BPP = 8 } },
+      {147, new ImageMetaData { Width = 324, Height = 480, BPP = 8 } },
+      {148, new ImageMetaData { Width = 96, Height = 96, BPP = 8 } },
+      {149, new ImageMetaData { Width = 96, Height = 96, BPP = 8 } },
+      {150, new ImageMetaData { Width = 96, Height = 96, BPP = 8 } },
+      {151, new ImageMetaData { Width = 96, Height = 96, BPP = 8 } },
+      {152, new ImageMetaData { Width = 96, Height = 96, BPP = 8 } },
+      {153, new ImageMetaData { Width = 96, Height = 96, BPP = 8 } },
+      {154, new ImageMetaData { Width = 96, Height = 96, BPP = 8 } },
+      {155, new ImageMetaData { Width = 96, Height = 96, BPP = 8 } },
+      {156, new ImageMetaData { Width = 96, Height = 96, BPP = 8 } },
+      {157, new ImageMetaData { Width = 96, Height = 96, BPP = 8 } },
+      {158, new ImageMetaData { Width = 96, Height = 96, BPP = 8 } },
+      {159, new ImageMetaData { Width = 96, Height = 96, BPP = 8 } },
+      {160, new ImageMetaData { Width = 96, Height = 96, BPP = 8 } },
+      {161, new ImageMetaData { Width = 96, Height = 96, BPP = 8 } },
+      {162, new ImageMetaData { Width = 96, Height = 96, BPP = 8 } },
+      {163, new ImageMetaData { Width = 96, Height = 96, BPP = 8 } },
+      {164, new ImageMetaData { Width = 96, Height = 96, BPP = 8 } },
+      {165, new ImageMetaData { Width = 96, Height = 96, BPP = 8 } },
+      {166, new ImageMetaData { Width = 96, Height = 96, BPP = 8 } },
+      {167, new ImageMetaData { Width = 96, Height = 96, BPP = 8 } },
+      {168, new ImageMetaData { Width = 96, Height = 96, BPP = 8 } },
+      {169, new ImageMetaData { Width = 96, Height = 96, BPP = 8 } },
+      {170, new ImageMetaData { Width = 96, Height = 96, BPP = 8 } },
+      {171, new ImageMetaData { Width = 96, Height = 96, BPP = 8 } },
+      {172, new ImageMetaData { Width = 96, Height = 96, BPP = 8 } },
+      {173, new ImageMetaData { Width = 96, Height = 96, BPP = 8 } },
+      {174, new ImageMetaData { Width = 96, Height = 96, BPP = 8 } },
+      {175, new ImageMetaData { Width = 96, Height = 96, BPP = 8 } },
+      {176, new ImageMetaData { Width = 96, Height = 96, BPP = 8 } },
+      {177, new ImageMetaData { Width = 96, Height = 96, BPP = 8 } },
+      {178, new ImageMetaData { Width = 96, Height = 96, BPP = 8 } },
+      {179, new ImageMetaData { Width = 96, Height = 96, BPP = 8 } },
+      {180, new ImageMetaData { Width = 256, Height = 128, BPP = 8 } },
+      {181, new ImageMetaData { Width = 256, Height = 128, BPP = 8 } },
+      {182, new ImageMetaData { Width = 256, Height = 128, BPP = 8 } },
+      {183, new ImageMetaData { Width = 256, Height = 128, BPP = 8 } },
+      {184, new ImageMetaData { Width = 256, Height = 128, BPP = 8 } },
+      {185, new ImageMetaData { Width = 256, Height = 128, BPP = 8 } },
+      {186, new ImageMetaData { Width = 256, Height = 128, BPP = 8 } },
+      {187, new ImageMetaData { Width = 256, Height = 128, BPP = 8 } },
+      {188, new ImageMetaData { Width = 256, Height = 128, BPP = 8 } },
+    };
+
+    internal static readonly Dictionary<string, uint[]> OffsetTable = new Dictionary<string, uint[]>
+    {
+      { "DATA02", new uint[] {
+        0x0CE84, 0x13CE84, 0x1C4284, 0x229584, 0x30A5BC, 0x30B8B8, 0x30BCA8, 0x30BFA8, 0x30C548, 0x3A9D80,
+        0x40FF38, 0x478438, 0x4E0938, 0x548E38, 0x5B38B8, 0x5F38B8, 0x6338B8, 0x6576B8, 0x67B4B8, 0x6A01B8,
+        0x6C4EB8, 0x6E8CB8, 0x70CAB8, 0x7308B8, 0x798DB8, 0x7B4C38, 0x81E7B8, 0x883838, 0x8E88B8, 0x94D938,
+        0x974BB8, 0x98CE38, 0x9BB138, 0x0A22738, 0x0A89D38, 0x0AB0FB8, 0x0ACB7B8, 0x0AF5738, 0x0B133B8,
+        0x0B35B38, 0x0BA3A38, 0x0C14638, 0x0C5A7B8, 0x0CC8E38, 0x0D3DDB8, 0x0DABCB8, 0x0DD2F38, 0x0DFECB8,
+        0x0E22AB8, 0x0E57E38, 0x0E80738, 0x0EEE638, 0x0F10DB8, 0x0F2EA38, 0x0FA39B8, 0x100E438, 0x1029B38,
+        0x1045238, 0x1061FB8, 0x108DD38, 0x10BC038, 0x112B5B8, 0x1144738, 0x11AF1B8, 0x1219C38, 0x1243438,
+        0x126CC38, 0x1291938, 0x1300738, 0x136F538, 0x1396F38, 0x1405D38, 0x1429B38, 0x144D938, 0x14796B8,
+        0x149AF38, 0x14C21B8, 0x14E3A38, 0x1552838, 0x1571B38, 0x15933B8, 0x15B80B8, 0x162E6B8, 0x16A01B8,
+        0x16E79B8, 0x1706CB8, 0x1726EB8, 0x17551B8, 0x1780F38, 0x17C1E38, 0x17E81B8, 0x1825C38, 0x1897738,
+        0x18C0038, 0x18E3E38, 0x1955938, 0x1975B38, 0x1999938, 0x1A0B438, 0x1A7CF38, 0x1AA5838, 0x1AD0E38,
+        0x1B08EB8, 0x1B40F38, 0x1B7D338, 0x1BB9738, 0x1BDFAB8, 0x1C05E38, 0x1C34138, 0x1CA5C38, 0x1D322B8,
+        0x1DA3DB8, 0x1E158B8, 0x1E45238, 0x1E6B5B8, 0x1EDDFB8, 0x1F509B8, 0x1F6B1B8, 0x1F985B8, 0x1FC68B8,
+        0x20392B8, 0x20666B8, 0x20895B8, 0x20FBFB8, 0x216E9B8, 0x21E13B8, 0x2207738, 0x222DAB8, 0x2254D38,
+        0x22C9538, 0x233DD38, 0x235DF38, 0x237F7B8, 0x23ACBB8, 0x23C28B8, 0x24361B8, 0x24AA9B8, 0x24F7BB8,
+        0x2537BB8, 0x25703B8, 0x259FD38, 0x25DD7B8, 0x260D138, 0x2631E38, 0x26662B8, 0x26B16B8, 0x26DF9B8,
+        0x2705D38, 0x2708538, 0x270AD38, 0x270D538, 0x270FD38, 0x2712538, 0x2714D38, 0x2717538, 0x2719D38,
+        0x271C538, 0x271ED38, 0x2721538, 0x2723D38, 0x2726538, 0x2728D38, 0x272B538, 0x272DD38, 0x2730538,
+        0x2732D38, 0x2735538, 0x2737D38, 0x273A538, 0x273CD38, 0x273F538, 0x2741D38, 0x2744538, 0x2746D38,
+        0x2749538, 0x274BD38, 0x274E538, 0x2750D38, 0x2753538, 0x2755D38, 0x275E138, 0x2766538, 0x276E938,
+        0x2776D38, 0x277F138, 0x2787538, 0x278F938, 0x2797D38, 0x27A0138, 0x27A6538, 0x27AC938, 0x27B2D38,
+        0x27B9138, 0x27BF538, 0x27C5938, 0x27CBD38, 0x27D2138, 0x27D8538, 0x27DE938, 0x27E4D38, 0x27EB138,
+        0x27F1538, 0x27F7938, 0x27FDD38, 0x2804138, 0x280A538, 0x2810938, 0x2816D38, 0x281D138, 0x2823538,
+        0x2829938, 0x282FD38, 0x2836138, 0x283C538, 0x2842938, 0x2848D38, 0x284F138, 0x2855538, 0x285B938,
+        0x2861D38, 0x2868138, 0x286E538, 0x2874938, 0x287AD38, 0x2881138, 0x2887538, 0x288D938, 0x2893D38,
+        0x289A138, 0x28A0538, 0x28A6938, 0x28ACD38, 0x28B3138, 0x28B9538, 0x28BF938, 0x28C5D38, 0x28CC138,
+        0x28D2538, 0x28D8938, 0x28DED38, 0x28E5138, 0x28EB538, 0x28F1938, 0x28F7D38, 0x28FE138, 0x2904538,
+        0x290A938, 0x2910D38, 0x2917138, 0x291D538, 0x2923938, 0x2929D38, 0x2930138, 0x2936538, 0x293C938,
+        0x2942D38, 0x2949138, 0x294F538, 0x2955938, 0x295BD38, 0x2962138, 0x2968538, 0x296E938, 0x2974D38,
+        0x297B138, 0x2981538, 0x2987938, 0x298DD38, 0x2994138, 0x299A538, 0x29A0938, 0x29A6D38, 0x29AD138,
+        0x29B3538, 0x29B9938, 0x29BFD38, 0x29C6138, 0x29CC538, 0x29D2938, 0x29D8D38, 0x29DF138, 0x29E5538,
+        0x29EB938, 0x29F1D38, 0x29F8138, 0x29FE538, 0x2A04938, 0x2A0AD38, 0x2A11138, 0x2A17538, 0x2A1D938,
+        0x2A23D38, 0x2A2A138, 0x2A30538, 0x2A36938, 0x2A3CD38, 0x2A43138, 0x2A49538, 0x2A4F938, 0x2A55D38,
+        0x2A5C138, 0x2A62538, 0x2A68938, 0x2A6ED38, 0x2A75138, 0x2A7B538, 0x2A81938, 0x2A87D38, 0x2A8E138,
+        0x2A94538, 0x2A9A938, 0x2AA0D38, 0x2AA7138, 0x2AAD538, 0x2AB3938, 0x2AB9D38, 0x2AC0138, 0x2AC6538,
+        0x2ACC938, 0x2AD2D38, 0x2AD9138, 0x2ADF538, 0x2AE5938, 0x2AEBD38, 0x2AF2138, 0x2AF8538, 0x2AFE938,
+        0x2B04D38, 0x2B0B138, 0x2B11538, 0x2B17938, 0x2B1DD38, 0x2B24138, 0x2B2A538, 0x2B30938, 0x2B36D38,
+        0x2B3D138, 0x2B43538, 0x2B49938, 0x2B4FD38, 0x2B56138, 0x2B5C538, 0x2B62938, 0x2B68D38, 0x2B6F138,
+        0x2B75538, 0x2B7B938, 0x2B81D38, 0x2B88138, 0x2B8E538, 0x2B94938, 0x2B9AD38, 0x2BA1138, 0x2BA7538,
+        0x2BAD938, 0x2BB3D38, 0x2BBA138, 0x2BC0538, 0x2BC6938, 0x2BCCD38, 0x2BD3138, 0x2BD9538, 0x2BDF938,
+        0x2BE5D38, 0x2BEC138, 0x2BF2538, 0x2BF8938, 0x2BFED38, 0x2C05138, 0x2C0B538, 0x2C11938, 0x2C17D38,
+      } },
+      { "DATA03", new uint[] {
+        0x6BC, 0x7D30, 0x0F284, 0x162E4, 0x1DBA8, 0x2475C, 0x2ADAC, 0x31B7C, 0x37D38, 0x3E290, 0x4288C,
+        0x47BA4, 0x4CB34, 0x5393C, 0x59610, 0x5EDC0, 0x64B64, 0x6C30C, 0x73130, 0x79C28, 0x809AC, 0x87438,
+        0x8E0DC, 0x956BC, 0x9A220, 0x0A0CC8, 0x0A716C, 0x0AA9A8, 0x0B1E08, 0x0B5AE8, 0x0B9900, 0x0BD3E4,
+        0x0C0870, 0x0C4144, 0x0C7E68, 0x0CBDB8, 0x0CEEE4, 0x0D43E0,
+      } },
+      { "DATA04", new uint[] {
+        0x3A88, 0x0C3AC, 0x14F38, 0x1DA30, 0x255AC, 0x2C970, 0x36DE4, 0x41010, 0x48E8C, 0x4CDE8,
+      } },
+      { "DATA05", new uint[] {
+        0x4200, 0x8420, 0x0CC40, 0x10CD0, 0x159B4, 0x1A0F8, 0x1E150, 0x427F0, 0x474B0, 0x4BAC8,
+        0x4FFFC, 0x554D8, 0x5A6FC, 0x5EA48, 0x6355C, 0x69010, 0x6E0AC, 0x739AC, 0x790A8, 0x7DE6C,
+        0x83260, 0x8972C, 0x8F510, 0x93790, 0x98AB0, 0x9D454, 0x0A202C, 0x0A706C, 0x0AB9FC, 0x0B0004,
+        0x0B5064, 0x0BA36C, 0x0BFA24, 0x0C34F0, 0x0C75D0, 0x0CC518, 0x0D0C0C, 0x0D58DC, 0x0DA2BC,
+        0x0DE650, 0x0E2BE8, 0x0E7FAC, 0x0ED424, 0x0F1818, 0x0F5E24, 0x0FAC18, 0x0FF058, 0x103A98,
+        0x108390, 0x10C6A0, 0x110964, 0x115E28, 0x11AEB8, 0x11FB6C, 0x124584, 0x129DA0, 0x12EA04,
+        0x1339F8, 0x138F00, 0x13DB0C, 0x142F98, 0x149154, 0x14F6A4
+      } },
+      { "DATA06", new uint[] {
+        0x3334, 0x89C4, 0x1EB24, 0x27760, 0x362D8, 0x37D50, 0x41388, 0x4456C, 0x4B108, 0x5FE54, 0x6ADD4,
+        0x759E8, 0x993E0, 0x0ACD08, 0x0B0900, 0x0B4744, 0x0BA3F0, 0x0BB4D0, 0x0CFBB0, 0x0D6520, 0x0DAABC,
+        0x0E6B5C, 0x0EAF48, 0x0FA0B0, 0x100788, 0x11472C, 0x11E2B8, 0x124320, 0x12C174, 0x12F5F0, 0x135558,
+        0x145AB4, 0x157E18, 0x169D60, 0x171884, 0x17F6E4, 0x187DAC, 0x19056C, 0x19CAD8, 0x1B5C68, 0x1C09EC,
+        0x1CC478, 0x1CF4E8, 0x1DBB04, 0x1E47C8, 0x1FB670, 0x201C08, 0x202F8C, 0x213CA0, 0x2255B8, 0x22C7CC,
+        0x22D4CC, 0x2322D0, 0x234FCC, 0x23ECBC, 0x240524, 0x24523C, 0x2475C0, 0x2494B8, 0x2572CC, 0x25A134,
+        0x277488, 0x2812B4, 0x2829F0, 0x290168, 0x2959A8, 0x29D960, 0x29F5A0, 0x29FFF8, 0x2A8604, 0x2CAB20,
+        0x2E3FBC, 0x300EB0, 0x323810, 0x33DC20, 0x34B414, 0x353BA4, 0x3675BC, 0x379C80, 0x37E748, 0x38261C,
+        0x393F9C, 0x39E7E0, 0x39FB90, 0x3ADA84, 0x3B626C, 0x3C4B44, 0x3C5970, 0x3C7860, 0x3CA370, 0x3D31F8,
+        0x3D7ABC, 0x3EAD10, 0x3F2198, 0x3F3D34, 0x3FE2E8, 0x407E20, 0x40F118, 0x40FB8C, 0x4168E4, 0x420D6C,
+        0x427AF4, 0x42B574, 0x42FBC0, 0x43C6BC, 0x4440F0, 0x448DBC, 0x455074, 0x45DB50, 0x473ED8, 0x48A2FC,
+        0x4A73D4, 0x4B6940, 0x4D38B4, 0x4DF6E8, 0x4ECAC8, 0x504DF4, 0x51C77C, 0x53079C, 0x55EE34, 0x56FF58,
+        0x5944AC, 0x5B7B2C, 0x5D4C4C, 0x5D73EC, 0x5E5F98, 0x5E6C04, 0x5F3228, 0x600F0C, 0x60F9C0, 0x621D50,
+        0x62EA84, 0x648A24, 0x64FE20, 0x6575A4, 0x6617D8, 0x66744C, 0x680F88, 0x6892EC, 0x6994B4, 0x6A2384,
+        0x6B6C00, 0x6C3C20, 0x6CE964, 0x6D646C, 0x6E3458, 0x6F6894, 0x707604, 0x717630, 0x71BA08, 0x7226CC,
+        0x7276FC, 0x72DB00, 0x747A8C, 0x75333C, 0x76CC18, 0x774FA0, 0x77A068, 0x782BB0, 0x795ADC, 0x7A3938,
+        0x7B3C48, 0x7BFDE8, 0x7CDFC8, 0x7D3604, 0x7D9FCC, 0x7DE2D0, 0x7EFC14, 0x7F0748, 0x7F89AC, 0x7FBD68,
+        0x7FF3EC, 0x800EE8, 0x80929C, 0x80E508, 0x8151BC, 0x81C2CC, 0x82B0E4, 0x8329B0, 0x836FB4, 0x838AC4,
+        0x83A67C, 0x842110, 0x84CC88, 0x85A488, 0x865A94, 0x8706B0, 0x885124, 0x8908D0, 0x8B3594, 0x8C02AC,
+        0x8C59AC, 0x8C9C68, 0x8CC1AC, 0x8D2CE0, 0x8E1EC4, 0x8E49A0, 0x8F7D40, 0x8FE08C, 0x90CA60, 0x91683C,
+        0x924B64, 0x928C58, 0x92D1F0, 0x938D10, 0x9452A8, 0x9517D8, 0x9534B0, 0x96097C, 0x963B90, 0x96E4F0,
+        0x98F5D0, 0x995C5C, 0x9A9160, 0x9AFEE4, 0x9B6BA4, 0x9BC9E4, 0x9CB074, 0x9D78A0, 0x9DF9E0, 0x9EC1B8,
+        0x9F13A8, 0x9F6688, 0x9F98B0, 0x0A01204, 0x0A07D14, 0x0A0EE3C, 0x0A15B48, 0x0A1A7F4, 0x0A27EF4,
+        0x0A40100, 0x0A50714, 0x0A52044, 0x0A6A20C, 0x0A71854, 0x0A842E8, 0x0A870EC, 0x0A940CC, 0x0A9A21C,
+        0x0AB0630, 0x0AB8F5C, 0x0ABD7B0, 0x0AE1FF4, 0x0AF2BD0, 0x0AFFA30, 0x0B00D3C, 0x0B0A8E4, 0x0B10EC8,
+        0x0B194B4, 0x0B1A7E8, 0x0B255CC, 0x0B2A0A4, 0x0B2DF10, 0x0B2FE00, 0x0B32A3C, 0x0B44600, 0x0B46D20,
+        0x0B47D60, 0x0B4F074, 0x0B67AB4, 0x0B69AA0, 0x0B6D6C4, 0x0B7519C, 0x0B7ABA4, 0x0B88D34, 0x0B96BB8,
+        0x0B9AD8C, 0x0BA49CC, 0x0BA6E24, 0x0BAD108, 0x0BBA7CC, 0x0BCCA70, 0x0BEF68C, 0x0C061C4, 0x0C08F60,
+        0x0C15BD4, 0x0C17A14, 0x0C2F7CC, 0x0C36374, 0x0C472C4, 0x0C51F5C, 0x0C56B74, 0x0C60464, 0x0C708C0,
+        0x0C79584, 0x0C7F8D8, 0x0C893F8, 0x0C8ADF8, 0x0C8EFD0, 0x0C92B9C, 0x0C978C4, 0x0C99FF8, 0x0C9BA90,
+        0x0CA4214, 0x0CACB7C, 0x0CBD21C, 0x0CBE5F4, 0x0CC581C, 0x0CCF618, 0x0CE3D2C, 0x0CE6E74, 0x0CF2A18,
+        0x0CF6C24, 0x0CFC384, 0x0D09080, 0x0D145D0, 0x0D19C28, 0x0D218F4, 0x0D2E164, 0x0D3DC10, 0x0D48DCC,
+        0x0D4FE98, 0x0D601D8, 0x0D638DC, 0x0D67568, 0x0D721F8, 0x0D7F2D8, 0x0D82F44, 0x0D87208, 0x0D88D04,
+        0x0D95EB4, 0x0D97B80, 0x0D9D008, 0x0DA3CB4, 0x0DB90D8, 0x0DC0990, 0x0DCA378, 0x0DDA048, 0x0DE0F00,
+        0x0DE4D3C, 0x0DE6C08, 0x0DFE818, 0x0E07C0C, 0x0E0C198, 0x0E0CCDC, 0x0E142BC, 0x0E17DBC, 0x0E1E4C0,
+        0x0E2257C, 0x0E2E54C, 0x0E3E7E4, 0x0E445F0, 0x0E5EFD8, 0x0E65C84, 0x0E692E4, 0x0E706F8, 0x0E72270,
+        0x0E773D0, 0x0E96DA0, 0x0E9FCEC, 0x0EAF170, 0x0EBC4D4, 0x0EBD028, 0x0ECB698, 0x0EDACD4, 0x0EE8B40,
+        0x0EEA230, 0x0EF2144, 0x0F0B50C, 0x0F14924, 0x0F1537C, 0x0F16338, 0x0F18880, 0x0F19BF4, 0x0F1ACCC,
+        0x0F1B9C8, 0x0F26D4C, 0x0F2F8F8, 0x0F34FF0, 0x0F3D598, 0x0F418C4, 0x0F46B00, 0x0F4C640, 0x0F53B04,
+        0x0F61B70, 0x0F74644, 0x0F8FA5C, 0x0F9FC9C, 0x0FADD7C, 0x0FD0654, 0x0FDB9E4, 0x0FF2C3C, 0x100646C,
+        0x100713C, 0x10174E8, 0x1026A1C, 0x1031A60, 0x103E358, 0x104A13C, 0x1053F6C, 0x105894C, 0x105FC70,
+        0x106A49C, 0x10708E0, 0x1079D44, 0x1097AA4, 0x10A730C, 0x10BA544, 0x10BB114, 0x10BCD58, 0x10D4904,
+        0x10E1C24, 0x10E46EC, 0x10E82F8, 0x10F3174, 0x10FC4CC, 0x1103BC4, 0x111593C, 0x111DEB0, 0x11403D0,
+        0x1141434, 0x1149764, 0x115405C, 0x1163CC8, 0x1178500, 0x1184D48, 0x1191CD0, 0x119B698, 0x11A34FC,
+        0x11BCE94, 0x11C1344, 0x11CC588, 0x11CDB90, 0x11DC41C, 0x11F273C, 0x11FB664, 0x1203444, 0x1209178,
+        0x1210AE0, 0x121162C, 0x121DA3C, 0x122A844, 0x122DFA8, 0x1233800, 0x1238724, 0x123BE60, 0x124A684,
+        0x124B1F0, 0x1251F7C, 0x1266424, 0x1276BAC, 0x127A9B4, 0x127B4C4, 0x1290F68, 0x1293FF8, 0x1294E28,
+        0x12A609C, 0x12B687C, 0x12C0400, 0x12CFECC, 0x12D11E4, 0x12D272C, 0x12D8888, 0x12F0C74, 0x12F3998,
+        0x12F781C, 0x12F8554, 0x12F9040, 0x12FCA10, 0x1310E7C, 0x131CEB0, 0x131EFF4, 0x131FB30, 0x1328854,
+        0x13324EC, 0x134474C, 0x134E220, 0x134FDA8, 0x13538E8, 0x1357720, 0x135E47C, 0x136E934, 0x137022C,
+        0x1377D8C, 0x137DCBC, 0x1382428, 0x13908A0, 0x1396EA8, 0x1397878, 0x13A4FE4, 0x13ABF94, 0x13B2724,
+        0x13BD230, 0x13BF38C, 0x13C45A4, 0x13D3C68, 0x13D7390, 0x13EF6BC, 0x1400AB8, 0x14109AC, 0x1424024,
+        0x143BFCC, 0x144C140, 0x146F748, 0x148576C, 0x14A9544, 0x14AEB2C, 0x14BB224, 0x14C1998, 0x14CD7C8,
+        0x14D23EC, 0x14DAF5C, 0x14EC448, 0x14EE89C, 0x14FE514, 0x1504534, 0x150ECB8, 0x151852C,
+      } },
+      { "DATA07", new uint[] {
+        0x6E44, 0x10A80, 0x17408, 0x20C78, 0x35274, 0x4DD44, 0x6836C, 0x7D8A8, 0x8CF64, 0x0A12A8, 0x0A712C,
+        0x0B37DC, 0x0C77B0, 0x0CE758, 0x0D6AB0, 0x0FF0B8, 0x125694, 0x12ADE8, 0x1302C0, 0x13E80C, 0x14BBE0,
+        0x1606FC, 0x167240, 0x1761D4, 0x1770F0, 0x183A94, 0x19218C, 0x1A73E0, 0x1B9044, 0x1D8D88, 0x1E2E34,
+        0x1F6BC4, 0x201F60, 0x20C850, 0x215A08, 0x21EF2C, 0x22F85C, 0x23BB10, 0x2436F4, 0x245ADC, 0x24DCDC,
+        0x250BB0, 0x25E924, 0x273630, 0x2868D8, 0x29B914, 0x2A0B04, 0x2AED68, 0x2B1108, 0x2BB328, 0x2C3C9C,
+        0x2C7370, 0x2CCF10, 0x2D5784, 0x2E671C, 0x2FAE6C, 0x308C40, 0x315E54, 0x323CF8, 0x326A38, 0x32F768,
+        0x3340B8, 0x33C728, 0x343850, 0x34C6C0, 0x3573F4, 0x36341C, 0x36556C, 0x375B90, 0x381EEC, 0x385958,
+        0x38C074, 0x399880, 0x39C298, 0x3A9308, 0x3B5F40, 0x3BB600, 0x3C7A6C, 0x3D026C, 0x3D3E18, 0x3DC3F4,
+        0x3F6A1C, 0x3FA1E4, 0x3FE6DC, 0x41628C, 0x41EA00, 0x422190, 0x424ADC, 0x440320, 0x45095C, 0x4567B4,
+        0x45CA6C, 0x469ACC, 0x47A2D0, 0x47C4D8, 0x4834CC, 0x493934, 0x4AA068, 0x4B9C60, 0x4BFEC4, 0x4C2AF8,
+        0x4CC418, 0x4E485C, 0x4E824C, 0x4EA7F8, 0x4FC810, 0x5124C0, 0x518E34, 0x519DF4, 0x52B2E0, 0x53B18C,
+        0x53BEB0, 0x53DD98, 0x53FED8, 0x549FC0, 0x561460, 0x56FF4C, 0x58F2F8, 0x596E24, 0x5AB058, 0x5B4FDC,
+        0x5B5EF8, 0x5C4730, 0x5CA11C, 0x5D8FB4, 0x5E2EFC, 0x5EC350, 0x5F90BC, 0x612FB8, 0x618FB0, 0x625B80,
+        0x632A28, 0x635B94, 0x643E4C, 0x647034, 0x64E1F0, 0x6532B0, 0x658810, 0x669394, 0x6739A4, 0x67BA9C,
+        0x682A9C, 0x690A54, 0x6A0A70, 0x6A608C, 0x6AD4A0, 0x6B1720, 0x6C1D18, 0x6C760C, 0x6CE948, 0x6D14F0,
+        0x6D3080, 0x6DB3C4, 0x6DFC2C, 0x6E7E14, 0x6F34EC, 0x703C8C, 0x720C40, 0x726BA0, 0x72EB2C, 0x7334DC,
+        0x7373E8, 0x73FAC8, 0x741E9C, 0x7477C4, 0x74E970, 0x75CEB0, 0x7739D4, 0x775D7C, 0x778D8C, 0x77DB4C,
+        0x780210, 0x7830D8, 0x795E54, 0x7A43B0, 0x7A6A68, 0x7A7CD8, 0x7AAF08, 0x7AC26C, 0x7B8C7C, 0x7C4B60,
+        0x7E07E4, 0x7FB7C8, 0x80E01C, 0x80EEFC, 0x8110FC, 0x826A3C, 0x836A84, 0x83D26C, 0x83FFA4, 0x84D9BC,
+        0x85A314, 0x86C5F0, 0x88450C, 0x89266C, 0x8A6034, 0x8AB804, 0x8B0A84, 0x8C41A4, 0x8C6754, 0x8D7B60,
+        0x8DFE18, 0x8E3CB0, 0x8EC00C, 0x8F1320, 0x8FB6B4, 0x908744, 0x9152A8, 0x91E7D8, 0x9202A4, 0x92C19C,
+        0x94B9DC, 0x94CF88, 0x959E2C, 0x961998, 0x962910, 0x965858, 0x969CF4, 0x96B73C, 0x9713C0, 0x97451C,
+        0x97FAB4, 0x986080, 0x98B878, 0x99DCB0, 0x9B23A0, 0x9C6CC8, 0x9C8B8C, 0x9D367C, 0x9D4A4C, 0x9DC794,
+        0x9E9538, 0x9F8608, 0x0A03624, 0x0A0D4B4, 0x0A1AF4C, 0x0A261FC, 0x0A3BC3C, 0x0A43420, 0x0A4597C,
+        0x0A50EE8, 0x0A600C0, 0x0A63888, 0x0A6AAC8, 0x0A6D260, 0x0A71BB4, 0x0A7E038, 0x0A88340, 0x0A9B490,
+        0x0AA7ED4, 0x0AB3E08, 0x0AB6A34, 0x0ABC6C0, 0x0ABFC20, 0x0AC6A9C, 0x0AD24B0, 0x0AEC388, 0x0AFAF34,
+        0x0B03074, 0x0B0E99C, 0x0B16314, 0x0B20258, 0x0B21268, 0x0B27BE0, 0x0B3111C, 0x0B365DC, 0x0B406CC,
+        0x0B43764, 0x0B465FC, 0x0B4AD48, 0x0B559F8, 0x0B66698, 0x0B6AB5C, 0x0B77758, 0x0B80B68, 0x0B89EDC,
+        0x0B91CFC, 0x0B97EB4, 0x0B9A8E4, 0x0BA0EB8, 0x0BAF038, 0x0BB79A0, 0x0BBD208, 0x0BC84D8, 0x0BCE5F8,
+        0x0BD3F00, 0x0BDA47C, 0x0BDE398, 0x0BF36C8, 0x0BFC390, 0x0C07DB8, 0x0C0D504, 0x0C153A4, 0x0C1AC04,
+        0x0C1D41C, 0x0C23C94, 0x0C325D4, 0x0C336A8, 0x0C35938, 0x0C45CA4, 0x0C4DBE4, 0x0C4F480, 0x0C5063C,
+        0x0C6A2A8, 0x0C6B704, 0x0C764B8, 0x0C77EC4, 0x0C80CE8, 0x0C894F0, 0x0C8EFC0, 0x0C9730C, 0x0C9EB3C,
+        0x0CA66F8, 0x0CADE4C, 0x0CB2BC8, 0x0CB4EF8, 0x0CB8F1C, 0x0CC70D8, 0x0CCBB60, 0x0CCE0E4, 0x0CECA4C,
+        0x0D02630, 0x0D07B6C, 0x0D09A74, 0x0D1CCD4, 0x0D2B708, 0x0D2CD4C, 0x0D3F11C, 0x0D47D18, 0x0D4D690,
+        0x0D596B8, 0x0D6653C, 0x0D6EFC4, 0x0D79818, 0x0D8C314, 0x0D98C2C, 0x0DA54D0, 0x0DB217C, 0x0DBBFB4,
+        0x0DC5050, 0x0DC693C, 0x0DC84D8, 0x0DCED1C, 0x0DD16E8, 0x0DD8DAC, 0x0DDBC00, 0x0DEB68C, 0x0DEDFE4,
+        0x0DF0CC4, 0x0DFC16C, 0x0E02568, 0x0E09C54, 0x0E0C834, 0x0E0DFA4, 0x0E0F778, 0x0E10B90, 0x0E1D518,
+        0x0E3B35C, 0x0E41A80, 0x0E4ABAC, 0x0E5AB84, 0x0E6B890, 0x0E6D4D4, 0x0E7A7E0, 0x0E7CD0C, 0x0E84600,
+        0x0E855B8, 0x0E8686C, 0x0E881B4, 0x0E91D94, 0x0E932F4, 0x0E954F8, 0x0EAD2AC, 0x0EB2E2C, 0x0EC4A78,
+        0x0ECE9C0, 0x0EE051C, 0x0EE11E8, 0x0EF6150, 0x0F1A7F0, 0x0F38EF0, 0x0F53310, 0x0F5D9F8, 0x0F5F9E0,
+        0x0F6BA74, 0x0F7E584, 0x0F876E8, 0x0F898C8, 0x0F9B1F0, 0x0FA8AA0, 0x0FC45CC, 0x0FE6BEC, 0x0FEFF58,
+        0x0FFFA44, 0x100AF28, 0x1012834, 0x101AA4C, 0x101FCC0, 0x1039790, 0x1047BB4, 0x105AC7C, 0x1064A7C,
+        0x1071628, 0x108AAC4, 0x108D4B0, 0x109877C, 0x10A5C48, 0x10B1030, 0x10BF594, 0x10C7E24, 0x10D2FD0,
+        0x10DB050, 0x10DC4CC, 0x10E0D40, 0x10E3770, 0x10E6C10, 0x10FF68C, 0x1119034, 0x1128BE8, 0x112E4A0,
+        0x1132F6C, 0x1143A70, 0x11474A0, 0x115C9F4, 0x116931C, 0x117E660, 0x11842C4, 0x119065C, 0x1196310,
+        0x119C548, 0x11A6944, 0x11B43C8, 0x11BBBC4, 0x11C40AC, 0x11CCAC4, 0x11D2F50, 0x11D7E68, 0x11E1F60,
+        0x11E92B8, 0x11FA0FC, 0x120B81C, 0x12167D4, 0x1219E90, 0x1222734, 0x122C6F0, 0x1237C5C, 0x1238C14,
+        0x1241C84, 0x124DA50, 0x125351C, 0x125F5F0, 0x126D218, 0x127753C, 0x127C308, 0x1286EA8, 0x129B24C,
+        0x12AC224, 0x12B1DDC, 0x12B7DF0, 0x12C4A2C, 0x12C726C, 0x12CD668, 0x12DF65C, 0x12F1134, 0x12F45C4,
+        0x12FD5CC, 0x13020A8, 0x130C918, 0x1325DA8, 0x133759C, 0x13386DC, 0x13395A4, 0x134DC28, 0x13595B4,
+        0x1364680, 0x136E0F0, 0x1374350, 0x137AB80, 0x1384D88, 0x138A4C8, 0x139EDCC, 0x13A84F8, 0x13BAF8C,
+        0x13BF90C, 0x13D1E20, 0x13D6CE4, 0x13E344C, 0x13F054C, 0x13FA61C, 0x14018F0, 0x1413444, 0x14293D4,
+        0x142FC0C, 0x1432170, 0x143D648, 0x1441AE0, 0x1469DC4, 0x147D92C, 0x1482DB4, 0x1489B54, 0x1497110,
+        0x14AD5E8, 0x14B9C58, 0x14C4360, 0x14C620C, 0x14D38D0, 0x14D9684, 0x14E401C, 0x14E80AC, 0x14F9564,
+        0x15151C0, 0x153B090, 0x153E848, 0x1546A70, 0x1557260, 0x155FFA0, 0x156865C, 0x1569DE8, 0x1571468,
+        0x157CB04, 0x15A30F0, 0x15AEB5C, 0x15B86E8, 0x15C45F0, 0x15D3294, 0x15D9E74, 0x15E4370, 0x15F4A1C,
+        0x1601104, 0x1611074, 0x161545C, 0x161BD40, 0x161CBC8, 0x16242F8, 0x16396DC, 0x1642E40, 0x164D8AC,
+        0x1658734, 0x16632B4, 0x166DB1C, 0x167CDC8, 0x1681904, 0x168FDFC, 0x1696504, 0x169EDE8, 0x16AF530,
+        0x16B3EE0, 0x16B694C, 0x16CB4C0, 0x16D0A20, 0x16D4A38, 0x16D9674, 0x16E4EF4, 0x16EACF4, 0x16EECE4,
+        0x16F2404, 0x16F6E34, 0x17021C4, 0x1707FDC, 0x170F96C, 0x171A214, 0x171E168, 0x172AE2C, 0x1734798,
+        0x1749704, 0x175684C, 0x1759FEC, 0x17654E0, 0x177295C, 0x1774D34, 0x177BC0C, 0x1780408, 0x1785AFC,
+        0x178FCCC, 0x1799734, 0x17A1920, 0x17AC288, 0x17C3EBC, 0x17D0C94, 0x17D4CDC, 0x17DAE30, 0x17E48A4,
+        0x17E57DC, 0x17EF5B0, 0x180ACEC, 0x180B9B0, 0x181414C, 0x18269AC, 0x1828850, 0x182F0A8, 0x18395F4,
+        0x183E1C8, 0x18400A4, 0x184D5DC, 0x1852D44, 0x185D8CC, 0x1868F8C, 0x186AD48, 0x187BC4C, 0x187DCF4,
+        0x1887200, 0x188DBF8, 0x18A434C, 0x18A948C, 0x18C218C, 0x18C3ABC, 0x18DE7D4, 0x18E3EE0, 0x18ED20C,
+        0x18F1CC8, 0x18F5958, 0x1909CDC, 0x19109E0, 0x191BA40, 0x1920110, 0x192D8B0, 0x1932E98, 0x1939088,
+        0x193B1E8, 0x1944CF4, 0x19498D8, 0x195A2B0, 0x1960A20, 0x1968398, 0x196B3F4, 0x1971408, 0x19751F0,
+        0x1989528, 0x19983AC, 0x1999DC4, 0x19A027C, 0x19A64E4, 0x19B18C4, 0x19BF864, 0x19CA384, 0x19CEAD0,
+        0x19D009C, 0x19D5FD4, 0x19D7B88, 0x19DD2B8, 0x19F4F14, 0x1A0527C, 0x1A0FF4C, 0x1A19948, 0x1A36888,
+        0x1A3E930, 0x1A3FC3C, 0x1A4334C, 0x1A46C50, 0x1A4B6E0, 0x1A5F6B8, 0x1A61590, 0x1A66330, 0x1A6D424,
+        0x1A782B8, 0x1A83C90, 0x1A93F18, 0x1A99C1C, 0x1AA1ABC, 0x1AA731C, 0x1AAA274, 0x1AB0AB8, 0x1ABF4AC,
+        0x1AC06D0, 0x1AC2610, 0x1AD39F8, 0x1ADB294, 0x1ADDF80, 0x1ADF038, 0x1AFBA04, 0x1B08870, 0x1B0A198,
+        0x1B0B5C8, 0x1B1B604, 0x1B2AAC8, 0x1B32654, 0x1B38D1C, 0x1B47A60, 0x1B54198, 0x1B66800, 0x1B74514,
+        0x1B7536C, 0x1B898F8, 0x1B96B7C, 0x1B9A774, 0x1B9DD98, 0x1BA6990, 0x1BA9498, 0x1BB4C90, 0x1BBB1D0,
+        0x1BC0800, 0x1BC4554, 0x1BCFB10, 0x1BE5A68, 0x1BEC460, 0x1BF6244, 0x1C05240, 0x1C0B80C, 0x1C0ED08,
+        0x1C10854, 0x1C14528, 0x1C16B30, 0x1C19048, 0x1C3BC8C, 0x1C50714, 0x1C70EAC, 0x1C8B6F0, 0x1CB3A0C,
+        0x1CD41DC, 0x1CE6A04, 0x1CFBA40, 0x1D14DC0, 0x1D1ABA4, 0x1D2F4B0, 0x1D47208, 0x1D57950, 0x1D600E4,
+        0x1D72D28, 0x1D83D2C,
+      } },
+      { "DATA08", new uint[] {
+        0x4A78, 0x0C2AC, 0x10B68, 0x17714, 0x214E0, 0x2C7D4, 0x3C880, 0x3D920, 0x49EEC, 0x535D4, 0x5F694,
+        0x6632C, 0x6B080, 0x74D60, 0x7FACC, 0x889E0, 0x9D8B8, 0x0AD8E8, 0x0B3AE8, 0x0B92CC, 0x0BC484,
+        0x0C22DC, 0x0CA9AC, 0x0D7488, 0x0DDB28, 0x0E974C, 0x0EBE00, 0x102698, 0x10A8C8, 0x10ECE4, 0x11B998,
+        0x1285D4, 0x139EDC, 0x13C604, 0x145F38, 0x1505C4, 0x155984, 0x166274, 0x16AC8C, 0x17F1BC, 0x1892C0,
+        0x191148, 0x1A0A20, 0x1A95FC, 0x1ADFA0, 0x1BBB80, 0x1C9D58, 0x1D2004, 0x1DC778, 0x1EE00C, 0x1FBB00,
+        0x206DF4, 0x20E348, 0x21606C, 0x217ED8, 0x22327C, 0x22B708, 0x232948, 0x24004C, 0x247FA0, 0x24D8B4,
+        0x25B194, 0x27122C, 0x27CC40, 0x28D004, 0x298B80, 0x2A8A9C, 0x2B5A9C, 0x2C67B8, 0x2D0D48, 0x2D87F4,
+        0x2E0C6C, 0x2EF078, 0x2F6A30, 0x2FC7EC, 0x306C14, 0x30E7AC, 0x3162CC, 0x322190, 0x332824, 0x339CC0,
+        0x345B84, 0x35DEA0, 0x371F0C, 0x38A838, 0x3A2FFC, 0x3B72BC, 0x3BE234, 0x3C8570, 0x3CA13C, 0x3DECF8,
+        0x3F483C, 0x3F899C, 0x40D5D0, 0x42A4D8, 0x433984, 0x44D348, 0x45B68C, 0x45D608, 0x46F85C, 0x47439C,
+        0x47E168, 0x490954, 0x496548, 0x4A2FF0, 0x4AF634, 0x4BF3D4, 0x4D7678, 0x4E4F3C, 0x4F9288, 0x50D764,
+        0x51252C, 0x513CB0, 0x525E1C, 0x53B62C, 0x541DB8, 0x556F80, 0x562628, 0x5685E0, 0x571730, 0x5824C0,
+        0x590754, 0x595EEC, 0x59B65C, 0x5B1F98, 0x5B5574, 0x5B9A80, 0x5BD8A4, 0x5C73B0, 0x5C88E8, 0x5C9F84,
+        0x5CBB3C, 0x5D51F4, 0x5D98F8, 0x5E6174, 0x5F980C, 0x609C6C, 0x622928, 0x63CB14, 0x64E8C8, 0x651F38,
+        0x65BF24, 0x672B28, 0x6777B4, 0x678A34, 0x68C318, 0x690CDC, 0x69EB74, 0x6A3538, 0x6A7374, 0x6AEE10,
+        0x6B8D88, 0x6B9AF4, 0x6C01C0, 0x6C6D28, 0x6D0CA0, 0x6D73E0, 0x6DE790, 0x6E6E9C, 0x6ED82C, 0x6FB0C8,
+        0x70D7B4, 0x719B90, 0x722050, 0x735420, 0x73DBA0, 0x73EF08, 0x7421C4, 0x74C13C, 0x755778, 0x75B498,
+        0x763FC8, 0x766608, 0x76FB34, 0x782514, 0x787F20, 0x7890EC, 0x78C574, 0x7945FC, 0x79A0FC, 0x7A6FDC,
+        0x7AA190, 0x7B61E8, 0x7BCB70, 0x7CFC60, 0x7DFB1C, 0x7EB0A4, 0x7F157C, 0x804B18, 0x808810, 0x809F08,
+        0x80FD4C, 0x81A2E0, 0x82B370, 0x83D120, 0x842424, 0x84438C, 0x857404, 0x85F410, 0x86723C, 0x870498,
+        0x872130, 0x87C7B8, 0x87F69C, 0x8923C8, 0x8A5878, 0x8AAEC0, 0x8B7DA0, 0x8BC5D8, 0x8CC328, 0x8DFD74,
+        0x8E7FDC, 0x8F91D0, 0x90EED8, 0x9221B4, 0x92A1C0, 0x93C244, 0x94C264, 0x952DCC, 0x95F874, 0x96D474,
+        0x980EC0, 0x996F88, 0x9AB1CC, 0x9B8C68, 0x9C6C28, 0x9CE07C, 0x9EB86C, 0x9FC71C, 0x0A0923C, 0x0A182E4,
+        0x0A2C004, 0x0A3EB50, 0x0A51624, 0x0A59904, 0x0A5F220, 0x0A6B890, 0x0A70ED8, 0x0A858A0, 0x0A8769C,
+        0x0A88704, 0x0A8A414, 0x0A99170, 0x0AAA094, 0x0ABFFF4, 0x0AC5A7C, 0x0AD6F84, 0x0AE6C9C, 0x0AF55C0,
+        0x0B0A878, 0x0B0D9B8, 0x0B151E8, 0x0B21400, 0x0B22E2C, 0x0B28078, 0x0B2932C, 0x0B34A0C, 0x0B3D9A0,
+        0x0B42920, 0x0B52F08, 0x0B53FDC, 0x0B6AB44, 0x0B7434C, 0x0B7B310, 0x0B7E158, 0x0B89EC4, 0x0B98B70,
+        0x0BA2A74, 0x0BAFB84, 0x0BB0B68, 0x0BC28B4, 0x0BD5BFC, 0x0BE36F8, 0x0BE4B10, 0x0C00060, 0x0C10FF4,
+        0x0C1240C, 0x0C215D8, 0x0C345D8, 0x0C48980, 0x0C54E68, 0x0C56BDC, 0x0C634F8, 0x0C6CED4, 0x0C765E4,
+        0x0C854E4, 0x0C95F80, 0x0CAE250, 0x0CC25F8, 0x0CD7CD0, 0x0CD8C3C, 0x0CD9C20, 0x0CE72D0, 0x0CECB38,
+        0x0CFD0AC, 0x0D027A8, 0x0D0AA9C, 0x0D11884, 0x0D1DC70, 0x0D2996C, 0x0D2EF00, 0x0D3C96C, 0x0D3D8D8,
+        0x0D52130, 0x0D624C4, 0x0D7CFCC, 0x0D8E0F0, 0x0D9A5D8, 0x0DA668C, 0x0DB56F4, 0x0DC4DD0, 0x0DD9724,
+        0x0DE4D34, 0x0DF77E0, 0x0E0A054, 0x0E2218C, 0x0E30B54, 0x0E3489C, 0x0E51654, 0x0E5CF50, 0x0E65B2C,
+        0x0E77BD0, 0x0E82900, 0x0E859E8, 0x0E9DEF4, 0x0EABA94, 0x0EB6D14, 0x0EC3BC0, 0x0ECC3C8, 0x0ED3FDC,
+        0x0EDD924, 0x0EE22A8, 0x0EF5860, 0x0EFD6AC, 0x0EFE980, 0x0F01AD8, 0x0F03530, 0x0F0A9C4, 0x0F17344,
+        0x0F1BE44, 0x0F31C3C, 0x0F3EC5C, 0x0F4B7EC, 0x0F4D55C, 0x0F6C2F0, 0x0F86130, 0x0F9DB74, 0x0FA910C,
+        0x0FC584C, 0x0FC6B90, 0x0FCD97C, 0x0FDA450, 0x0FE81B8, 0x0FFAC18, 0x1006850, 0x100BB3C, 0x100FB48,
+        0x1014978, 0x10274BC, 0x1028714, 0x1037E80, 0x103923C, 0x103DBB8, 0x1042000, 0x1047F2C, 0x105B544,
+        0x105C904, 0x1065224, 0x1075648, 0x1083CBC, 0x10860F8, 0x1093F68, 0x1099F80, 0x109F358, 0x10AAD3C,
+        0x10C4E1C, 0x10D91A8, 0x10DC9EC, 0x10F4C68, 0x110F3A4, 0x1110894, 0x1115830, 0x11242A8, 0x112858C,
+        0x1136F48, 0x114CF18, 0x115A184, 0x1165094, 0x116827C, 0x1171FE0, 0x1175280, 0x117ED10, 0x1180588,
+        0x1181F68, 0x1187838, 0x118B574, 0x11965F0, 0x11A4FB0, 0x11A64A0, 0x11A809C, 0x11A9C98, 0x11ABD8C,
+        0x11B1F88, 0x11C110C, 0x11CF580, 0x11D09C0, 0x11E1490, 0x11ED798, 0x11F6B08, 0x11FF390, 0x1200500,
+        0x1204684, 0x120699C, 0x121EC90, 0x1222FA4, 0x12331DC, 0x12430F8, 0x12455A0, 0x1248718, 0x124F5E0,
+        0x1258068, 0x12646AC, 0x126F5C8, 0x1274FA8, 0x127FF3C, 0x12844C0, 0x129126C, 0x12A5F7C, 0x12AE560,
+        0x12C7E64, 0x12C91E0, 0x12D1148, 0x12E1EE0, 0x12E688C, 0x12F6FAC, 0x1303754, 0x1304D20, 0x1308620,
+        0x1315268, 0x1333338, 0x133ABB0, 0x134A310, 0x134B77C, 0x13531D0, 0x1355498, 0x135C780, 0x135DAFC,
+        0x1364514, 0x136E5D8, 0x13831F8, 0x139010C, 0x13971A4, 0x13A19CC, 0x13AC7F8, 0x13BBA3C, 0x13C43D4,
+        0x13D4C58, 0x13E3AEC, 0x13EDA48, 0x13FDB60, 0x14093C4, 0x1418594, 0x1429848, 0x143DA38, 0x144C764,
+        0x145A61C, 0x146C2A8, 0x147A070, 0x1482A10, 0x149E2D4, 0x14A8EDC, 0x14AEAEC, 0x14B9FCC, 0x14BD810,
+        0x14C29E4, 0x14D5894, 0x14D6AB8, 0x14D8C34, 0x14E0A34, 0x14EC0F0, 0x14ED6CC, 0x14F5C3C, 0x14F9D6C,
+        0x1504114, 0x1505FC8, 0x15114A8, 0x152188C, 0x15249D8, 0x152DF90, 0x153FF4C, 0x154B3B4, 0x154E500,
+        0x1553FB0, 0x155D314, 0x156AB44, 0x15716AC, 0x157C8BC, 0x15822F0, 0x15838CC, 0x15A103C, 0x15AB5C0,
+        0x15AF574, 0x15B7DAC, 0x15C2B90, 0x15D199C, 0x15E457C, 0x15ECDB4, 0x15EF450, 0x15F6AE4, 0x1603864,
+        0x16054C8, 0x1608438, 0x160B240, 0x1619864, 0x1624988, 0x162C358, 0x163FA64, 0x164B260, 0x166470C,
+        0x167CC0C, 0x1685484, 0x168DD00, 0x1694E28, 0x169FF6C, 0x16A6D70, 0x16B477C, 0x16C0380, 0x16C5900,
+        0x16D2274, 0x16D61C8, 0x16DE32C, 0x16F9148, 0x16FD09C, 0x1701D58, 0x170BD3C, 0x17169A8, 0x1727D68,
+        0x173C194, 0x1746BB8, 0x1758824, 0x175B428, 0x1761738, 0x176D268, 0x1773088, 0x1778224, 0x177DB5C,
+        0x1786D70, 0x1794BA8, 0x17A46A0, 0x17ADC30, 0x17B6A58, 0x17C00CC, 0x17C1214, 0x17C9334, 0x17CCB34,
+        0x17D651C, 0x17DA794, 0x17DB94C, 0x17DE440, 0x17E4C94, 0x17EE374, 0x17F3138, 0x18032B4, 0x180E64C,
+        0x1811608, 0x181D3A0, 0x18273A0, 0x1833834, 0x1839920, 0x1846EA8, 0x1849C58, 0x184D6C4, 0x1851968,
+        0x1865E3C, 0x187B560, 0x1895020, 0x189EC3C, 0x18C1100, 0x18CA5CC, 0x18D511C, 0x18D8968, 0x18E4AC8,
+        0x18E5A3C, 0x18E8564, 0x18F7630, 0x18FB330, 0x1913588, 0x192C66C, 0x1938C08, 0x1954818, 0x196B7A4,
+        0x197D19C, 0x198BBD4, 0x1998DA4, 0x19ADB64, 0x19BCE14, 0x19C74B8, 0x19D0188, 0x19DEA5C, 0x19E564C,
+        0x19F1CDC, 0x19FE200, 0x1A10F1C, 0x1A2B378, 0x1A42CF4, 0x1A44558, 0x1A479E8, 0x1A4F02C, 0x1A598B0,
+        0x1A6CC9C, 0x1A7B8B4, 0x1A83240, 0x1A85B88, 0x1A8CF74, 0x1A9A39C, 0x1AA8380, 0x1AB7A68, 0x1AC5250,
+        0x1ACC6B8, 0x1ADBBC0, 0x1AE6E60, 0x1AF1CBC, 0x1B01348, 0x1B0E070, 0x1B192EC, 0x1B219B8, 0x1B2EBEC,
+        0x1B38B18, 0x1B44054, 0x1B49C6C, 0x1B4F628, 0x1B61DE4, 0x1B6A43C, 0x1B7C250, 0x1B8BA40, 0x1B96470,
+        0x1B99D14, 0x1BA94FC, 0x1BBE868, 0x1BC1F34, 0x1BC4F90, 0x1BE41A0, 0x1BEA064, 0x1BFCD30, 0x1C0A9FC,
+        0x1C1ED50, 0x1C25B44, 0x1C385C4, 0x1C485F4, 0x1C5F148, 0x1C682A8, 0x1C6A8AC, 0x1C73DA0, 0x1C89D98,
+        0x1CA6A24, 0x1CBD3EC, 0x1CC2080, 0x1CC4CA0, 0x1CCD55C, 0x1CD9060, 0x1CDB40C, 0x1CE1A78, 0x1CE5710,
+        0x1CEC398, 0x1CF80F4, 0x1D031A4, 0x1D09C4C, 0x1D21874, 0x1D277D0, 0x1D3A508, 0x1D4AA6C, 0x1D4DE14,
+        0x1D535EC, 0x1D5D6A0, 0x1D75D9C, 0x1D8C3F0, 0x1D97950, 0x1DAD9C4, 0x1DC024C, 0x1DC45F0, 0x1DD9408,
+        0x1DE1010, 0x1DE3C30, 0x1DEE288, 0x1E0391C, 0x1E18E30, 0x1E23AA4, 0x1E32AC0, 0x1E44D2C, 0x1E46FEC,
+        0x1E4F82C,
+      } },
+      { "DATA09", new uint[] {
+        0x7ED8, 0x17218, 0x25544, 0x362E4, 0x3F1BC, 0x40550, 0x4DBB0, 0x5CE38, 0x749D4, 0x7F278, 0x935CC,
+        0x9DF3C, 0x9F834, 0x0A1B6C, 0x0ABF30, 0x0AFF88, 0x0B6388, 0x0B9C38, 0x0C2A48, 0x0C3A30, 0x0CBB18,
+        0x0D2F6C, 0x0E25EC, 0x0E5630, 0x0E9768, 0x0FDE28, 0x106690, 0x10D720, 0x11751C, 0x129BAC, 0x13037C,
+        0x13151C, 0x13F2F0, 0x150A58, 0x16AB58, 0x182940, 0x191B70, 0x19ECC0, 0x1B7AEC, 0x1C5A70, 0x1E1118,
+        0x1E2528, 0x1E5DF8, 0x1EC6A8, 0x1FDE3C, 0x2071B0, 0x224614, 0x22F848, 0x23EB18, 0x24ADAC, 0x257C64,
+        0x263B2C, 0x26DAE4, 0x278D14, 0x284C6C, 0x28F9B0, 0x29B148, 0x2A5938, 0x2B0898, 0x2BBB8C, 0x2C58B8,
+        0x2C74D8, 0x2CDE20, 0x2E5A9C, 0x2ED75C, 0x2FA9C0, 0x30CF40, 0x32EB7C, 0x334464, 0x339998, 0x341858,
+        0x350938, 0x361394, 0x36FFD8, 0x37A27C, 0x383878, 0x38D610, 0x3976D4, 0x3A1CF0, 0x3BB3A8, 0x3CFEBC,
+        0x3D64A0, 0x3DF8AC, 0x3E27A4, 0x3ECD30, 0x3F0490, 0x3F7218, 0x40C018, 0x425E38, 0x43E6C0, 0x455800,
+        0x458AB0, 0x469AF0, 0x47D170, 0x48DD70, 0x495470, 0x496408, 0x4A0798, 0x4AD354, 0x4B5CE4, 0x4C8E44,
+        0x4DA0B8, 0x4EBC80, 0x4F1530, 0x4FAF48, 0x5026A8, 0x50E484, 0x51D620, 0x52585C, 0x52C3BC, 0x536BB4,
+        0x53BFC8, 0x53F9A8, 0x54B0C4, 0x565540, 0x57D2C8, 0x592748, 0x59B9C8, 0x5B7B90, 0x5C817C, 0x5DADD0,
+        0x5E79CC, 0x5EE3B0, 0x5F0460, 0x5F8F9C, 0x601558, 0x6137E4, 0x61FED4, 0x62D520, 0x6461CC, 0x647224,
+        0x64C924, 0x65089C, 0x65B0F4, 0x6655C0, 0x666AC0, 0x66B4C0, 0x671FB8, 0x67C900, 0x68A2B8, 0x68EC30,
+        0x692150, 0x6949DC, 0x6A7000, 0x6A850C, 0x6AC9EC, 0x6B03D0, 0x6B192C, 0x6C9618, 0x6E8D34, 0x6F0F74,
+        0x7172C8, 0x71E888, 0x7218F4, 0x7328AC, 0x73CE90, 0x73F494, 0x7415E4, 0x74D248, 0x7517FC, 0x759F70,
+        0x75C394, 0x768A58, 0x76D670, 0x76F800, 0x771EF8, 0x779880, 0x7904F4, 0x79986C, 0x7A25C8, 0x7AD5F8,
+        0x7C3F70, 0x7C5DF4, 0x7D180C, 0x7DDC30, 0x7E0070, 0x7E82EC, 0x7EF8D8, 0x7FAC00, 0x7FDE10, 0x807E30,
+        0x81F4B8, 0x832D80, 0x83A9BC, 0x84F684, 0x862270, 0x876D54, 0x879138, 0x87D9D0, 0x88A524, 0x88EE0C,
+        0x893B50, 0x896B8C, 0x89D33C, 0x8A3AF4, 0x8ACF90, 0x8B0924, 0x8D9438, 0x8EC124, 0x8F97AC, 0x8FF8D0,
+        0x90337C, 0x9177E4, 0x91A83C, 0x922F3C, 0x927130, 0x92A6EC, 0x930418, 0x94B96C, 0x952680, 0x95F8C8,
+        0x96883C, 0x974204, 0x98C598, 0x99A898, 0x9B2D64, 0x9BDBA4, 0x9C73B0, 0x9CB2C8, 0x9D651C, 0x9D9D84,
+        0x9DB214, 0x9E54A0, 0x9EB728, 0x9F1F1C, 0x9FE3D8, 0x0A08E20, 0x0A0B200, 0x0A0DEC4, 0x0A130C4,
+        0x0A15F94, 0x0A2B540, 0x0A371E8, 0x0A47110, 0x0A58730, 0x0A671C0, 0x0A76E60, 0x0A7E740, 0x0A8C150,
+        0x0A97ECC, 0x0A99F40, 0x0A9E740, 0x0AAAE90, 0x0AB4CE8, 0x0AC1518, 0x0AC5DA0, 0x0AC6E74, 0x0AD4C14,
+        0x0ADB9E8, 0x0AF4290, 0x0B00204, 0x0B0A780, 0x0B164E4, 0x0B1B108, 0x0B1C0FC, 0x0B1EFE4, 0x0B26C74,
+        0x0B2E8D0, 0x0B30224, 0x0B44698, 0x0B5806C, 0x0B6DACC, 0x0B87464, 0x0B9B944, 0x0BA0278, 0x0BA7940,
+        0x0BB1A0C, 0x0BB74D4, 0x0BBED7C, 0x0BC8694, 0x0BCF720, 0x0BD1A64, 0x0BD75A0, 0x0BE60AC, 0x0BEA0C4,
+        0x0BED4E8, 0x0BF1954, 0x0BF3D48, 0x0BF6258, 0x0BF8D0C, 0x0C09824, 0x0C0F3F4, 0x0C17E54, 0x0C350D0,
+        0x0C3F10C, 0x0C3FF8C, 0x0C4432C, 0x0C5F344, 0x0C655B8, 0x0C66CD8, 0x0C6897C, 0x0C83304, 0x0C8D440,
+        0x0C987A8, 0x0C9DC7C, 0x0C9EC74, 0x0CA2344, 0x0CAE020, 0x0CB97A8, 0x0CC4E40, 0x0CD1A2C, 0x0CD32A8,
+        0x0CDF6CC, 0x0CE2D80, 0x0CEFF80, 0x0CF0FE0, 0x0CF8104, 0x0D0D4E4, 0x0D0FEDC, 0x0D20ED8, 0x0D328A4,
+        0x0D3D9F0, 0x0D4F664, 0x0D67250, 0x0D77A90, 0x0D7E510, 0x0D8A0F8, 0x0D96FEC, 0x0DA0F44, 0x0DA998C,
+        0x0DB77F8, 0x0DBB29C, 0x0DC018C, 0x0DC8DE8, 0x0DD2E64, 0x0DE87E4, 0x0E051F4, 0x0E0B4F0, 0x0E0C578,
+        0x0E178A0, 0x0E280D8, 0x0E37BC4, 0x0E3B2B0, 0x0E44260, 0x0E504BC, 0x0E5F710, 0x0E6FF64, 0x0E81E98,
+        0x0E8FDF8, 0x0EA9BA4, 0x0ECA6D4, 0x0ED29A0, 0x0ED4AE8, 0x0ED6090, 0x0EE694C, 0x0F04638, 0x0F0CA24,
+        0x0F0E40C, 0x0F0F5F4, 0x0F15AE0, 0x0F2F8F4, 0x0F38FC8, 0x0F3BF60, 0x0F400E4, 0x0F4687C, 0x0F476C0,
+        0x0F48CDC, 0x0F56D30, 0x0F59AF0, 0x0F6949C, 0x0F6CE80, 0x0F837B8, 0x0F8D4B0, 0x0F908E8, 0x0F95B50,
+        0x0F9C468, 0x0FAED24, 0x0FBEBE8, 0x0FC8324, 0x0FCC1E4, 0x0FE4E9C, 0x0FE77A4, 0x0FE8B98, 0x0FEB774,
+        0x1009D4C, 0x1011B88, 0x10209B8, 0x102B088, 0x102EEF4, 0x1034484, 0x1036C34, 0x1039AE4, 0x103B974,
+        0x103F040, 0x1055920, 0x1063CE4, 0x106D3D4, 0x1084714, 0x108DCB0, 0x1092F24, 0x1097130, 0x109B548,
+        0x10A4B38, 0x10A8530, 0x10B1EB4, 0x10B37B4, 0x10B511C, 0x10D7500, 0x10EA9DC, 0x10FAEA0, 0x1106224,
+        0x110797C, 0x111CE9C, 0x1128F84, 0x113D200, 0x1148F6C, 0x114C790, 0x11549F8, 0x115CB04, 0x1169690,
+        0x11767E0, 0x118B720, 0x11916FC, 0x11A27DC, 0x11A8AA0, 0x11ABBF8, 0x11B4490, 0x11C1BEC, 0x11D47B4,
+        0x11DA060, 0x11EA540, 0x11F3E48, 0x1202FF4, 0x120ED08, 0x12126D8, 0x1220174, 0x1229974, 0x1238DDC,
+        0x123B624, 0x123CF3C, 0x1242350, 0x1243150, 0x1245A70, 0x124719C, 0x1249634, 0x124B3E8, 0x124D3B8,
+        0x125FDC8, 0x126EF60, 0x127680C, 0x127EC0C, 0x12863EC, 0x129BF38, 0x12A6078, 0x12A92DC, 0x12AE370,
+        0x12B9330, 0x12C8604, 0x12DB7B8, 0x12E87E8, 0x12F73AC, 0x13092B4, 0x1310EF0, 0x13196A0, 0x132FEE0,
+        0x133CA3C, 0x134AD6C, 0x13576E0, 0x135FFB4, 0x136282C, 0x13682A0, 0x136CDB4, 0x136DF84, 0x13734FC,
+        0x1379CFC, 0x13829B4, 0x1387858, 0x13969D4, 0x139ADA4, 0x13A048C, 0x13AA334, 0x13B9374, 0x13C1940,
+        0x13D4240, 0x13E0F94, 0x13F9124, 0x1408DD8, 0x140D910, 0x141833C, 0x141B43C, 0x14212C0, 0x142955C,
+        0x1435C0C, 0x144B1C0, 0x145B720, 0x14805D4, 0x1494004, 0x14A08A8, 0x14B3B9C, 0x14D2FB0, 0x14D3FA4,
+        0x14D51F8, 0x14E1B70, 0x14EEE20, 0x14F4860, 0x14FA334, 0x150309C, 0x150F998, 0x1528468, 0x152CBD8,
+        0x153D3A0, 0x1541B30,
+      } },
+      { "DATA10", new uint[] {
+        0x2550, 0x0C368, 0x15670, 0x1C950, 0x2572C, 0x26C84, 0x2F638, 0x3AF00, 0x3DF5C, 0x3F4C0, 0x47C74,
+        0x50F18, 0x584E0, 0x5D264, 0x6C20C, 0x788B0, 0x816B4, 0x83EE0, 0x85DF0, 0x9F6E8, 0x0A4AA0, 0x0B74F4,
+        0x0C76FC, 0x0C8C8C, 0x0CDE1C, 0x0DE8D0, 0x0F5284, 0x10971C, 0x10E9F8, 0x10FE5C, 0x1312D4, 0x13EA54,
+        0x1476E8, 0x16C614, 0x1838CC, 0x199158, 0x1A3D98, 0x1A96B4, 0x1BFBC8, 0x1D92A4, 0x1E41A0, 0x202880,
+        0x2074C4, 0x21CC14, 0x21EFA0, 0x2277F8, 0x2341F8, 0x23AA90, 0x243DB4, 0x257BD4, 0x25E508, 0x25FBB4,
+        0x265338, 0x26A0D0, 0x26DF74, 0x27D224, 0x286EF4, 0x28CCE4, 0x293A6C, 0x29E0A4, 0x2BD488, 0x2D021C,
+        0x2DB9DC, 0x2FDA14, 0x304FB4, 0x324FE8, 0x33A7F8, 0x34F8E0, 0x3513E8, 0x353730, 0x35F748, 0x37275C,
+        0x38614C, 0x3A2F00, 0x3AD230, 0x3C7EEC, 0x3E330C, 0x3F2D0C, 0x4091F0, 0x4122E4, 0x43109C, 0x440CB4,
+        0x446404, 0x447E58, 0x465574, 0x466E34, 0x46FE94, 0x47707C, 0x487570, 0x49B9F4, 0x4A6750, 0x4C7488,
+        0x4D866C, 0x4E62A0, 0x509278, 0x5235DC, 0x539CEC, 0x5545BC, 0x5591EC, 0x563098, 0x567F20, 0x570FDC,
+        0x580CD0, 0x591B5C, 0x5A0760, 0x5AFF60, 0x5BC7D8, 0x5C9A94, 0x5CB818, 0x5CCCC4, 0x5D65F0, 0x5DB4E0,
+        0x5DE568, 0x5E1674, 0x5EA2DC, 0x5EEA4C, 0x5F0710, 0x5F23E4, 0x5F6B98, 0x5F99D8, 0x604044, 0x60C5FC,
+        0x61BFBC, 0x6335D4, 0x63DF70, 0x644A7C, 0x64C690, 0x64E87C, 0x65771C, 0x662B08, 0x6645C0, 0x673CDC,
+        0x6755B8, 0x684C98, 0x6860AC, 0x6916E8, 0x695A5C, 0x69E524, 0x6A70C4, 0x6B91C0, 0x6BC83C, 0x6C4308,
+        0x6D68DC, 0x6DBEF4, 0x6E61A8, 0x6FEC58, 0x708194, 0x711554, 0x716C3C, 0x727908, 0x730944, 0x7475C4,
+        0x75BB2C, 0x75DDC0, 0x767A84, 0x76ED60, 0x7789C8, 0x77E838, 0x785170, 0x789434, 0x795CDC, 0x79ECF0,
+        0x7A5D80, 0x7AFF28, 0x7B74D4, 0x7BE820, 0x7DD560, 0x7EA710, 0x7FDBEC, 0x7FEDEC, 0x810BE0, 0x8126C8,
+        0x8267BC, 0x835DD0, 0x8526F4, 0x8576C4, 0x859428, 0x85AB9C, 0x85B9B0, 0x864148, 0x87CE90, 0x8886FC,
+        0x88AE0C, 0x890520, 0x8A4630, 0x8B9B34, 0x8D83D0, 0x8D9014, 0x8E43C8, 0x8F8040, 0x90CE50, 0x91DE40,
+        0x925F30, 0x939698, 0x9434BC, 0x94D6B0, 0x9557B0, 0x95E774, 0x96AE78, 0x986FE8, 0x989CEC, 0x9B6D24,
+        0x9BA948, 0x9C4964, 0x9D2C80, 0x9F30EC, 0x0A03668, 0x0A043C0, 0x0A1093C, 0x0A2B01C, 0x0A36DE8,
+        0x0A42C0C, 0x0A4B2E4, 0x0A4DC34, 0x0A4FEA8, 0x0A58E64, 0x0A5B084, 0x0A65008, 0x0A6B8B0, 0x0A744CC,
+        0x0A77FF4, 0x0A81D9C, 0x0A86A3C, 0x0A8BB2C, 0x0A93E60, 0x0A974E4, 0x0A9A830, 0x0A9C6D4, 0x0A9F398,
+        0x0AAA90C, 0x0AB7A9C, 0x0AC2B74, 0x0AD761C, 0x0AF2188, 0x0AF6DA8, 0x0AFF084, 0x0B17AF8, 0x0B193D8,
+        0x0B1A538, 0x0B1BA74, 0x0B20E3C, 0x0B2D850, 0x0B31438, 0x0B3FF00, 0x0B44614, 0x0B5E3CC, 0x0B6A4D0,
+        0x0B6B2D4, 0x0B724CC, 0x0B740A0, 0x0B7D670, 0x0B82508, 0x0B84204, 0x0B861D8, 0x0B9EFE4, 0x0BA7400,
+        0x0BA81F8, 0x0BBA3E0, 0x0BBBF2C, 0x0BC7EB8, 0x0BCD0A4, 0x0BD4A90, 0x0BD6C30, 0x0BDEC7C, 0x0BFFEB4,
+        0x0C07B30, 0x0C09660, 0x0C0B760, 0x0C11C8C, 0x0C272B0, 0x0C31F50, 0x0C3766C, 0x0C583D0, 0x0C78B0C,
+        0x0C8406C, 0x0CA5F40, 0x0CA6DB4, 0x0CB8EEC, 0x0CB9BFC, 0x0CBC8C8, 0x0CC4550, 0x0CE6F48, 0x0CEB918,
+        0x0D05FC0, 0x0D0918C, 0x0D17AE8, 0x0D37A20, 0x0D43A08, 0x0D5746C, 0x0D8089C, 0x0D945B0, 0x0DB5A68,
+        0x0DCD2BC, 0x0DDA4C0, 0x0DF3C38, 0x0DFE468, 0x0E188A0, 0x0E43E2C, 0x0E62D54, 0x0E69428, 0x0E728D8,
+        0x0E76EC0, 0x0E7ACCC, 0x0E7FF84, 0x0E84FDC, 0x0E8C0D8, 0x0E8F608, 0x0E9121C, 0x0E92ED8, 0x0E952A4,
+        0x0EA073C, 0x0EAF4F4, 0x0EB8A20, 0x0EC9B98, 0x0ED61C4, 0x0EE2560, 0x0EEABD4, 0x0EEC404, 0x0EFE038,
+        0x0F06080, 0x0F26F38, 0x0F3A6B8, 0x0F5B040, 0x0F5FCEC, 0x0F61CCC, 0x0F6E2D0, 0x0F6F294, 0x0F83AA8,
+        0x0F90880, 0x0F9B598, 0x0F9D20C, 0x0FA871C, 0x0FA9924, 0x0FB32E0, 0x0FCB5B0, 0x0FCD744, 0x0FDADD4,
+        0x0FE88F8, 0x0FE9FF0, 0x0FEB264, 0x0FFD95C, 0x1009324, 0x10150F8, 0x101B798, 0x1025E60, 0x102F4BC,
+        0x1031BEC, 0x1033278, 0x1036788, 0x103D660, 0x1040288, 0x1056058, 0x10645F0, 0x1068728, 0x10760F4,
+        0x108C340, 0x1092580, 0x109F6F0, 0x10AFB28, 0x10C0878, 0x10C1544, 0x10CD9C8, 0x10DC6DC, 0x10ECB80,
+        0x10F6584, 0x1100DA8, 0x11063E0, 0x11082C8, 0x110B5C8, 0x1113FCC, 0x113365C, 0x11487A0, 0x115F7CC,
+        0x116F024, 0x119432C, 0x11AF454, 0x11D4228, 0x11F8C48, 0x121C904, 0x1233064, 0x1244268, 0x1245CD4,
+        0x124CEF8, 0x124F878, 0x12585F0, 0x1273074, 0x1273C94, 0x12798F0, 0x1285E64, 0x12958E8, 0x12A0570,
+        0x12A7CA4, 0x12AA1F4, 0x12AD4E8, 0x12B08DC, 0x12B7738, 0x12BD974, 0x12BF7D8, 0x12C0914, 0x12CA2A4,
+        0x12D4898, 0x12DEF18, 0x12E9258, 0x12EBF58, 0x12F03A0, 0x1306CF8, 0x130CDB8, 0x131FFF0, 0x13227A8,
+        0x13355B0, 0x1336BAC, 0x1340A5C, 0x1343D3C, 0x134F388, 0x13645CC, 0x1370338, 0x13777EC, 0x137CDCC,
+        0x1386690, 0x139BAE8, 0x13A793C, 0x13B1318, 0x13CE438, 0x13E0E0C, 0x13EC668, 0x13ED634, 0x13FC150,
+        0x13FD44C, 0x141D6F8, 0x1429868, 0x14420C0, 0x144A7D4, 0x1460468, 0x146DE64, 0x1471BD4, 0x1478200,
+        0x1479770, 0x14879EC, 0x1490994, 0x149FA88, 0x14AA8EC, 0x14B52A0, 0x14B9C48, 0x14C5590, 0x14D28E4,
+        0x14E1D60, 0x14E6574, 0x14E8290, 0x14EDDDC, 0x14FA104, 0x1501728, 0x1508C18, 0x150C2E8, 0x151047C,
+        0x151CE4C, 0x151F66C, 0x1540238, 0x154957C, 0x155A214, 0x155BF04, 0x1567378, 0x157C8E0, 0x1585408,
+        0x158F81C, 0x15914A8, 0x159DCE0, 0x15B2614, 0x15C7970, 0x15D36C4, 0x15E0E20, 0x15E4DE4, 0x15EE6DC,
+        0x16073B8, 0x161B994, 0x1621CA8, 0x1629324, 0x162C23C, 0x1632B70, 0x163B230, 0x163DCE4, 0x164558C,
+        0x16463CC, 0x1650548, 0x165EE8C, 0x1668E0C, 0x167F1F4, 0x1693AF0, 0x16AC0AC, 0x16B45DC, 0x16C4FB8,
+        0x16D5E14, 0x16E3DA4, 0x1700634, 0x1708AA4, 0x1717078, 0x1717E3C, 0x17274A0, 0x1733854, 0x173E470,
+        0x1744264, 0x1746AF4, 0x174AE90, 0x1756E48, 0x175EE24, 0x1769E34, 0x176B6B0, 0x17756A0, 0x177ED54,
+        0x1792668, 0x17A9EA4, 0x17B5768, 0x17B8B00, 0x17C4B8C, 0x17CDA48, 0x17D321C, 0x17DC244, 0x17E4D08,
+        0x17E68B4, 0x17E7568, 0x17F1D88, 0x1807E4C, 0x180B1FC, 0x1818A88, 0x1823E00, 0x1833920, 0x183D818,
+        0x184AA78, 0x1853054, 0x186726C, 0x186858C, 0x18773EC, 0x1880F88, 0x18825F0, 0x188F1D8, 0x1897CFC,
+        0x18A5AC8, 0x18CD434, 0x18ED1CC, 0x18FDDD8, 0x1921440, 0x192B444, 0x19367C8, 0x193F178, 0x1947BA0,
+        0x195B294, 0x1967FF4, 0x19742BC, 0x1982898, 0x19842B0, 0x198DCB4, 0x1991DD4, 0x19983E0, 0x19A13CC,
+        0x19B6788, 0x19D0504, 0x19DA788, 0x19DC440, 0x19DEA00, 0x19E9070, 0x19EB004, 0x19FF030, 0x1A043E4,
+        0x1A17990, 0x1A18D58, 0x1A1CF58, 0x1A1F598, 0x1A2601C, 0x1A289F4, 0x1A33EF0, 0x1A3EBC0, 0x1A41068,
+        0x1A44E0C, 0x1A49980, 0x1A5BD64, 0x1A5DEAC, 0x1A68818, 0x1A6C058, 0x1A76D0C, 0x1A79B70, 0x1A7EB4C,
+        0x1A81CCC, 0x1A83D64, 0x1A87380, 0x1A881F8, 0x1A8A1B4, 0x1A9D5DC, 0x1AA8564, 0x1AC113C, 0x1AD2974,
+        0x1AEA384, 0x1AFDED8, 0x1B16BF0, 0x1B23F3C, 0x1B3ECBC, 0x1B5B168, 0x1B6259C, 0x1B796D4, 0x1B8706C,
+        0x1B999DC, 0x1B9ACB0, 0x1B9DE90, 0x1BA7A3C, 0x1BBED48, 0x1BCA510, 0x1BE3640, 0x1BF2E58, 0x1C06580,
+        0x1C18CE0, 0x1C3FA30, 0x1C4F87C, 0x1C58424, 0x1C6C5D0, 0x1C7C108, 0x1C8A5C4, 0x1CA0768, 0x1CB67F4,
+        0x1CB7E18, 0x1CB9EA4,
+      } },
+      { "DATA11", new uint[] {
+        0x43BC, 0x0E140, 0x22164, 0x283C4, 0x378A4, 0x395B8, 0x3B598, 0x492D4, 0x5100C, 0x5B638, 0x5C7D8,
+        0x60418, 0x6A2A0, 0x790CC, 0x94970, 0x0A2E34, 0x0AAE5C, 0x0ACF8C, 0x0BA8E0, 0x0C1034, 0x0C8608,
+        0x0CA6E8, 0x0D3990, 0x0D5150, 0x0DAD50, 0x0E6F28, 0x0F74D4, 0x0FBA14, 0x104988, 0x108648, 0x10A794,
+        0x10F570, 0x11010C, 0x111FEC, 0x11869C, 0x11C480, 0x1208E4, 0x124728, 0x133650, 0x1347F0, 0x13B6CC,
+        0x13F684, 0x14A45C, 0x153CD8, 0x169870, 0x186CA4, 0x199320, 0x1A54F4, 0x1ACC54, 0x1B4764, 0x1BBD54,
+        0x1C9F68, 0x1D0C60, 0x1E7D64, 0x1F0A80, 0x1FB908, 0x1FD3F0, 0x2090F4, 0x20A3F8, 0x21074C, 0x2154EC,
+        0x217BAC, 0x221358, 0x223E20, 0x23C304, 0x241DE0, 0x250548, 0x251930, 0x254308, 0x26443C, 0x26EE88,
+        0x272B78, 0x276A68, 0x27F9AC, 0x28BBD4, 0x296EC8, 0x297C84, 0x2A0CFC, 0x2A4CBC, 0x2AFF40, 0x2BEA94,
+        0x2D0FC0, 0x2D2928, 0x2E73B8, 0x2EBB28, 0x3077F0, 0x3110FC, 0x31CE34, 0x324BAC, 0x327A54, 0x337C1C,
+        0x3401A0, 0x3521B8, 0x359D88, 0x36F084, 0x3742D8, 0x37CA48, 0x393CB0, 0x396A2C, 0x39A720, 0x39F580,
+        0x3A6ECC, 0x3B210C, 0x3BC2BC, 0x3C3024, 0x3C74E0, 0x3CD368, 0x3E877C, 0x3FC000, 0x410480, 0x4269BC,
+        0x429E58, 0x42D69C, 0x436764, 0x446C00, 0x4487D4, 0x45FF70, 0x46E49C, 0x4769A0, 0x4893D8, 0x498760,
+        0x4ADADC, 0x4AEF78, 0x4B6050, 0x4BF1E0, 0x4D9D6C, 0x4E0A08, 0x4F582C, 0x50397C, 0x5064BC, 0x509030,
+        0x50EFEC, 0x51FD70, 0x52763C, 0x534B20, 0x53B0D4, 0x554884, 0x559DD8, 0x55B414, 0x56C054, 0x57D124,
+        0x58DD88, 0x5957AC, 0x59BD88, 0x5A72E4, 0x5B3DCC, 0x5BD3CC, 0x5C8BA8, 0x5D3884, 0x5DED08, 0x5EE6C4,
+        0x5F8E34, 0x6022E0, 0x60DCC0, 0x61089C, 0x61A9AC, 0x62C600, 0x63A25C, 0x63D070, 0x64F0AC, 0x651D8C,
+        0x658C10, 0x663A3C, 0x66ADC8, 0x679B58, 0x683708, 0x69039C, 0x6954C4, 0x696980, 0x6AC4A0, 0x6B048C,
+        0x6B441C, 0x6C31B0, 0x6C615C, 0x6D0AD4, 0x6D5ACC, 0x6D8694, 0x6E3FD8, 0x6EB4A4, 0x6FF3DC, 0x70D0D0,
+        0x71E404, 0x733E4C, 0x746AA0, 0x75A8B8, 0x75C098, 0x75CC6C, 0x763F28, 0x76D6D4, 0x77B1E4, 0x77E304,
+        0x79BBF8, 0x79E9F8, 0x7AB538, 0x7AC6BC, 0x7AE9F8, 0x7C2A60, 0x7C3574, 0x7C7B2C, 0x7C8F48, 0x7CB950,
+        0x7CFAD4, 0x7D5E74, 0x7DCBDC, 0x7E7400, 0x809544, 0x820228, 0x836F78, 0x83AD78, 0x83BE98, 0x83CF48,
+        0x844E7C, 0x84DE78, 0x867778, 0x868738, 0x87D0F8, 0x881130, 0x886BFC, 0x89A2F0, 0x89B88C, 0x8A5D28,
+        0x8A983C, 0x8AFB80, 0x8B7038, 0x8BC194, 0x8C6C88, 0x8C804C, 0x8CE680, 0x8D2B10, 0x8DBA2C, 0x8F91D4,
+        0x8FE450, 0x908C68, 0x90A2E4, 0x91B168, 0x92978C, 0x92B500, 0x93667C, 0x946808, 0x9477A8, 0x953DFC,
+        0x9658B8, 0x96D5B8, 0x973A80, 0x979EA0, 0x985DDC, 0x987500, 0x98E2D4, 0x98F824, 0x99C618, 0x9A9FCC,
+        0x9B1574, 0x9BAD44, 0x9BEEEC, 0x9C59B0, 0x9C9E38, 0x9CBD94, 0x9D1794, 0x9DAD3C, 0x9E5CCC, 0x9E8284,
+        0x9E9720, 0x9F1000, 0x9F9C04, 0x0A09EE0, 0x0A0E7B4, 0x0A133DC, 0x0A13D24, 0x0A1CCCC, 0x0A1EC4C,
+        0x0A23450, 0x0A2DC90, 0x0A301BC, 0x0A32D90, 0x0A3535C, 0x0A5BA88, 0x0A70F60, 0x0A8D45C, 0x0A9E138,
+        0x0AAD518, 0x0ACDBD8, 0x0AE9A74, 0x0AFAFB0, 0x0AFE760, 0x0B16668, 0x0B1BAEC, 0x0B1DC2C, 0x0B24CD8,
+        0x0B36B0C, 0x0B37C4C, 0x0B47108, 0x0B52848, 0x0B57370, 0x0B5F3E8, 0x0B60DE0, 0x0B6C124, 0x0B84280,
+        0x0B9371C, 0x0B99C50, 0x0BA67A4, 0x0BAFB98, 0x0BB0C48, 0x0BB5334, 0x0BB9CAC, 0x0BCA7BC, 0x0BDD124,
+        0x0BEC11C, 0x0BF420C, 0x0BF9AA8, 0x0C09EEC, 0x0C1C244, 0x0C2C698, 0x0C34A28, 0x0C39E08, 0x0C4B9BC,
+        0x0C4E9C4, 0x0C68218, 0x0C75A48, 0x0C76D60, 0x0C7A950, 0x0C7F5C0, 0x0C8605C, 0x0C8A080, 0x0C97EBC,
+        0x0C9B744, 0x0CA5B78, 0x0CA9704, 0x0CB2000, 0x0CB55E8, 0x0CBB984, 0x0CBE2BC, 0x0CC4538, 0x0CD2238,
+        0x0CEE140, 0x0CF1604, 0x0CF6168, 0x0D012D0, 0x0D06B90, 0x0D0C0C4, 0x0D10BA0, 0x0D1C07C, 0x0D20E08,
+        0x0D2FDDC, 0x0D3DE94, 0x0D5014C, 0x0D60F20, 0x0D62DF4, 0x0D640A0, 0x0D6A6D0, 0x0D6C554, 0x0D74874,
+        0x0D82C58, 0x0D87428, 0x0D94B3C, 0x0D9B5D0, 0x0DA5B4C, 0x0DA91CC, 0x0DAC020, 0x0DB1230, 0x0DBBBCC,
+        0x0DCCF58, 0x0DD3354, 0x0DDE6D4, 0x0DE0EA4, 0x0DF2E08, 0x0DF7144, 0x0E01C84, 0x0E0B3A4, 0x0E1E398,
+        0x0E22F74, 0x0E44E9C, 0x0E5AF4C, 0x0E5C418, 0x0E5D5B8, 0x0E655A4, 0x0E75F2C, 0x0E80F60, 0x0E8882C,
+        0x0E9AA04, 0x0E9BE18, 0x0E9F5B0, 0x0EA5F68, 0x0EAB4D4, 0x0EB045C, 0x0EB6764, 0x0EBE8A8, 0x0EC2898,
+        0x0EC8294, 0x0ECD1AC, 0x0ED6450, 0x0EE5994, 0x0EF0158, 0x0EF5AC4, 0x0EF7194, 0x0F05780, 0x0F13E18,
+        0x0F18850, 0x0F3B358, 0x0F483A0, 0x0F53D3C, 0x0F6AB20, 0x0F8C2BC, 0x0F958CC, 0x0FB6B8C, 0x0FC7A6C,
+        0x0FD7DF0, 0x0FE79EC, 0x0FF85A0, 0x10183BC, 0x1027E30, 0x1042230, 0x104FD80, 0x1064460, 0x10687E4,
+        0x107ADEC, 0x107F324, 0x108764C, 0x108EF14, 0x109392C, 0x10952C0, 0x109BDBC, 0x10A3950, 0x10AC844,
+        0x10C4518, 0x10C7F28, 0x10CA3C0, 0x10D56E8, 0x10DB840, 0x10E4664, 0x10ECBA8, 0x10F6440, 0x10FC9CC,
+        0x1112ABC, 0x1114924, 0x1123FEC, 0x112AAC4, 0x112F090, 0x113D528, 0x1149A9C, 0x1154ED0, 0x1161424,
+        0x117F148, 0x1194440, 0x119EDA0, 0x11AD2B4, 0x11C9E54, 0x11D5760, 0x11F76CC, 0x1201BA8, 0x1215EAC,
+        0x12183B0, 0x1219774, 0x122F0B0, 0x123750C, 0x124BE7C, 0x124C948, 0x124DF2C, 0x1259DB0, 0x125CF8C,
+        0x125EEE0, 0x126278C, 0x126AF60, 0x126FF80, 0x1271918, 0x127B3B8, 0x12881D4, 0x1297C18, 0x129E6DC,
+        0x12A1664, 0x12AB23C, 0x12AF778, 0x12B0304, 0x12BBF30, 0x12CC3E8, 0x12D4468, 0x12DD79C, 0x12E7344,
+        0x12F1C04, 0x1301330, 0x130ABD8, 0x1316B28, 0x13206B0, 0x1323088, 0x1323B84, 0x1325AB8, 0x13294CC,
+        0x132F8F8, 0x1334F58, 0x1340440, 0x134E648, 0x13590A0, 0x1362084, 0x1377460, 0x13803BC, 0x13818C8,
+        0x13836B4, 0x138F044, 0x1396014, 0x13A11C0, 0x13A7CA8, 0x13AEC74, 0x13AFF08, 0x13B538C, 0x13B8328,
+        0x13C5B08, 0x13C7510, 0x13D1810, 0x13D3E58, 0x13D8BF4, 0x13DDBAC, 0x13DFAB4, 0x13E7CC4, 0x13EC948,
+        0x13F5BE4, 0x13F7C84, 0x14098C4, 0x140AC68, 0x140C36C, 0x1413B30, 0x1416F00, 0x141BC8C, 0x14239C8,
+        0x14271E0, 0x1438878, 0x1443AD4, 0x144D11C, 0x144E5C0, 0x14513E8, 0x14576A8, 0x145C098, 0x1465690,
+        0x1475B50, 0x147A964, 0x1484BDC, 0x148A73C, 0x14957C0, 0x14A1838, 0x14A2DC0, 0x14B32F8, 0x14BCB60,
+        0x14C60FC, 0x14CC3FC, 0x14DC074, 0x14E4518, 0x14ED2E0, 0x14FE514, 0x1506E18, 0x1510780, 0x151471C,
+        0x151B194, 0x154BB34, 0x1555060, 0x155AAB8, 0x155B804, 0x15668C4, 0x156A30C, 0x157E6D8, 0x15918C8,
+        0x1599070, 0x15A22CC, 0x15AA6CC, 0x15B7D34, 0x15CBAC8, 0x15CDBD0, 0x15D6388, 0x15E198C, 0x15E8E64,
+        0x15F3044, 0x15F8404, 0x16049F0, 0x160C798, 0x160F9F0, 0x1620948, 0x16308E0, 0x163204C, 0x1642934,
+        0x165DEB0, 0x166A3C8, 0x1676AB0, 0x1679560, 0x167ACB8, 0x168478C, 0x1693580, 0x1698460, 0x16A4F3C,
+        0x16B7AD8, 0x16C5B94, 0x16DAE5C, 0x16F35B4, 0x1702D34, 0x171310C, 0x1727490, 0x172B3D0, 0x173F6D4,
+        0x174C008, 0x1759A88, 0x175F1FC, 0x1761B18, 0x176C8BC, 0x1779EB0, 0x1780D94, 0x1785FF8, 0x17887A0,
+        0x178D50C, 0x179DDDC, 0x17A8E94, 0x17B2130, 0x17C49FC, 0x17CB09C, 0x17D12A8, 0x17D90C4, 0x17DFD3C,
+        0x17E0930, 0x17E5AA0, 0x17E6CD0, 0x17F20E4, 0x17F7A74, 0x1807EE4, 0x181D1E0, 0x182DB80, 0x183D740,
+        0x183E910, 0x18400A4, 0x1844100, 0x1847670, 0x1852C40, 0x18536EC, 0x185A9D4, 0x1862474, 0x1871D60,
+        0x1874A54, 0x188667C, 0x189A0E8, 0x189DD1C, 0x18A4D34, 0x18ABEBC, 0x18B3D98, 0x18B7CFC, 0x18CC160,
+        0x18D7460, 0x18E5270, 0x18F5520, 0x18F6854, 0x18FA668, 0x190C234, 0x191B4F0, 0x191C4B8, 0x19228A4,
+        0x192A328, 0x1934A24, 0x193DAB8, 0x19436C4, 0x1945674, 0x194762C, 0x195C010, 0x19635E0, 0x19708F4,
+        0x1972534, 0x1976618, 0x19853B8, 0x198DAA0, 0x199ED5C, 0x19A3080, 0x19A9704, 0x19AADB4, 0x19B9608,
+        0x19C59AC, 0x19C8F90, 0x19D5258, 0x19E9DBC, 0x19F16A8, 0x19F248C, 0x19FB968, 0x1A0583C, 0x1A172F0,
+        0x1A1C8AC, 0x1A1E6CC, 0x1A272B8, 0x1A40C78, 0x1A5D948, 0x1A75730, 0x1A8C4AC, 0x1A8D150, 0x1A9238C,
+        0x1A9A22C, 0x1AA7E28, 0x1ABA918, 0x1AC1238, 0x1ACD3F8, 0x1ADA93C, 0x1AE06D0, 0x1AE1B14, 0x1AF15D0,
+        0x1B05434, 0x1B102FC, 0x1B1BF98, 0x1B24BBC, 0x1B365C4, 0x1B449E0, 0x1B4DD10, 0x1B6074C, 0x1B660C8,
+        0x1B67460, 0x1B6B0F8, 0x1B72400, 0x1B7ABD0, 0x1B829C0, 0x1B87FC4, 0x1B8CB3C, 0x1B99314, 0x1B9C7C8,
+        0x1BAA5EC, 0x1BAE828, 0x1BAF8A8, 0x1BB92F0, 0x1BBDBB0, 0x1BC99E8, 0x1BD50B8, 0x1BDBA54, 0x1BDC9E8,
+        0x1BE6E04, 0x1BEB62C, 0x1BF343C, 0x1BFE2E0, 0x1C05658, 0x1C0F204, 0x1C14588, 0x1C1A834, 0x1C1CEC8,
+        0x1C22E28, 0x1C357B8, 0x1C43D0C, 0x1C491DC, 0x1C4B368, 0x1C66690, 0x1C69BB0, 0x1C72790, 0x1C76E5C,
+        0x1C77FF8, 0x1C88A34, 0x1C90580, 0x1C92630, 0x1C99D20, 0x1CB4C8C, 0x1CBAF40, 0x1CCB1F0, 0x1CD74FC,
+        0x1CDFF54, 0x1CF1190, 0x1CFFF44, 0x1D12558, 0x1D1389C, 0x1D1B814, 0x1D284E4, 0x1D2DC30, 0x1D3C0B4,
+        0x1D3E024, 0x1D4AF94, 0x1D55830, 0x1D71798, 0x1D7BBBC, 0x1D90480, 0x1D9B978, 0x1DB0D14, 0x1DB7BC8,
+        0x1DC4E50, 0x1DC6234, 0x1DCE774, 0x1DDD970, 0x1DE5278, 0x1DE9EE0, 0x1DEB0FC, 0x1DF7758, 0x1DFB450,
+        0x1E0BA34, 0x1E160BC, 0x1E20204, 0x1E3A3B8, 0x1E4897C, 0x1E4DC48, 0x1E4FA04, 0x1E512BC, 0x1E548F4,
+        0x1E6D22C, 0x1E6F004, 0x1E73368, 0x1E79518, 0x1E7BBE0, 0x1E8E624, 0x1EA7368, 0x1EC288C, 0x1ECAFE4,
+        0x1EE22B8, 0x1EF5CC0, 0x1F04C98, 0x1F1A1F8, 0x1F280F0, 0x1F445C8, 0x1F4F100, 0x1F5E98C, 0x1F6E228,
+        0x1F6FA94, 0x1F78C6C, 0x1F81A90, 0x1F875B0, 0x1F8D158, 0x1FC0534, 0x1FC89DC, 0x1FD9A1C, 0x1FEFE80,
+        0x1FFF280, 0x2007FCC, 0x2011630, 0x201E764, 0x2024F78, 0x2029178, 0x202F4A0, 0x203DCC8, 0x204B410,
+        0x2050160, 0x205E1DC, 0x2066870, 0x208085C, 0x208B12C, 0x20958D8, 0x209B48C, 0x20AB91C, 0x20AD7C0,
+        0x20B2DA4, 0x20B738C, 0x20BD088, 0x20C0514, 0x20CAA2C, 0x20CC528, 0x20D7A3C, 0x20D9468, 0x20DA3E4,
+        0x20E591C, 0x21012D0, 0x2126064, 0x2132F7C, 0x2140730, 0x214DE94, 0x214FE30, 0x2151658, 0x21528F4,
+        0x2158690, 0x215EFEC, 0x216A17C, 0x2172404, 0x217CBC4, 0x21824C8, 0x2183CF8, 0x218A0B4, 0x218E500,
+        0x21AB168, 0x21B4954, 0x21BD1EC, 0x21C7750, 0x21CBE24, 0x21CDADC, 0x21D3B9C, 0x21DE2C8, 0x21E2F98,
+        0x21E9D64, 0x21F6414, 0x22045C8, 0x2209560, 0x2217C28, 0x2227970, 0x2238DB0, 0x223C45C, 0x223D5A8,
+        0x2240F10, 0x22464EC, 0x22509C0, 0x225B1F8, 0x226152C, 0x226BC78, 0x22808AC, 0x22872B8, 0x22922A4,
+        0x229CA40, 0x229FD30, 0x22A0B50, 0x22A3EE0, 0x22B5754, 0x22B6774, 0x22CA390, 0x22D85D0, 0x22DB5D0,
+        0x22E9FF0, 0x22FBA50, 0x2302A5C, 0x230403C, 0x23069D0, 0x230C328, 0x230DD30, 0x23175E0, 0x231E810,
+        0x2329684, 0x2337A38, 0x2340FA8, 0x23537C8, 0x2354D08, 0x2361C34, 0x2362A68, 0x2375920, 0x237F4B0,
+        0x2388894, 0x239627C, 0x23A3884, 0x23B5280, 0x23C03EC, 0x23D07A8, 0x23D49D8, 0x23E0444, 0x23EEE20,
+        0x23F81CC, 0x2410A64, 0x2417928, 0x2424E24, 0x2427498, 0x24355AC, 0x2443DCC, 0x2449A6C, 0x245676C,
+        0x245930C, 0x2464A64, 0x246FF04, 0x2474B04, 0x248AFF4, 0x249D75C, 0x24ABD40, 0x24B70B4, 0x24BE174,
+        0x24CE8D4, 0x24DB3B0, 0x24E1E74, 0x24EE984, 0x24FB76C, 0x25087F8, 0x251AE28, 0x252A970, 0x2530984,
+        0x253CC74, 0x255FE64, 0x2565BCC, 0x25692FC, 0x2570758, 0x257FFF0, 0x2580DDC, 0x258C260, 0x259CA58,
+        0x25A9E1C, 0x25BF480, 0x25DE7AC, 0x25E7584, 0x25F58A8, 0x25FA8B8, 0x2606B10, 0x26098B0, 0x2610EB8,
+        0x2622B38, 0x2624BA8, 0x26376F4, 0x264ABB4, 0x26549B8, 0x2681934, 0x2696BD0, 0x26A65EC, 0x26C06D8,
+        0x26E1340, 0x26ED184, 0x26FDB64, 0x2705834, 0x2717538, 0x27245AC, 0x273A074, 0x2740708, 0x2755C84,
+        0x27635D8,
+      } },
+      { "DATA12", new uint[] {
+        0x3434, 0x12194, 0x1AB9C, 0x2AA4C, 0x37DE0, 0x3C074, 0x48FE8, 0x61F7C, 0x701BC, 0x7AD84, 0x7FE4C,
+        0x9E2E4, 0x9FD30, 0x0B8384, 0x0D0158, 0x0D57C8, 0x0DA478, 0x0F359C, 0x10A51C, 0x1184C8, 0x123A30,
+        0x1398A4, 0x14449C, 0x15E298, 0x166540, 0x1736A4, 0x1840F8, 0x18D2DC, 0x19569C, 0x1A2D18, 0x1AE5E8,
+        0x1BB158, 0x1C843C, 0x1D217C, 0x1E4730, 0x1EC75C, 0x1FC0FC, 0x210DC4, 0x221640, 0x2254B4, 0x231D18,
+        0x24053C, 0x250018, 0x261DE4, 0x26EB00, 0x289C88, 0x296810, 0x2A8588, 0x2BD00C, 0x2C0E30, 0x2D87D4,
+        0x2E8384, 0x2F1D7C, 0x2F947C, 0x2FA784, 0x301578, 0x3208F4, 0x33B018, 0x3512A4, 0x35E1A4, 0x37879C,
+        0x39BE78, 0x3A02CC, 0x3A234C, 0x3A4448, 0x3B9824, 0x3BDFA4, 0x3C41B8, 0x3CD320, 0x3D0420, 0x3D8634,
+        0x3E7F94, 0x3EBE44, 0x4043D4, 0x40D5E0, 0x414044, 0x422EF0, 0x43AEE0, 0x43C17C, 0x44159C, 0x443B9C,
+        0x44B81C, 0x45433C, 0x458044, 0x4663F8, 0x46D588, 0x478144, 0x4843C8, 0x48F464, 0x4A0364, 0x4B2D54,
+        0x4C4B4C, 0x4C662C, 0x4D07FC, 0x4D1E84, 0x4D7F3C, 0x4DD920, 0x4DF27C, 0x4E429C, 0x4E60A8, 0x4F1744,
+        0x4F92F0, 0x500B44, 0x508838, 0x50C7D4, 0x5136C0, 0x5256CC, 0x5340FC, 0x5363D8, 0x5456EC, 0x5615D0,
+        0x568B94, 0x5726AC, 0x575B68, 0x57C108, 0x58201C, 0x586C50, 0x590338, 0x593054, 0x5A104C, 0x5A5D04,
+        0x5AA64C, 0x5BF960, 0x5C7A88, 0x5CCEA0, 0x5DACAC, 0x5E4344, 0x5EC7A0, 0x5FCB0C, 0x603EF4, 0x6143EC,
+        0x6212E0, 0x62DAFC, 0x63DDA8, 0x64B624, 0x64E434, 0x65AA1C, 0x6696E0, 0x671D60, 0x672A7C, 0x68FBC8,
+        0x6A8314, 0x6BC3E0, 0x6CBDBC, 0x6D8670, 0x6F71F8, 0x703288, 0x712C04, 0x7296E4, 0x72EB18, 0x73EEBC,
+        0x74ED24, 0x75CCA0, 0x76581C, 0x773600, 0x787368, 0x79A8B4, 0x7A235C, 0x7A37B0, 0x7B248C, 0x7B3E3C,
+        0x7C560C, 0x7C7704, 0x7D9238, 0x7E94E0, 0x7EB658, 0x7FEB7C, 0x8038E0, 0x80CE44, 0x811C28, 0x818B54,
+        0x834464, 0x837660, 0x83CA14, 0x83EDC8, 0x846D4C, 0x856AF0, 0x857CBC, 0x85AA38, 0x8656EC, 0x877710,
+        0x88B1D0, 0x890AB8, 0x895B88, 0x89AD4C, 0x89FA18, 0x8AE294, 0x8B3770, 0x8BB8B4, 0x8CD080, 0x8CE698,
+        0x8D0830, 0x8DB948, 0x8E1F6C, 0x8FA1F0, 0x8FAF88, 0x91A4E0, 0x926340, 0x929500, 0x92B47C, 0x9345A4,
+        0x938568, 0x93C728, 0x93EE78, 0x947824, 0x94F454, 0x952224, 0x953830, 0x956188, 0x957364, 0x95B05C,
+        0x95DEDC, 0x96668C, 0x96C7A8, 0x97AF78, 0x981794, 0x98806C, 0x98AE24, 0x9917C0, 0x9A9980, 0x9B7AD4,
+        0x9BE6F4, 0x9BF414, 0x9C4790, 0x9D1680, 0x9DDEBC, 0x9E6C4C, 0x9ECE40, 0x9FF1B0, 0x0A14224, 0x0A2CED4,
+        0x0A36988, 0x0A3E1C0, 0x0A4FC74, 0x0A66A58, 0x0A73E54, 0x0A8B6F0, 0x0A9432C, 0x0AA2840, 0x0AAB7B0,
+        0x0AB0A88, 0x0ABA1E8, 0x0ACEB34, 0x0AE5460, 0x0AEE54C, 0x0AFC878, 0x0B05134, 0x0B11EA0, 0x0B25960,
+        0x0B270A0, 0x0B33BF4, 0x0B42004, 0x0B56CEC, 0x0B62624, 0x0B6EAF0, 0x0B7B9BC, 0x0B93C38, 0x0B9B1CC,
+        0x0B9EB74, 0x0BA5CC0, 0x0BB82A4, 0x0BC27F8, 0x0BD7074, 0x0BE87F4, 0x0BF0998, 0x0C01A7C, 0x0C08604,
+        0x0C193B0, 0x0C312A4, 0x0C365A4, 0x0C3EDC4, 0x0C4691C, 0x0C5508C, 0x0C687D8, 0x0C721F8, 0x0C8B0B8,
+        0x0C924EC, 0x0C9EC94, 0x0CABD94, 0x0CB2ED8, 0x0CBDA14, 0x0CBFD1C, 0x0CC5898, 0x0CD307C, 0x0CDB2C4,
+        0x0CE8760, 0x0CF6D94, 0x0CFCD00, 0x0D00DB0, 0x0D037CC, 0x0D0AF54, 0x0D13684, 0x0D2C6E8, 0x0D32740,
+        0x0D3BB7C, 0x0D40F94, 0x0D4CFAC, 0x0D5370C, 0x0D72AE8, 0x0D82C00, 0x0D9C75C, 0x0DB87EC, 0x0DC6DF8,
+        0x0DCEE18, 0x0DD28CC, 0x0DD41D8, 0x0DE0664, 0x0DE8520, 0x0DEBBF8, 0x0DF9DA0, 0x0DFBB88, 0x0E0A96C,
+        0x0E18474, 0x0E22724, 0x0E390BC, 0x0E3F324, 0x0E419A4, 0x0E4872C, 0x0E50CF8, 0x0E6108C, 0x0E74094,
+        0x0E8B1E4, 0x0E8CAB4, 0x0E8F5F0, 0x0E9D4B8, 0x0EA75D4, 0x0EB0C98, 0x0EB56A0, 0x0EBD738, 0x0EC0874,
+        0x0EC5768, 0x0ED1E24, 0x0ED778C, 0x0EE98B4, 0x0EFEB6C, 0x0F1B12C, 0x0F2FAA0, 0x0F3F89C, 0x0F54720,
+        0x0F654EC, 0x0F76094, 0x0F7CE74, 0x0F87A54, 0x0F967C0, 0x0FA897C, 0x0FB2BC4, 0x0FB86A8, 0x0FBDD18,
+        0x0FC9B74, 0x0FDB15C, 0x0FF2F3C, 0x1003144, 0x101124C, 0x1025750, 0x1030C44, 0x103F0C4, 0x104CD00,
+        0x104E784, 0x10596D0, 0x1061F04, 0x106A740, 0x107C5F0, 0x1092518, 0x109C6D4, 0x10A2014, 0x10B00B0,
+        0x10BDA98, 0x10CC970, 0x10E0CA0, 0x10EB140, 0x10F1A24, 0x110BB54, 0x11269C0, 0x112A178, 0x112B9A0,
+        0x112CD5C, 0x1133AEC, 0x113D1BC, 0x1158104, 0x115984C, 0x116C7E4, 0x116E284, 0x11711F4, 0x1175E7C,
+        0x117E068, 0x1188E50, 0x1198688, 0x11B0E30, 0x11D7368, 0x11EF7A8, 0x11FEF4C, 0x1207DC4, 0x12186F0,
+        0x1225BE8, 0x1234214, 0x1243E6C, 0x125239C, 0x125D39C, 0x12664F8, 0x1276BA8, 0x128006C, 0x128DFF0,
+        0x128FC20, 0x1296D14, 0x129D780, 0x12A79B4, 0x12B7F08, 0x12C8DD4, 0x12E0EA8, 0x12F0034, 0x12FF4AC,
+        0x130DCDC, 0x1316108, 0x13173A8, 0x1326C04, 0x13329D8, 0x133AECC, 0x1345828, 0x134F730, 0x135BF3C,
+        0x135D804, 0x135ED60, 0x1374CD0, 0x137DB84, 0x1383408, 0x138D428, 0x139B388, 0x13B24C0, 0x13C78FC,
+        0x13C9600, 0x13D0344, 0x13E6F9C, 0x13FCDF0, 0x140E98C, 0x1417190, 0x142DD00, 0x1435CD8, 0x1437D7C,
+        0x1439AB0, 0x143C4B0, 0x144D0C0, 0x144F86C, 0x145ACC8, 0x1467A50, 0x1479568, 0x148F29C, 0x1495904,
+        0x149C860, 0x149D8A8, 0x14A8EE0, 0x14B0CE4, 0x14BC864, 0x14C1B38, 0x14D2C28, 0x14D8FB4, 0x14EF094,
+        0x150859C, 0x1509AA0, 0x15223D4, 0x152462C, 0x1527E98, 0x153167C, 0x1533A74, 0x153A14C, 0x1549A64,
+        0x155C054, 0x155F75C, 0x156A594, 0x15730B8, 0x1577D94, 0x157E668, 0x15873E4, 0x1589334, 0x1589EEC,
+        0x158B240, 0x1597B50, 0x159D5D8, 0x159F0DC, 0x15A3418, 0x15AA53C, 0x15AFD90, 0x15CE35C, 0x15CFE08,
+        0x15D6044, 0x15E4EAC, 0x15F8874, 0x15FAF70, 0x15FF838, 0x160C014, 0x161C47C, 0x162D400, 0x1640CDC,
+        0x1651730, 0x16657C0, 0x166D10C, 0x166FB04, 0x167A49C, 0x168AA2C, 0x16A38F8, 0x16B3394, 0x16BF294,
+        0x16CA4F4, 0x16D26BC, 0x16D81D0, 0x16E97E0, 0x16FC088, 0x16FD950, 0x170A1F0, 0x171CF20, 0x17291B8,
+        0x172CAB4, 0x17368C4, 0x1739DA0, 0x1745E8C, 0x174F79C, 0x1760388, 0x176283C, 0x176DB2C, 0x1774BF8,
+        0x17849F0, 0x17885C0, 0x178CB20, 0x179EAAC, 0x17A4F58, 0x17B0384, 0x17C14A4, 0x17CB2FC, 0x17D20C0,
+        0x17DE4C0, 0x17F06C8, 0x17FD69C, 0x1802F74, 0x180AE00, 0x1812C6C, 0x1823084, 0x182B540, 0x1833710,
+        0x183F454, 0x184BEFC, 0x1850700, 0x185D1F0, 0x1867A78, 0x186886C, 0x1869B14, 0x186DB60, 0x187C2C4,
+        0x187D160, 0x1885FDC, 0x189E844, 0x18AB10C, 0x18C87CC, 0x18CD094, 0x18E3BA4, 0x18FBEDC, 0x1906ED8,
+        0x192159C, 0x192D738, 0x193D090, 0x19472C0, 0x195DC08, 0x1978C68, 0x19989AC, 0x19B1B6C, 0x19CC6DC,
+        0x19CD7DC, 0x19CE89C, 0x19DC9CC, 0x19F4CC4, 0x19FB750, 0x1A078F8, 0x1A16B18, 0x1A2469C, 0x1A2648C,
+        0x1A2D400, 0x1A35E68, 0x1A42DF4, 0x1A57838, 0x1A63678, 0x1A65DD8, 0x1A67E7C, 0x1A721CC, 0x1A82F54,
+        0x1A9FBF0, 0x1AA72CC, 0x1AB2194, 0x1AC90BC, 0x1AD9F2C, 0x1AE131C, 0x1AE9E30, 0x1AF4A40, 0x1B00270,
+        0x1B0AA78, 0x1B0C104, 0x1B1A658, 0x1B21728, 0x1B23924, 0x1B27F84, 0x1B2FE78, 0x1B4457C, 0x1B4D3F0,
+        0x1B59590, 0x1B6CC68, 0x1B6E904, 0x1B72E08, 0x1B76BA4, 0x1B7BA18, 0x1B858B4, 0x1BA1FB4, 0x1BA825C,
+        0x1BACD38, 0x1BB0B7C, 0x1BBDF84, 0x1BC7964, 0x1BE5138, 0x1BF7720, 0x1BFC534, 0x1C0C678, 0x1C1B278,
+        0x1C2D484, 0x1C2FC48, 0x1C39D48, 0x1C3FEA4, 0x1C46224, 0x1C4D04C, 0x1C5647C, 0x1C66C38, 0x1C68D98,
+        0x1C6E264, 0x1C7A6F4, 0x1C8BDA4, 0x1C93364, 0x1C98864, 0x1CA5EB8, 0x1CAE29C, 0x1CB462C, 0x1CBBF24,
+        0x1CC72D8, 0x1CCD6DC, 0x1CCF620, 0x1CD14F0, 0x1CD81A0, 0x1CDF108, 0x1CE6070, 0x1CF9414, 0x1D005C0,
+        0x1D02578, 0x1D0A714, 0x1D1BD98, 0x1D27ADC, 0x1D2F534, 0x1D3F650, 0x1D45880, 0x1D5083C, 0x1D59948,
+        0x1D5EE90, 0x1D63130, 0x1D6C1C8, 0x1D6FCEC, 0x1D72474, 0x1D78D5C, 0x1D82924, 0x1D94F24, 0x1DA7F68,
+        0x1DAF294, 0x1DC200C, 0x1DC99C0, 0x1DD9110, 0x1DDFF94, 0x1DE7948, 0x1DEA324, 0x1DF9284, 0x1E01D80,
+        0x1E0F854, 0x1E144C0, 0x1E190B0, 0x1E1E23C, 0x1E27004, 0x1E29FF0, 0x1E2FD28, 0x1E39A58, 0x1E47A4C,
+        0x1E517F4, 0x1E63E70, 0x1E6FD40, 0x1E72BCC, 0x1E7B3F8, 0x1E8405C, 0x1E8ED70, 0x1E982B0, 0x1E9FA10,
+        0x1EAA544, 0x1EABBFC, 0x1EB0164, 0x1EB48AC, 0x1EC34C4, 0x1EC7D74, 0x1EDB3D0, 0x1EE2F7C, 0x1EEF72C,
+        0x1EFCFAC, 0x1F0C1D8, 0x1F17CEC, 0x1F27D94, 0x1F2A860, 0x1F30610, 0x1F35DB0, 0x1F4B2DC, 0x1F524A0,
+        0x1F572E4, 0x1F5EEEC, 0x1F695EC, 0x1F6ED14, 0x1F73CC4, 0x1F7B678, 0x1F88D90, 0x1FA5ABC, 0x1FA6D44,
+        0x1FC7FD0, 0x1FC91B4, 0x1FDCE20, 0x1FEE9CC, 0x1FFDEBC, 0x200CFFC, 0x2011F34, 0x201D0B4, 0x2028364,
+        0x203271C, 0x203463C, 0x203557C, 0x203E344, 0x2043978, 0x205CE24, 0x2069990, 0x207C440, 0x20896B0,
+        0x2091D04, 0x2096488, 0x2097A10, 0x209FD8C, 0x20B2750, 0x20BE83C, 0x20CA838, 0x20E26FC, 0x20F2A24,
+        0x20FF3D4, 0x210BC28, 0x211898C, 0x211F9A0, 0x212F2E4, 0x214CCA4, 0x215AB20, 0x21694B0, 0x217F658,
+        0x2191A1C, 0x2194C4C, 0x21992D4, 0x21A69EC, 0x21AEF40, 0x21BD00C, 0x21C9520, 0x21CFCE4, 0x21DB41C,
+        0x21EB3D8, 0x21F769C, 0x2201C44, 0x22189EC, 0x2227908, 0x2236A44, 0x2238820, 0x223E208, 0x22429EC,
+        0x224EFE8, 0x2260DA8, 0x2270C54, 0x227E9E0, 0x2282514, 0x22850AC, 0x2289468, 0x2295AEC, 0x22A64F4,
+        0x22B51B0, 0x22C288C, 0x22C5D74, 0x22C87A4, 0x22D0438, 0x22D4874, 0x22F2DAC, 0x22F6EAC, 0x22F9E70,
+        0x23022EC, 0x230C2D8, 0x23178A4, 0x231C2F0, 0x2321B30, 0x2329050, 0x232C1F4, 0x233317C, 0x23361B8,
+        0x233F0E8, 0x234DC3C, 0x235CAD4, 0x2363BC4, 0x236B5FC, 0x2379104, 0x2398F64, 0x23A8504, 0x23B3BC0,
+        0x23BCEA8, 0x23DB638, 0x23EACB8, 0x23F4100, 0x23F9768, 0x240E6C8, 0x241FCB8, 0x2424B38, 0x2433778,
+        0x243F780, 0x2447EC4, 0x244A270, 0x244D6E0, 0x245EBA0, 0x246D67C, 0x248A040, 0x24950A8, 0x24B0214,
+        0x24B7AAC, 0x24BD670, 0x24C9E24, 0x24D85DC, 0x24DF3EC, 0x24E8780, 0x24ED874, 0x24F7A84, 0x24FF408,
+        0x250CB90, 0x252113C, 0x252E6C0, 0x25388A4, 0x2543A60, 0x25498B8, 0x25564B8, 0x25606C8, 0x2563530,
+        0x256DC54, 0x2575050, 0x258AC1C, 0x25A120C, 0x25B32C8, 0x25C2494, 0x25CD568, 0x25E0AF4, 0x25E6E58,
+        0x260B3E4, 0x2615204, 0x261CA28, 0x262BE38, 0x264C370, 0x2664428, 0x26788BC, 0x267AC50, 0x267CF70,
+        0x268105C, 0x268D184, 0x26ACDC8, 0x26B50D4, 0x26C7B38, 0x26CDD1C, 0x26DD64C, 0x26F2CE0, 0x26FF2B0,
+        0x2704690, 0x270804C, 0x270F0B0, 0x271BC94, 0x27317D4, 0x273F8BC, 0x2742A10, 0x274B498, 0x2757814,
+        0x2762708, 0x276D7D8, 0x2771A78, 0x2781850, 0x278DF14, 0x279BF0C, 0x27A9804, 0x27AE038, 0x27B1908,
+        0x27BD674, 0x27D47A4, 0x27E671C, 0x27FAF34, 0x281C2E4, 0x2839D9C, 0x2850094, 0x285E098, 0x2863718,
+        0x286E2DC, 0x2878BE0, 0x288D0C4, 0x28930E0, 0x2899DD8, 0x289C08C, 0x289D754, 0x28AD17C, 0x28B3FD4,
+        0x28BBC64,
+      } },
+      { "DATA13", new uint[] {
+        0x66D4, 0x7544, 0x97B8, 0x0A6A0, 0x0B6E8, 0x0CAE8, 0x0F368, 0x101D8, 0x158D8, 0x25250, 0x27700,
+        0x2889C, 0x2ABEC, 0x330A8, 0x349C0, 0x3CD70, 0x3E2F4, 0x4086C, 0x481D0, 0x4DBE8, 0x4FB44, 0x51798,
+        0x544B0, 0x55C6C, 0x5D200, 0x63F30, 0x69C58, 0x6C170, 0x78228, 0x80D18, 0x8E14C, 0x9422C, 0x0B002C,
+        0x0C943C, 0x0E0BB0, 0x0EC5AC, 0x0ED444, 0x0F4534, 0x0F643C, 0x0F8CD0, 0x0FAE14, 0x0FC780, 0x0FECB4,
+        0x1035D0, 0x1047F0, 0x1076B0, 0x10BA2C, 0x12B724, 0x12DB34, 0x12FEBC, 0x136BF8, 0x1390B8, 0x13CDC0,
+        0x15F948, 0x1730F4, 0x1924FC, 0x1A901C, 0x1AA288, 0x1B5224, 0x1B6DB8, 0x1BE6CC, 0x1C0524, 0x1C1D84,
+        0x1C55FC, 0x1C6CFC, 0x1C990C, 0x1CBB84, 0x1CCC1C, 0x1CEBD0, 0x1E01A0, 0x1EBBC4, 0x1F1DE8, 0x1F3B50,
+        0x1FF500, 0x203C20, 0x20632C, 0x20BC04, 0x2154B8, 0x237A4C, 0x2627A8, 0x27CB0C, 0x29E3D4, 0x2ADDAC,
+        0x2AF018, 0x2B1E78, 0x2B3D44, 0x2B5774, 0x2B813C, 0x2B9248, 0x2CA29C, 0x2CFDB4, 0x2D5EA4, 0x2DF7D8,
+        0x2E1304, 0x2EBA2C, 0x2F7CCC, 0x2F9FA0, 0x2FF380, 0x3022EC, 0x30F464, 0x31115C, 0x315258, 0x317680,
+        0x31962C, 0x31C528, 0x3202FC, 0x3220D8, 0x326D10, 0x32CD04, 0x32FFDC, 0x3314D8, 0x333138, 0x33A1A0,
+        0x33C110, 0x33D834, 0x348628, 0x35C1B4, 0x37ED0C, 0x39D9E8, 0x3B7758, 0x3B927C, 0x3BB1A0, 0x3C6038,
+        0x3CB538, 0x3CC7C0, 0x3D433C, 0x3D539C, 0x3D9B10, 0x3DF288, 0x3E086C, 0x3E2478, 0x3E77A0, 0x3EDBB4,
+        0x3EECB0, 0x3F6078, 0x3F8928, 0x3FA624, 0x401010, 0x407EA0, 0x40D308, 0x41500C, 0x41801C, 0x41A340,
+        0x41EB50, 0x42E2D8, 0x42F384, 0x434F98, 0x436E6C, 0x43AFB8, 0x43C0B4, 0x43D114, 0x4477A8, 0x44DF04,
+        0x455B4C, 0x460104, 0x467F48, 0x468F78, 0x46BFB4, 0x46CF78, 0x47CC5C, 0x489664, 0x48F314, 0x49F318,
+        0x4A1538, 0x4A27FC, 0x4A939C, 0x4AB8C0, 0x4AD410, 0x4AF9A0, 0x4C7644, 0x4C90BC, 0x4CB2DC, 0x4D076C,
+        0x4D1954, 0x4D3F2C, 0x4DB27C, 0x4DF364, 0x4FA070, 0x513DD0, 0x53AB44, 0x544458, 0x546534, 0x551E94,
+        0x555F10, 0x55FE3C, 0x561EAC, 0x563CF4, 0x565090, 0x567F1C, 0x56E1C4, 0x5717FC, 0x578774, 0x57A630,
+        0x57C114, 0x57DDAC, 0x57FED0, 0x58104C, 0x5835DC, 0x585948, 0x586BA0, 0x5879B8, 0x589320, 0x58E1A4,
+        0x59072C, 0x592AE4, 0x593B44, 0x598374, 0x59DB68, 0x59FE40, 0x5A24A0, 0x5A4B10, 0x5AD168, 0x5B1DA8,
+        0x5B4160, 0x5B6844, 0x5BEE24, 0x5C0B20, 0x5C35A0, 0x5E5370, 0x6097FC, 0x615CC4, 0x6195A8, 0x62E134,
+        0x650388, 0x6513E8, 0x6583B8, 0x65948C, 0x65F1B0, 0x663120, 0x66531C, 0x674374, 0x676920, 0x678DE4,
+        0x67B060, 0x67D598, 0x682DB4, 0x6855AC, 0x686554, 0x687328, 0x68D408, 0x68F2D8, 0x690370, 0x693AC4,
+        0x69B658, 0x6A2670, 0x6A39F8, 0x6A50E0, 0x6B0D58, 0x6B306C, 0x6B6610, 0x6D0384, 0x6F5C6C, 0x719634,
+        0x72975C, 0x739EEC, 0x753488, 0x755728, 0x757D88, 0x759464, 0x7615F0, 0x76CC68, 0x76E6DC, 0x772580,
+        0x774310, 0x77865C, 0x77D23C, 0x7804D4, 0x782648, 0x7860B8, 0x79191C, 0x792DA0, 0x7971DC, 0x7A02A8,
+        0x7AC3B0, 0x7AD738, 0x7AEB00, 0x7B2C9C, 0x7B4798, 0x7BEE14, 0x7C01FC, 0x7CCD40, 0x7D62D8, 0x7DCCC0,
+        0x7E5658, 0x7EBB00, 0x7F1FA8, 0x7F3C90, 0x7F5DD8, 0x7FCD84, 0x80D5B8, 0x80E5E4, 0x810810, 0x817358,
+        0x81840C, 0x8286A8, 0x82FFF4, 0x8324BC, 0x834B5C, 0x83E98C, 0x8430D0, 0x85BCFC, 0x86BAAC, 0x87E32C,
+        0x8845E0, 0x89A7F8, 0x89D360, 0x8BC014, 0x8BD3F8, 0x8C9154, 0x8DA67C, 0x8E71B0, 0x8E8E94, 0x8EE04C,
+        0x8FE300, 0x908644, 0x9153A0, 0x919874, 0x92AC50, 0x92E70C,
+      } },
+      { "DATA14", new uint[] {
+        0x2CE8, 0x6670, 0x0DDBC, 0x107D0, 0x191D0, 0x1C458, 0x21DB4, 0x2D3B0, 0x4CB20, 0x5EF88, 0x68E9C,
+        0x6AD7C, 0x6DE98, 0x71988, 0x78B34, 0x812E0, 0x82F28, 0x861B0, 0x89778, 0x8BA14, 0x925AC, 0x9D250,
+        0x0A1698, 0x0A285C, 0x0AAAE4, 0x0B5CAC, 0x0BDEB8, 0x0C1754, 0x0C3A68, 0x0E13F4, 0x0E4F5C, 0x0E7108,
+        0x0EDC2C, 0x0F098C, 0x0F7618, 0x110AD0, 0x11A444, 0x11D30C, 0x12B418, 0x12CCE4, 0x134164, 0x140BFC,
+        0x14C978, 0x157CA8, 0x167C1C, 0x175AD0, 0x17F624, 0x19D360, 0x1A63F4, 0x1AE948, 0x1B3584, 0x1B4DD8,
+        0x1B7E04, 0x1B95DC, 0x1BB9A4, 0x1C8200, 0x1D4190, 0x1DB96C, 0x1E0F0C, 0x1EF2B0, 0x2066AC, 0x21263C,
+        0x215D54, 0x224614, 0x22DCF0, 0x231830, 0x2337B0, 0x239ABC, 0x23D514, 0x24A978, 0x2526E0, 0x2573B8,
+        0x25A880, 0x25E610, 0x260ED0, 0x2622BC, 0x266C54, 0x26C268, 0x26DAF8, 0x26EF60, 0x27CD78, 0x2A966C,
+        0x2B6E0C, 0x2D1EA8, 0x2D5120, 0x2D8A14, 0x2DEAF4, 0x300668, 0x30E658, 0x316E48, 0x322BFC, 0x326A7C,
+        0x32B6DC, 0x3346C4, 0x33A5A4, 0x34E0BC, 0x3540F4, 0x36CC6C, 0x3757B4, 0x37B2E0, 0x3864D0, 0x391A34,
+        0x39CF24, 0x39E410, 0x3A7130, 0x3AA744, 0x3B47E8, 0x3C0DD4, 0x3D4488, 0x3D6BA8, 0x3DF858, 0x3E3FA8,
+        0x3E5AFC, 0x3E8FB8, 0x3EBD30, 0x3EDF00, 0x3F15B4, 0x3F7CB4, 0x4010F4, 0x4085BC, 0x411C18, 0x4165CC,
+        0x417CBC, 0x41AE38, 0x41CC90, 0x4229FC, 0x427440, 0x433018, 0x4462BC, 0x45162C, 0x455E68, 0x45724C,
+        0x45BBB4, 0x45D700, 0x45FFC8, 0x463D04, 0x4798B0, 0x484508, 0x488D20, 0x48AE80, 0x48D210, 0x49B278,
+        0x4A8E14, 0x4AB908, 0x4ADFA4, 0x4B4940, 0x4B8E50, 0x4BC038, 0x4BF50C, 0x4C6AD8, 0x4CA554, 0x4D280C,
+        0x4DF798, 0x4E1754, 0x4E7314, 0x4F2DEC, 0x4F6044, 0x4F84F4, 0x50A1B8, 0x50BE64, 0x50DD6C, 0x517A24,
+        0x519748, 0x51B214, 0x523030, 0x538C84, 0x5585F8, 0x571410, 0x58CE88, 0x5AA62C, 0x5BC5C0, 0x5CDBE8,
+        0x5E7CF4, 0x5F966C, 0x5FB754, 0x5FE388, 0x6070B8, 0x60892C, 0x625678, 0x635F00, 0x63FF7C, 0x642BF4,
+        0x64783C, 0x64C8C0, 0x654274, 0x656498, 0x663B00, 0x66F81C, 0x67CCA4, 0x685300, 0x6877F8, 0x68C620,
+        0x68E144, 0x6913D0, 0x6937D4, 0x698584, 0x699BFC, 0x6B54F8, 0x6C3A58, 0x6CB840, 0x6CDF90, 0x6D6318,
+        0x6D8810, 0x6DA6F4, 0x6DE78C, 0x6E3E24, 0x6EAF6C, 0x6F085C, 0x6F506C, 0x6FAD90, 0x705BB0, 0x706CFC,
+        0x70D8A4, 0x71DD50, 0x71F850, 0x7267F8, 0x72AA84, 0x7334B0, 0x736B3C, 0x73A3B0, 0x73FA34, 0x742438,
+        0x74D250, 0x751EA4, 0x75BA34, 0x763AE4, 0x765A40, 0x768960, 0x76AA98, 0x772E84, 0x77BBB8, 0x77E6AC,
+        0x784D68, 0x790024, 0x791124, 0x796E24, 0x7A1030, 0x7A2AEC, 0x7A4460, 0x7A5B90, 0x7A954C,
+      } },
+      { "DATA15", new uint[] {
+        0x5710, 0x0CC54, 0x13110, 0x1512C, 0x200BC, 0x30630, 0x34618, 0x46348, 0x53F24, 0x69F5C, 0x727E8,
+        0x80CF8, 0x90054, 0x97340, 0x9C018, 0x0A44A8, 0x0ADAC0, 0x0B658C, 0x0C0058, 0x0C86E0, 0x0D2F4C,
+        0x0D865C, 0x0DFECC, 0x0E4D88, 0x0E6E48, 0x0F6830, 0x0FAFDC, 0x1053A8, 0x10BAF0, 0x119F08, 0x1231C8,
+        0x12D364, 0x135C5C, 0x144F7C, 0x14BB08, 0x150D88, 0x15A6AC, 0x164DB4, 0x1764E4, 0x17E918, 0x18C890,
+        0x193AB0, 0x19C20C, 0x1AE1C4, 0x1BA284, 0x1BDE2C, 0x1C78C8, 0x1D3C4C, 0x1E4874, 0x1EE1CC, 0x1F2538,
+        0x1FFC58, 0x2081D8, 0x20C780, 0x21FDC8, 0x231E58, 0x239B5C, 0x251560, 0x253E14, 0x259EC8, 0x26C304,
+        0x277F2C, 0x27B6A8, 0x280658, 0x298F8C, 0x2B9C04, 0x2BBED8, 0x2D2A3C, 0x2EAE68, 0x2F3B3C, 0x30B0B0,
+        0x313D04, 0x332EA4, 0x337FA4, 0x3406C0, 0x345900, 0x346580, 0x34B530, 0x35F3E0, 0x363654, 0x373BB4,
+        0x377F28, 0x37D67C, 0x37E170, 0x37FDA4, 0x39B224, 0x3B313C, 0x3C0240, 0x3C7C74, 0x3D0A18, 0x3D4E10,
+        0x3D9524, 0x3E7330, 0x3F4514, 0x3F7920, 0x3F8FDC, 0x405210, 0x40E844, 0x427688, 0x43505C, 0x44BD00,
+        0x45E854, 0x4727E4, 0x475E54, 0x47C8EC, 0x481A04, 0x49B530, 0x4A3D9C, 0x4A8564, 0x4B12C0, 0x4BBF8C,
+        0x4C1B04, 0x4D0B90, 0x4DBCCC, 0x4E7464, 0x4FC8C0, 0x516954, 0x51FA18, 0x526168, 0x52DC24, 0x545664,
+        0x54AAD0, 0x55934C, 0x562100, 0x56A798, 0x573650, 0x58F800, 0x5A4694, 0x5BD00C, 0x5BF9F0, 0x5CBFF0,
+        0x5CD344, 0x5D87D4, 0x5DDA78, 0x5F16FC, 0x6011D8, 0x60FC94, 0x62E964, 0x63F680, 0x648F38, 0x64E4F4,
+        0x664160, 0x66DCAC, 0x67BBB4, 0x68A82C, 0x691B00, 0x69924C, 0x69E4C8, 0x6AA0E4, 0x6AF018, 0x6B08EC,
+        0x6C1D9C, 0x6CBB20, 0x6D4ED4, 0x6DEC7C, 0x6EF1A8, 0x6FC3CC, 0x710D1C, 0x71495C, 0x720EA8, 0x735CCC,
+        0x73DC4C, 0x750598, 0x75E660, 0x76877C, 0x77312C, 0x779670, 0x77D858, 0x786BE4, 0x78DD34, 0x79AB20,
+        0x7A2BEC, 0x7A5AB0, 0x7B174C, 0x7C85C8, 0x7DFE5C, 0x7E9C58, 0x7EB644, 0x8035E0, 0x80DEB4, 0x81B284,
+        0x82CF38, 0x83700C, 0x84C10C, 0x854EBC, 0x85C564, 0x861B74, 0x86625C, 0x8711B4, 0x886230, 0x88F5D8,
+        0x897DA0, 0x89D6A4, 0x8AF344, 0x8C57B0, 0x8D3078, 0x8E0BB0, 0x8F2904, 0x90DF00, 0x91B0F0, 0x927AC4,
+        0x9287F8, 0x92BD0C, 0x93A5D4, 0x93E8DC, 0x951DF0, 0x95B054, 0x96467C, 0x96D3A0, 0x9714BC, 0x975ED0,
+        0x9898B8, 0x98CDB0, 0x9B75A0, 0x9C5A0C, 0x9D4C40, 0x9E9678, 0x9EAB00, 0x0A00AC4, 0x0A06CD8, 0x0A10878,
+        0x0A1241C, 0x0A296D4, 0x0A2D4C0, 0x0A3F784, 0x0A4ACFC, 0x0A6AD5C, 0x0A78DA8, 0x0A99998, 0x0AA9590,
+        0x0ABC5D8, 0x0AD0D80, 0x0ADE424, 0x0AEA2E0, 0x0AFD9C8, 0x0B08DC8, 0x0B0C1DC, 0x0B138D8, 0x0B156A0,
+        0x0B1BED4, 0x0B23224, 0x0B33624, 0x0B3A1A8, 0x0B46F7C, 0x0B5A270, 0x0B5DE28, 0x0B7A8F4, 0x0B84C40,
+        0x0B93C9C, 0x0BA7C78, 0x0BB5F10, 0x0BC5DCC, 0x0BEBC94, 0x0C044A4, 0x0C202B8, 0x0C286FC, 0x0C2CF7C,
+        0x0C38E64, 0x0C4DEE8, 0x0C6096C, 0x0C68C20, 0x0C71894, 0x0C76BDC, 0x0C88DFC, 0x0C951A0, 0x0C9A71C,
+        0x0C9E6D0, 0x0CA1F98, 0x0CADCB8, 0x0CB28F4, 0x0CB7510, 0x0CBFBB0, 0x0CC7430, 0x0CCE838, 0x0CD76F4,
+        0x0CD9BA0, 0x0CDD32C, 0x0CE7600, 0x0CF04E8, 0x0CFC648, 0x0D09910, 0x0D0CC80, 0x0D1825C, 0x0D27230,
+        0x0D2B3A0, 0x0D32248, 0x0D34980, 0x0D4D3FC, 0x0D545F0, 0x0D56478, 0x0D63AF8, 0x0D69704, 0x0D72D7C,
+        0x0D78F50, 0x0D7D348, 0x0D86D78, 0x0D8E0B8, 0x0D9B344, 0x0DA47E8, 0x0DA77AC, 0x0DB29E4, 0x0DCA05C,
+        0x0DE0EE0, 0x0DE9A7C, 0x0DEBA3C, 0x0E04770, 0x0E0E0C4, 0x0E20E60, 0x0E2B2D0, 0x0E3B70C, 0x0E49520,
+        0x0E55D74, 0x0E62C30, 0x0E7BC28, 0x0E89398, 0x0E8D81C, 0x0EAB05C, 0x0ECC3F0, 0x0ED5A5C, 0x0EDF898,
+        0x0EE3B0C, 0x0EECCC4, 0x0EF5358, 0x0F06CF0, 0x0F0DC68, 0x0F1DCBC, 0x0F254A0, 0x0F2F07C, 0x0F3C018,
+        0x0F44D44, 0x0F4BFD4, 0x0F5C574, 0x0F67764, 0x0F81558, 0x0F8BECC, 0x0FA6714, 0x0FB83C8, 0x0FC2F64,
+        0x0FC66C0, 0x0FC752C, 0x0FD3B60, 0x0FED48C, 0x0FF36C8, 0x0FFE7C8, 0x1003FA8, 0x100556C, 0x100F208,
+        0x102490C, 0x1033314, 0x103AB98, 0x1040360, 0x104D994, 0x104F258, 0x105957C, 0x105DFB0, 0x106D014,
+        0x1073B94, 0x108D5A4, 0x10AB13C, 0x10B1B04, 0x10BFBC4, 0x10C1E84, 0x10C5570, 0x10D17E4, 0x10E2358,
+        0x10E673C, 0x10ECD68, 0x1102224, 0x11099F8, 0x1128D70, 0x113AE7C, 0x114E4F4, 0x1159118, 0x1174B20,
+        0x1181078, 0x1187D5C, 0x118F1C8, 0x1198334, 0x119E014, 0x11A5B58, 0x11AED1C, 0x11BD9AC, 0x11CED2C,
+        0x11D7B64, 0x11E7630, 0x11E8B08, 0x11F02C0, 0x11F4028, 0x11F4BF8, 0x12006DC, 0x120A008, 0x12141D0,
+        0x1216B98, 0x1223CF0, 0x1226F60, 0x1228460, 0x122C3FC, 0x122D41C, 0x123912C, 0x12456C8, 0x124B98C,
+        0x1255A0C, 0x125F798, 0x126589C,
+      } },
+    };
+  }
+}
+// vim: sw=2

Legacy/Legacy.csproj

@@ -89,6 +89,7 @@
     <Compile Include="Asura\ArcPAK.cs" />
     <Compile Include="Asura\ImageMTG.cs" />
     <Compile Include="BlackButterfly\ArcDAT.cs" />
+    <Compile Include="Bom\ImageGRP.cs" />
     <Compile Include="CottonClub\ImageLMG.cs" />
     <Compile Include="Gsx\ArcK5.cs" />
     <Compile Include="Gsx\ImageK4.cs" />
@@ -123,6 +124,8 @@
     <Compile Include="KeroQ\ImageCBM.cs" />
     <Compile Include="KeroQ\ImageKGD.cs" />
     <Compile Include="KeroQ\ImageKGD1.cs" />
+    <Compile Include="Koei\ArcYK.cs" />
+    <Compile Include="Koei\YkTables.cs" />
     <Compile Include="Kurumi\ImageGRA.cs" />
     <Compile Include="Lazycrew\ArcDAT.cs" />
     <Compile Include="Lazycrew\ImageDAT.cs" />
@@ -136,6 +139,7 @@
     <Compile Include="Mink\ImageFC.cs" />
     <Compile Include="Mink\ImageFD.cs" />
     <Compile Include="Mmfass\ArcSDA.cs" />
+    <Compile Include="Nug\ArcDAT.cs" />
     <Compile Include="Nyoken\ArcZLK.cs" />
     <Compile Include="Omi\ArcDAT.cs" />
     <Compile Include="Paprika\ArcPKDAT.cs" />
@@ -303,6 +307,7 @@
     <Folder Include="HyperWorks\" />
     <Folder Include="Nanami\" />
   </ItemGroup>
+  <ItemGroup />
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <PropertyGroup>
     <PreBuildEvent>perl "$(SolutionDir)inc-revision.pl" "$(ProjectPath)" $(ConfigurationName)

Legacy/Nug/ArcDAT.cs

@@ -0,0 +1,97 @@
+//! \file       ArcDAT.cs
+//! \date       2023 Sep 10
+//! \brief      NUG System resource archive.
+//
+// Copyright (C) 2023 by morkt
+//
+// 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.
+//
+
+using GameRes.Compression;
+using System;
+using System.Collections.Generic;
+using System.ComponentModel.Composition;
+using System.IO;
+
+namespace GameRes.Formats.Nug
+{
+    [Export(typeof(ArchiveFormat))]
+    public class FwaOpener : ArchiveFormat
+    {
+        public override string         Tag => "DAT/FWA";
+        public override string Description => "Frontwing resource archive";
+        public override uint     Signature => 0x46574131; // '1AWF'
+        public override bool  IsHierarchic => false;
+        public override bool      CanWrite => false;
+
+        public override ArcFile TryOpen (ArcView file)
+        {
+            int count = file.View.ReadInt32 (0xC);
+            if (!IsSaneCount (count))
+                return null;
+            long index_offset = file.View.ReadUInt32 (0x10) + count * 4;
+            uint index_size = (uint)count * 0x40u;
+            if (index_size > file.View.Reserve (index_offset, index_size))
+                return null;
+            var dir = new List<Entry> (count);
+            for (int i = 0; i < count; ++i)
+            {
+                uint entry_size = file.View.ReadUInt32 (index_offset);
+                if (entry_size < 0x40)
+                    return null;
+                var name = file.View.ReadString (index_offset+0x10, 0x30);
+                var entry = Create<PackedEntry> (name);
+                entry.Offset = file.View.ReadUInt32 (index_offset+4);
+                entry.Size   = file.View.ReadUInt32 (index_offset+8);
+                if (!entry.CheckPlacement (file.MaxOffset))
+                    return null;
+                entry.UnpackedSize = entry.Size;
+                dir.Add (entry);
+                index_offset += entry_size;
+            }
+            return new ArcFile (file, this, dir);
+        }
+
+        public override Stream OpenEntry (ArcFile arc, Entry entry)
+        {
+            var pent = (PackedEntry)entry;
+            var offset = entry.Offset;
+            uint signature = arc.File.View.ReadUInt32 (offset);
+            if (!pent.IsPacked && entry.Size > 0x20)
+            {
+                if (signature == 0x46574353) // 'SCWF'
+                {
+                    pent.IsPacked = true;
+                    pent.UnpackedSize = arc.File.View.ReadUInt32 (offset+0x10);
+                    entry.Offset += 0x20;
+                    entry.Size -= 0x20;
+                }
+                else if (signature == 0x46574343) // 'CCWF'
+                {
+                    entry.Offset += 0x20;
+                    entry.Size = arc.File.View.ReadUInt32 (offset+0x10);
+                }
+            }
+            Stream input = arc.File.CreateStream (entry.Offset, entry.Size);
+            if (pent.IsPacked)
+                input = new LzssStream (input);
+            return input;
+        }
+    }
+}

Legacy/Properties/AssemblyInfo.cs

@@ -32,5 +32,5 @@ using System.Runtime.InteropServices;
 // You can specify all the values or you can default the Build and Revision Numbers 
 // by using the '*' as shown below:
 // [assembly: AssemblyVersion("1.0.*")]
-[assembly: AssemblyVersion ("1.0.10.205")]
+[assembly: AssemblyVersion ("1.0.10.208")]
-[assembly: AssemblyFileVersion ("1.0.10.205")]
+[assembly: AssemblyFileVersion ("1.0.10.208")]