diff --git a/ArcFormats/ArcCommon.cs b/ArcFormats/ArcCommon.cs index 22b823f5..7225cf2a 100644 --- a/ArcFormats/ArcCommon.cs +++ b/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)); } /// @@ -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; } } diff --git a/ArcFormats/ArcFormats.csproj b/ArcFormats/ArcFormats.csproj index 3424057f..2e54d131 100644 --- a/ArcFormats/ArcFormats.csproj +++ b/ArcFormats/ArcFormats.csproj @@ -123,6 +123,8 @@ + + @@ -166,6 +168,7 @@ + @@ -748,7 +751,7 @@ - + diff --git a/ArcFormats/CatSystem/ImageHG3.cs b/ArcFormats/CatSystem/ImageHG3.cs index 0f7d0f2c..fe11560d 100644 --- a/ArcFormats/CatSystem/ImageHG3.cs +++ b/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; - var pixels = new byte[stride*(int)m_info.Height]; + int stride = m_info.iWidth * src_pixel_size; + 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 (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+1]; - output[dst++] = pixels[src]; - output[dst++] = 0xFF; + output[dst++] = pixels[src+src_B]; + output[dst++] = pixels[src+src_G]; + output[dst++] = pixels[src+src_R]; + output[dst++] = alpha[src_A++]; src += src_pixel_size; } + return output; + } - m_input.Position = next_section; - var section_header = m_input.ReadBytes (8); - if (!Binary.AsciiEqual (section_header, "img_al\0\0")) - return output; - m_input.Seek (8, SeekOrigin.Current); + byte[] ReadAlpha (long start_pos) + { + m_input.Position = start_pos + 0x10; + int packed_size = m_input.ReadInt32(); 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) - { - int b = alpha.ReadByte(); - if (-1 == b) - throw new EndOfStreamException(); - output[i] = (byte)b; - } - return output; + var alpha_data = new byte[alpha_size]; + alpha.Read (alpha_data, 0, alpha_size); + return alpha_data; } } + Dictionary ReadSections () + { + long next_offset = m_info.HeaderSize; + var toc = new Dictionary(); + 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."); diff --git a/ArcFormats/DraftArc.cs b/ArcFormats/DraftArc.cs index ea9c0f0d..6ccf5bc3 100644 --- a/ArcFormats/DraftArc.cs +++ b/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 Description { get => "?????? engine resource archive"; } - public override uint Signature { get => 0; } - public override bool IsHierarchic { get => false; } - public override bool CanWrite { get => false; } + public override string Tag => "ARC"; + public override string Description => "?????? engine resource archive"; + public override uint Signature => 0; + public override bool IsHierarchic => 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); + } } } diff --git a/ArcFormats/DraftAudio.cs b/ArcFormats/DraftAudio.cs index b0f1cbc6..e0d9749e 100644 --- a/ArcFormats/DraftAudio.cs +++ b/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 Description { get => "?????? audio resource"; } - public override uint Signature { get => 0; } - public override bool CanWrite { get => false; } + public override string Tag => "xxx"; + public override string Description => "?????? audio resource"; + public override uint Signature => 0; + public override bool CanWrite => false; public override SoundInput TryOpen (IBinaryStream file) { diff --git a/ArcFormats/DraftImage.cs b/ArcFormats/DraftImage.cs index 6124a62d..ddbb5475 100644 --- a/ArcFormats/DraftImage.cs +++ b/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 Description { get => "?????? image format"; } - public override uint Signature { get => 0; } + public override string Tag => "xxx"; + public override string Description => "?????? image format"; + public override uint Signature => 0; public override ImageMetaData ReadMetaData (IBinaryStream file) { diff --git a/ArcFormats/Emote/ArcPSB.cs b/ArcFormats/Emote/ArcPSB.cs index a82eac0a..bbdb2cc5 100644 --- a/ArcFormats/Emote/ArcPSB.cs +++ b/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) diff --git a/ArcFormats/FC01/ArcBDT.cs b/ArcFormats/FC01/ArcBDT.cs new file mode 100644 index 00000000..7b4af7b4 --- /dev/null +++ b/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 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 { + 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; + } + } +} diff --git a/ArcFormats/FC01/ArcPAK.cs b/ArcFormats/FC01/ArcPAK.cs index e7f51352..98d98eb8 100644 --- a/ArcFormats/FC01/ArcPAK.cs +++ b/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 ReadIndex () { using (var index = OpenIndex()) + return ReadIndex (index); + } + + public List ReadIndex (IBinaryStream index) + { + int name_size = m_record_size - 0x10; + var dir = new List (m_count); + for (int i = 0; i < m_count; ++i) { - int name_size = m_record_size - 0x10; - var dir = new List (m_count); - for (int i = 0; i < m_count; ++i) - { - var entry = new AgsiEntry(); - entry.UnpackedSize = index.ReadUInt32(); - entry.Size = index.ReadUInt32(); - entry.Method = index.ReadInt32(); - entry.Offset = index.ReadUInt32() + m_data_offset; - if (!entry.CheckPlacement (m_file.MaxOffset)) - return null; - var name = index.ReadCString (name_size); - if (string.IsNullOrEmpty (name)) - return null; - entry.Name = name; - 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; + var entry = new AgsiEntry(); + entry.UnpackedSize = index.ReadUInt32(); + entry.Size = index.ReadUInt32(); + entry.Method = index.ReadInt32(); + entry.Offset = index.ReadUInt32() + DataOffset; + if (!entry.CheckPlacement (m_file.MaxOffset)) + return null; + var name = index.ReadCString (name_size); + if (string.IsNullOrEmpty (name)) + return null; + entry.Name = name; + 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; } IBinaryStream OpenIndex () diff --git a/ArcFormats/FC01/BdtTables.cs b/ArcFormats/FC01/BdtTables.cs new file mode 100644 index 00000000..8e40f55e --- /dev/null +++ b/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, + }; + } +} diff --git a/ArcFormats/Kaas/ArcKAAS.cs b/ArcFormats/Kaas/ArcKAAS.cs index d1956bed..e98fc62b 100644 --- a/ArcFormats/Kaas/ArcKAAS.cs +++ b/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; + // 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]; diff --git a/ArcFormats/KiriKiri/ArcXP3.cs b/ArcFormats/KiriKiri/ArcXP3.cs index 2f4fc054..b96df0fc 100644 --- a/ArcFormats/KiriKiri/ArcXP3.cs +++ b/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" }; } diff --git a/ArcFormats/LiveMaker/ArcVF.cs b/ArcFormats/LiveMaker/ArcVF.cs index 8d77eb26..ee40f60f 100644 --- a/ArcFormats/LiveMaker/ArcVF.cs +++ b/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 }; } diff --git a/ArcFormats/Macromedia/ArcCCT.cs b/ArcFormats/Macromedia/ArcCCT.cs index e722b2a8..0f31f25c 100644 --- a/ArcFormats/Macromedia/ArcCCT.cs +++ b/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) diff --git a/ArcFormats/Macromedia/ArcDXR.cs b/ArcFormats/Macromedia/ArcDXR.cs index 38e7af2d..ed6eabc5 100644 --- a/ArcFormats/Macromedia/ArcDXR.cs +++ b/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 RawChunks = new HashSet { - "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 (); 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; - if (!ConvertText || null == ment || ment.FourCC != "STXT") + var pent = entry as PackedEntry; + if (null == pent) return base.OpenEntry (arc, entry); - uint offset = Binary.BigEndian (arc.File.View.ReadUInt32 (entry.Offset)); - uint length = Binary.BigEndian (arc.File.View.ReadUInt32 (entry.Offset + 4)); - return arc.File.CreateStream (entry.Offset + offset, length); + var input = OpenChunkStream (arc.File, pent); + var ment = entry as DirectorEntry; + 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 dir) { var seen_ids = new HashSet(); - 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]; - if (string.IsNullOrEmpty (name)) - name = ediM.Id.ToString ("D6"); - return new Entry + var ediM = dir_file.Index[elem.Id]; + name = SanitizeName(name, ediM.Id); + return new PackedEntry { - Name = name + ".mp3", - Type = "audio", - Offset = ediM.Offset, - Size = ediM.Size, + Name = name + ".ediM", + Type = "audio", + Offset = ediM.Offset, + 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 sndS = dir_file.MMap[sndSrec.Id]; - if (string.IsNullOrEmpty (name)) - name = sndSrec.Id.ToString ("D6"); + var sndH = dir_file.Index[sndHrec.Id]; + var sndS = dir_file.Index[sndSrec.Id]; + name = SanitizeName (name, sndSrec.Id); 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, alfa = null; + KeyTableEntry bitd = null, edim = 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); - 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) + if (bitd != null) { - var cast_id = cast.Index[entry.Palette-1]; - var clut = dir_file.KeyTable.FindByCast (cast_id, "CLUT"); - if (clut != null) - entry.PaletteRef = dir_file.MMap[clut.Id]; + entry.DeserializeHeader (bitmap.SpecificData); + var name = SanitizeName (bitmap.Info.Name, bitd.Id); + var chunk = dir_file.Index[bitd.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); - palette = ReadPalette (pal_bytes); + using (var pal = OpenChunkStream (arc.File, bent.PaletteRef)) + { + 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) - { - using (var alpha = arc.File.CreateStream (bent.AlphaRef.Offset, bent.AlphaRef.Size)) - { - var alpha_info = new ImageMetaData { - Width = info.Width, - Height = info.Height, - BPP = 8, - }; - var decoder = new BitdDecoder (alpha, alpha_info, null); - alpha_channel = decoder.Unpack8bpp(); - } - } + alpha_channel = ReadAlphaChannel (arc.File, bent.AlphaRef, info); + var input = OpenChunkStream (arc.File, bent).AsStream; + return new BitdDecoder (input, info, palette) { AlphaChannel = alpha_channel }; + } + + IImageDecoder OpenJpeg (ArcFile arc, BitmapEntry entry) + { + if (null == entry.AlphaRef) + return base.OpenImage (arc, entry); + // 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 Entry AlphaRef; + public DirectorEntry PaletteRef; + 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) { diff --git a/ArcFormats/Macromedia/AudioSND.cs b/ArcFormats/Macromedia/AudioSND.cs index f8ba395f..fd77620a 100644 --- a/ArcFormats/Macromedia/AudioSND.cs +++ b/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 Description { get => "Macromedia Director audio resource"; } - public override uint Signature { get => 0; } - public override bool CanWrite { get => false; } + public override string Tag => "SND"; + public override string Description => "Macromedia Director audio resource"; + public override uint Signature => 0; + public override bool CanWrite => false; + + static readonly ResourceInstance Mp3 = new ResourceInstance ("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 (data, format); + return new RawPcmInput (samples_stream, format); } int sample_count = frames_count * channels; var samples = file.ReadBytes (sample_count); diff --git a/ArcFormats/Macromedia/DirectorFile.cs b/ArcFormats/Macromedia/DirectorFile.cs index 2f84b1d0..cca399d5 100644 --- a/ArcFormats/Macromedia/DirectorFile.cs +++ b/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 m_dir; + Dictionary m_index = new Dictionary(); MemoryMap m_mmap = new MemoryMap(); KeyTable m_keyTable = new KeyTable(); DirectorConfig m_config = new DirectorConfig(); List m_casts = new List(); + Dictionary m_ilsMap = new Dictionary(); - 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 Casts => m_casts; + public List Casts => m_casts; + public List Directory => m_dir; + public Dictionary 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 (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 cast = new Cast (context, reader, mmap_entry); + var cas_entry = Index[key_entry.Id]; + 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; - member.Deserialize (context, reader); + var cast_reader = GetChunkReader (chunk, reader); + member.Deserialize (context, cast_reader); cast.Members[member.Id] = member; } } @@ -293,11 +417,10 @@ namespace GameRes.Formats.Macromedia public string Name; public Dictionary Members = new Dictionary(); - 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 ChunkMap = new List(); - - 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 Dir = new List(); + public readonly List Dir = new List(); - public MemoryMapEntry this[int index] => Dir[index]; - - public MemoryMapEntry Find (string four_cc) => Dir.Find (e => e.FourCC == four_cc); + public DirectorEntry this[int index] => Dir[index]; 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(); - int Next = reader.ReadI32(); + Flags = reader.ReadU16(); + 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) diff --git a/ArcFormats/Macromedia/ImageBITD.cs b/ArcFormats/Macromedia/ImageBITD.cs index e75828b9..fb571e6a 100644 --- a/ArcFormats/Macromedia/ImageBITD.cs +++ b/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))] - public class BitdFormat : ImageFormat + internal class BitdMetaData : ImageMetaData { - public override string Tag { get { return "BITD"; } } - 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(); - var key_lines = new List(); - 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]; - } - } - } + public byte DepthType; } 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); - bitmap = new FormatConvertedBitmap (bitmap, PixelFormats.Bgr32, null, 0); + if (bitmap == null) + 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; diff --git a/ArcFormats/Mebius/AudioKOE.cs b/ArcFormats/Mebius/AudioKOE.cs index ff2a1940..c3d2b772 100644 --- a/ArcFormats/Mebius/AudioKOE.cs +++ 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 DefaultKeys = new Dictionary { - { "koe", new byte[] { + Dictionary DefaultKeys => SchemeMap["Mebinya!"]; + + static readonly Dictionary> SchemeMap = + new Dictionary> { + { "Mebinya!", new Dictionary { + { "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 { + { "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, + } }, } }, }; } diff --git a/ArcFormats/Nekopack/ArcNEKO.cs b/ArcFormats/Nekopack/ArcNEKO.cs index 96f2dea9..e6256540 100644 --- a/ArcFormats/Nekopack/ArcNEKO.cs +++ b/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 s_known_file_names = new Lazy (ReadNekoPackLst); diff --git a/ArcFormats/Psp/ArcQPK.cs b/ArcFormats/Psp/ArcQPK.cs new file mode 100644 index 00000000..5fe9fca8 --- /dev/null +++ b/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 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 (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); + } + } +} diff --git a/ArcFormats/StudioJikkenshitsu/ImageDAT.cs b/ArcFormats/StudioJikkenshitsu/ImageDAT.cs index 48a24585..b80801f8 100644 --- a/ArcFormats/StudioJikkenshitsu/ImageDAT.cs +++ b/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 (arcStrings.ArcImageEncrypted); return options.Key; diff --git a/ArcFormats/StudioJikkenshitsu/ImageGRC.cs b/ArcFormats/StudioJikkenshitsu/ImageGRC.cs index 0953a9bb..7b65dcc2 100644 --- a/ArcFormats/StudioJikkenshitsu/ImageGRC.cs +++ b/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 SpeedFormat = new ResourceInstance ("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); diff --git a/Experimental/Microsoft/ArcEXE.cs b/Experimental/Microsoft/ArcEXE.cs index 336b46e8..56ca88ad 100644 --- a/Experimental/Microsoft/ArcEXE.cs +++ b/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 RuntimeTypeMap = new Dictionary() { { "#2", "RT_BITMAP" }, { "#10", "RT_RCDATA" }, + { "#16", "RT_VERSION" }, }; static readonly Dictionary ExtensionTypeMap = new Dictionary() { @@ -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 (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 diff --git a/GameRes/ArcView.cs b/GameRes/ArcView.cs index 59a04d08..d1a26bac 100644 --- a/GameRes/ArcView.cs +++ b/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 - // CodePage is just a direct field access. - if (enc.CodePage == 1200 || enc.CodePage == 1201) // for UTF-16 encodings stop marker is 2-bytes long + if (enc.IsUtf16()) // for UTF-16 encodings stop marker is 2-bytes long { ushort* u = (ushort*)s; while (string_length + 1 < size && 0 != u[string_length >> 1]) diff --git a/GameRes/BinaryStream.cs b/GameRes/BinaryStream.cs index 3a7ca08b..905ffc12 100644 --- a/GameRes/BinaryStream.cs +++ b/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 (m_source, 0, start, length); - if (-1 == i) - i = start+length; - string s = enc.GetString (m_source, start, i-start); + length = Math.Min (length, m_length - m_position); + int eos_pos = FindEoS (start, length, enc); + if (-1 == eos_pos) + 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 (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 (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; } } diff --git a/Legacy/Bom/ImageGRP.cs b/Legacy/Bom/ImageGRP.cs index e490e06e..cba13d44 100644 --- a/Legacy/Bom/ImageGRP.cs +++ b/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 ImageData.Create (info, reader.Format, null, pixels); + return reader.Unpack(); } 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]; - dword_70986C[v1 + 1] = v2; - dword_6FF95C[i] = v4; - dword_704360[i] = v1; + int v4 = dword_6FF464[v1] + dword_6FF464[v1 + 1]; 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_6FFE50 = 0xFFFF; + dword_6FF464[635] = 0xFFFF; } - int[] dword_704360 = new int[317]; - int[] dword_6FF95C = new int[317]; - int[] dword_70986C = new int[634]; - - int sub_408BE0 () + int GetControlWord () { - 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) - { - byte v = m_input.ReadUInt8(); - m_bits |= (v << (8 - m_cached_bits)); - m_cached_bits += 8; - } + FillBitCache(); 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 - 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) + if (dword_6FF464[634] == 0x8000) sub_408D50(); - int v1 = dword_70A258[a1]; + int v1 = dword_70986C[a1 + 635]; do { - v2 = dword_6FF464[v1] + 1; - dword_6FF464[v1] = v2; - v3 = v2; - if ( v2 > dword_6FF468[v1] ) + int v2 = ++dword_6FF464[v1]; + int v3 = v2; + if (v2 > dword_6FF464[v1 + 1]) { - v4 = &dword_6FF46C[v1 + 1]; - if ( v3 > dword_6FF46C[v1] ) - { - do - { - v5 = *v4; - ++v4; - } - while ( v3 > v5 ); - } - dword_6FF464[v1] = *(v4 - 2); - *(v4 - 2) = v3; - v6 = v4 - dword_6FF464; - v7 = dword_703E68[v1]; - v8 = v6 - 2; + int v4 = v1 + 2; // &dword_6FF464[v1 + 2]; + while (v3 > dword_6FF464[v4++]) + ; + dword_6FF464[v1] = dword_6FF464[v4 - 2]; + dword_6FF464[v4 - 2] = v3; + int v6 = v4; // v4 - dword_6FF464; + int v7 = dword_703E68[v1]; + int v8 = v6 - 2; dword_70986C[v7] = v8; - if ( v7 < 635 ) - dword_709870[v7] = v8; - v9 = dword_703E68[v8]; + if (v7 < 635) + dword_70986C[v7 + 1] = v8; + int v9 = dword_703E68[v8]; dword_703E68[v8] = v7; dword_70986C[v9] = v1; - if ( v9 < 635 ) - dword_709870[v9] = v1; + if (v9 < 635) + 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; - v20 = 318; - v6 = dword_6FF464; - do + int v19 = 0; + int v6 = 0; // dword_6FF464; + int v1 = 0; + while (v1 < 317) { - v7 = *v6 + v6[1]; - v8 = &dword_6FF95C[v1]; - v9 = v5 - 1; - v10 = &dword_6FF95C[v1 - 1]; - dword_6FF95C[v1] = v7; - if ( v7 < *v10 ) + int v7 = dword_6FF464[v6] + dword_6FF464[v6 + 1]; + int v9 = v5; + int v10 = v1 + 317; // &dword_6FF464[v1 + 317]; + dword_6FF464[v1 + 318] = v7; + while (v7 < dword_6FF464[v10]) { - do - { - v11 = *(v10 - 1); - --v10; - --v9; - } - while ( v7 < v11 ); + --v10; + --v9; } - v12 = v9 + 1; - for ( i = &dword_6FF464[v12]; v8 > i; --v8 ) - *v8 = *(v8 - 1); - *i = v7; - v14 = &dword_704360[v1]; - v15 = &dword_703E68[v12]; - if ( &dword_704360[v1] > v15 ) + int p = v9; // &dword_6FF464[v9] + for (int v8 = v1 + 318; v8 > p; --v8) + dword_6FF464[v8] = dword_6FF464[v8 - 1]; + dword_6FF464[p] = v7; + + int v14 = v1 + 318; // &dword_703E68[v1 + 318]; + int v15 = v9; // &dword_703E68[v9]; + while (v14 > v15) { - do - { - *v14 = *(v14 - 1); - --v14; - } - while ( v14 > v15 ); + dword_703E68[v14] = dword_703E68[v14 - 1]; + --v14; } v6 += 2; - *v15 = v19; - ++v1; - v5 = v20 + 1; + dword_703E68[v15] = v19; v19 += 2; - ++v20; + ++v5; + ++v1; } - while ( v1 < 317 ); - v16 = 0; - v17 = dword_703E68; - do + int v16 = 0; + for (int i = 0; i < 635; ++i) { - v18 = *v17; - if ( *v17 < 635 ) + int v18 = dword_703E68[i]; + 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; } } diff --git a/Legacy/Discovery/ArcDAT.cs b/Legacy/Discovery/ArcDAT.cs index acfb6fe3..cb149c9b 100644 --- a/Legacy/Discovery/ArcDAT.cs +++ b/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 (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; - if (8 == entry.BPP) + int bpp = m_is_mask ? 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)) - lzss.Read (m_output, 0, m_output.Length); - return ImageData.CreateFlipped (Info, Format, Palette, m_output, Stride); + if (m_is_packed) + { + 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; diff --git a/Legacy/Koei/ArcYK.cs b/Legacy/Koei/ArcYK.cs new file mode 100644 index 00000000..0c718eac --- /dev/null +++ b/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 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 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 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 (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 GetDataIndex (ArcView file, uint[] offsets, string name) + { + var dir = new List (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); + } + } +} diff --git a/Legacy/Koei/YkTables.cs b/Legacy/Koei/YkTables.cs new file mode 100644 index 00000000..075e1c0c --- /dev/null +++ b/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 IsAudio = new HashSet { + "DATA05", "DATA06", "DATA07", "DATA08", "DATA09", "DATA10", "DATA11", "DATA12", "DATA13", "DATA14", "DATA15", + }; + internal static readonly Dictionary Data02Images = new Dictionary + { + { 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 OffsetTable = new Dictionary + { + { "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 diff --git a/Legacy/Legacy.csproj b/Legacy/Legacy.csproj index 576baaec..7459d23e 100644 --- a/Legacy/Legacy.csproj +++ b/Legacy/Legacy.csproj @@ -89,6 +89,7 @@ + @@ -123,6 +124,8 @@ + + @@ -136,6 +139,7 @@ + @@ -303,6 +307,7 @@ + perl "$(SolutionDir)inc-revision.pl" "$(ProjectPath)" $(ConfigurationName) diff --git a/Legacy/Nug/ArcDAT.cs b/Legacy/Nug/ArcDAT.cs new file mode 100644 index 00000000..67b8da01 --- /dev/null +++ b/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 (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 (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; + } + } +} diff --git a/Legacy/Properties/AssemblyInfo.cs b/Legacy/Properties/AssemblyInfo.cs index a13ea4d9..d63b355a 100644 --- a/Legacy/Properties/AssemblyInfo.cs +++ b/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: AssemblyFileVersion ("1.0.10.205")] +[assembly: AssemblyVersion ("1.0.10.208")] +[assembly: AssemblyFileVersion ("1.0.10.208")]