Public-Mirror/GARbro-mirror
1
0
Fork 0
mirror of https://github.com/crskycode/GARbro.git synced 2024-11-23 05:35:34 +08:00
Code Issues Projects Releases Wiki Activity

Merge remote-tracking branch 'upstream/master'

Browse Source
This commit is contained in:
Crsky 2023-09-15 19:07:35 +08:00
commit 4e89ce0cc7
33 changed files with 2612 additions and 584 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
ArcFormats/ArcCommon.cs
View File

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

5
ArcFormats/ArcFormats.csproj
View File

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

80
ArcFormats/CatSystem/ImageHG3.cs
View File

@ -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<byte> (0xFF, total).ToArray();
bool swap_rgb = toc.ContainsKey ("imgmode"); // XXX ???
var output = new byte[total * 4];
int src = 0;
int dst = 0;
int src_A = 0;
int src_R = 2, src_G = 1, src_B = 0;
if (swap_rgb)
{
src_R = 0;
src_B = 2;
}
for (uint i = 0; i < total; ++i)
{
output[dst++] = pixels[src+2];
output[dst++] = pixels[src+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<string, long> ReadSections ()
{
long next_offset = m_info.HeaderSize;
var toc = new Dictionary<string, long>();
uint section_size;
do
{
m_input.Position = next_offset;
var section_name = m_input.ReadCString (8);
section_size = m_input.ReadUInt32();
toc[section_name] = next_offset;
next_offset += section_size;
}
while (section_size != 0);
return toc;
}
byte[] UnpackWebp ()
{
throw new NotImplementedException ("HG-3 WebP decoder not implemented.");

15
ArcFormats/DraftArc.cs
View File

@ -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);
}
}
}

8
ArcFormats/DraftAudio.cs
View File

@ -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)
{

6
ArcFormats/DraftImage.cs
View File

@ -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)
{

2
ArcFormats/Emote/ArcPSB.cs
View File

@ -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)

151
ArcFormats/FC01/ArcBDT.cs Normal file
View File

@ -0,0 +1,151 @@
//! \file ArcBDT.cs
//! \date 2023 Sep 10
//! \brief RPA resource archive.
//
// Copyright (C) 2023 by morkt
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to
// deal in the Software without restriction, including without limitation the
// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
// sell copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
// IN THE SOFTWARE.
//
using System;
using System.Collections.Generic;
using System.ComponentModel.Composition;
using System.Globalization;
using System.IO;
using System.Linq;
// [021228][Fairytale Kagetsu Gumi] Tsuki Jong
namespace GameRes.Formats.FC01
{
[Export(typeof(ArchiveFormat))]
public partial class BdtOpener : PakOpener
{
public override string Tag => "BDT";
public override string Description => "Fairytale resource archive";
public override uint Signature => 0x4B434150; // 'PACK'
public override bool IsHierarchic => false;
public override bool CanWrite => false;
public BdtOpener ()
{
Signatures = new[] { 0x4B434150u, 0u };
}
public override ArcFile TryOpen (ArcView file)
{
uint signature = file.View.ReadUInt32 (0);
if (signature != this.Signature)
return BogusMediaArchive (file, signature);
var arc_name = Path.GetFileNameWithoutExtension (file.Name).ToLowerInvariant();
if (!arc_name.StartsWith ("dt0"))
return null;
uint index_pos = 12;
int count = file.View.ReadInt32 (4);
if (!IsSaneCount (count) || file.MaxOffset <= index_pos)
return null;
int entry_size = file.View.ReadInt32 (8);
string arc_num_str = arc_name.Substring (3);
int arc_num = int.Parse (arc_num_str, NumberStyles.HexNumber);
var dir = ReadVomIndex (file, arc_num, count, entry_size);
if (null == dir)
return null;
var arc_key = GetKey (arc_num);
return new AgsiArchive (file, this, dir, arc_key);
}
List<Entry> ReadVomIndex (ArcView file, int arc_num, int count, int record_size)
{
if (4 == arc_num) // dt004.bdt is an archive of indexes
{
var reader = new IndexReader (file, count, record_size);
return reader.ReadIndex();
}
var dt4name = VFS.ChangeFileName (file.Name, "dt004.bdt");
using (var dt4file = VFS.OpenView (dt4name))
{
var dt4arc = TryOpen (dt4file);
if (null == dt4arc)
return null;
using (dt4arc)
{
int vom_idx = arc_num;
if (arc_num > 4)
--vom_idx;
var voms = string.Format ("vom{0:D3}.dat", vom_idx);
var vom_entry = dt4arc.Dir.First (e => e.Name == voms);
using (var input = dt4arc.OpenEntry (vom_entry))
using (var index = BinaryStream.FromStream (input, vom_entry.Name))
{
var reader = new IndexReader (file, count, record_size);
return reader.ReadIndex (index);
}
}
}
}
ArcFile BogusMediaArchive (ArcView file, uint signature)
{
if (!file.Name.HasExtension (".bdt"))
return null;
string ext = null;
string type = "";
if (OggAudio.Instance.Signature == signature)
{
ext = ".ogg";
type = "audio";
}
else if (AudioFormat.Wav.Signature == signature && file.View.AsciiEqual (8, "AVI "))
{
ext = ".avi";
}
if (null == ext)
return null;
var name = Path.GetFileNameWithoutExtension (file.Name);
var dir = new List<Entry> {
new Entry {
Name = name + ext,
Type = type,
Offset = 0,
Size = (uint)file.MaxOffset
}
};
return new ArcFile (file, this, dir);
}
byte[] GetKey (int index)
{
int src = index * 8;
if (src + 8 > KeyOffsetTable.Length)
throw new ArgumentException ("Invalid AGSI key index.");
var key = new byte[8];
key[0] = KeySource[KeyOffsetTable[src++]];
key[1] = KeySource[KeyOffsetTable[src++]];
key[2] = KeySource[KeyOffsetTable[src++]];
key[3] = KeySource[KeyOffsetTable[src++] + 480];
key[4] = KeySource[KeyOffsetTable[src++] + 480];
key[5] = KeySource[KeyOffsetTable[src++] + 480];
key[6] = KeySource[KeyOffsetTable[src++] + 480];
key[7] = KeySource[KeyOffsetTable[src++] + 480];
return key;
}
}
}

57
ArcFormats/FC01/ArcPAK.cs
View File

@ -102,8 +102,10 @@ namespace GameRes.Formats.FC01
public override Stream OpenEntry (ArcFile arc, Entry entry)
{
var aent = (AgsiEntry)entry;
var aent = entry as AgsiEntry;
var aarc = arc as AgsiArchive;
if (null == aent)
return base.OpenEntry (arc, entry);
Stream input;
if (!aent.IsEncrypted)
input = arc.File.CreateStream (entry.Offset, entry.Size);
@ -202,16 +204,16 @@ namespace GameRes.Formats.FC01
ArcView m_file;
int m_count;
int m_record_size;
uint m_data_offset;
public bool IsEncrypted { get; set; }
public uint DataOffset { get; set; }
public IndexReader (ArcView file, int count, int record_size, bool is_encrypted)
public IndexReader (ArcView file, int count, int record_size, bool is_encrypted = false)
{
m_file = file;
m_count = count;
m_record_size = record_size;
m_data_offset = (uint)(0xC + m_count * m_record_size);
DataOffset = (uint)(0xC + m_count * m_record_size);
IsEncrypted = is_encrypted;
}
@ -239,7 +241,7 @@ namespace GameRes.Formats.FC01
if (!ArchiveFormat.IsSaneCount (count) || record_size <= 0x10 || record_size > 0x100)
return null;
var reader = new IndexReader (file, count, record_size, is_encrypted);
if (reader.m_data_offset >= file.MaxOffset)
if (reader.DataOffset >= file.MaxOffset)
return null;
return reader;
}
@ -247,29 +249,32 @@ namespace GameRes.Formats.FC01
public List<Entry> ReadIndex ()
{
using (var index = OpenIndex())
return ReadIndex (index);
}
public List<Entry> ReadIndex (IBinaryStream index)
{
int name_size = m_record_size - 0x10;
var dir = new List<Entry> (m_count);
for (int i = 0; i < m_count; ++i)
{
int name_size = m_record_size - 0x10;
var dir = new List<Entry> (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 ()

159
ArcFormats/FC01/BdtTables.cs Normal file
View File

@ -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,
};
}
}

2
ArcFormats/Kaas/ArcKAAS.cs
View File

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

1
ArcFormats/KiriKiri/ArcXP3.cs
View File

@ -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" };
}

2
ArcFormats/LiveMaker/ArcVF.cs
View File

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

4
ArcFormats/Macromedia/ArcCCT.cs
View File

@ -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)

237
ArcFormats/Macromedia/ArcDXR.cs
View File

@ -23,13 +23,13 @@
// IN THE SOFTWARE.
//
using GameRes.Compression;
using GameRes.Utility;
using System;
using System.Collections.Generic;
using System.ComponentModel.Composition;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Text.RegularExpressions;
using System.Windows.Media;
using System.Windows.Media.Imaging;
@ -46,12 +46,12 @@ namespace GameRes.Formats.Macromedia
public DxrOpener ()
{
Extensions = new[] { "dxr", "cxt" };
Extensions = new[] { "dxr", "cxt", "cct", "dcr" };
Signatures = new[] { 0x52494658u, 0x58464952u };
}
internal static readonly HashSet<string> RawChunks = new HashSet<string> {
"RTE0", "RTE1", "FXmp", "VWFI", "VWSC", "Lscr", "STXT", "XMED", "snd "
"RTE0", "RTE1", "FXmp", "VWFI", "VWSC", "Lscr", "STXT", "XMED", //"snd "
};
internal bool ConvertText = true;
@ -71,9 +71,9 @@ namespace GameRes.Formats.Macromedia
var dir = new List<Entry> ();
ImportMedia (dir_file, dir);
foreach (MemoryMapEntry entry in dir_file.MMap.Dir)
foreach (DirectorEntry entry in dir_file.Directory)
{
if (entry.Size != 0 && RawChunks.Contains (entry.FourCC))
if (entry.Size != 0 && entry.Offset != -1 && RawChunks.Contains (entry.FourCC))
{
entry.Name = string.Format ("{0:D6}.{1}", entry.Id, entry.FourCC.Trim());
if ("snd " == entry.FourCC)
@ -90,19 +90,30 @@ namespace GameRes.Formats.Macromedia
var snd = entry as SoundEntry;
if (snd != null)
return OpenSound (arc, snd);
var ment = entry as MemoryMapEntry;
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<Entry> dir)
{
var seen_ids = new HashSet<int>();
var mmap = dir_file.MMap;
foreach (var cast in dir_file.Casts)
{
foreach (var piece in cast.Members.Values)
@ -157,17 +169,35 @@ namespace GameRes.Formats.Macromedia
{
if ("ediM" == elem.FourCC)
{
var ediM = dir_file.MMap[elem.Id];
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)
{

20
ArcFormats/Macromedia/AudioSND.cs
View File

@ -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<AudioFormat> Mp3 = new ResourceInstance<AudioFormat> ("MP3");
public override SoundInput TryOpen (IBinaryStream file)
{
@ -83,6 +85,13 @@ namespace GameRes.Formats.Macromedia
if (bps != 16 && bps != 8)
return null;
// try mp3
var samples_stream = new StreamRegion (reader.Source, reader.Position);
var mp3_input = new BinaryStream (samples_stream, file.Name);
var mp3 = Mp3.Value.TryOpen (mp3_input);
if (mp3 != null)
return mp3;
var format = new WaveFormat {
FormatTag = 1,
Channels = channels,
@ -93,8 +102,7 @@ namespace GameRes.Formats.Macromedia
format.SetBPS();
if (8 == bps)
{
var data = new StreamRegion (file.AsStream, file.Position);
return new RawPcmInput (data, format);
return new RawPcmInput (samples_stream, format);
}
int sample_count = frames_count * channels;
var samples = file.ReadBytes (sample_count);

305
ArcFormats/Macromedia/DirectorFile.cs
View File

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

224
ArcFormats/Macromedia/ImageBITD.cs
View File

@ -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<int, int>();
var key_lines = new List<int>();
for (;;)
{
int b = m_input.ReadByte();
if (-1 == b)
break;
int count = b;
if (b > 0x7f)
count = (byte)-(sbyte)b;
++count;
if (count > 0x7f)
return null;
if (b > 0x7f)
{
if (-1 == m_input.ReadByte())
return null;
}
else
m_input.Seek (count, SeekOrigin.Current);
key_lines.Clear();
key_lines.AddRange (scan_lines.Keys);
foreach (var line in key_lines)
{
int width = scan_lines[line];
if (width < count)
scan_lines.Remove (line);
else if (width == count)
scan_lines[line] = line;
else
scan_lines[line] = width - count;
}
total += count;
if (total <= MaxScanLine && total >= 8)
scan_lines[total] = total;
if (total > MaxScanLine && !scan_lines.Any())
return null;
}
int rem;
total = Math.DivRem (total, 4, out rem);
if (rem != 0)
return null;
var valid_lines = from line in scan_lines where line.Key == line.Value
orderby line.Key
select line.Key;
bool is_eof = -1 == m_input.ReadByte();
foreach (var width in valid_lines)
{
int height = Math.DivRem (total, width, out rem);
if (0 == rem)
{
return new ImageMetaData
{
Width = (uint)width,
Height = (uint)height,
BPP = 32,
};
}
}
return null;
}
}
internal class BitdReader : BitdScanner
{
byte[] m_output;
int m_width;
int m_height;
public byte[] Data { get { return m_output; } }
public PixelFormat Format { get; private set; }
public BitdReader (Stream input, ImageMetaData info) : base (input)
{
m_width = (int)info.Width;
m_height = (int)info.Height;
m_output = new byte[m_width * m_height * 4];
Format = PixelFormats.Bgra32;
}
public void Unpack ()
{
int stride = m_width * 4;
var scan_line = new byte[stride];
for (int line = 0; line < m_output.Length; line += stride)
{
int dst = 0;
while (dst < stride)
{
int b = Input.ReadByte();
if (-1 == b)
throw new InvalidFormatException ("Unexpected end of file");
int count = b;
if (b > 0x7f)
count = (byte)-(sbyte)b;
++count;
if (dst + count > stride)
throw new InvalidFormatException();
if (b > 0x7f)
{
b = Input.ReadByte();
if (-1 == b)
throw new InvalidFormatException ("Unexpected end of file");
for (int i = 0; i < count; ++i)
scan_line[dst++] = (byte)b;
}
else
{
Input.Read (scan_line, dst, count);
dst += count;
}
}
dst = line;
for (int x = 0; x < m_width; ++x)
{
m_output[dst++] = scan_line[x+m_width*3];
m_output[dst++] = scan_line[x+m_width*2];
m_output[dst++] = scan_line[x+m_width];
m_output[dst++] = scan_line[x];
}
}
}
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;

75
ArcFormats/Mebius/AudioKOE.cs
View File

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

2
ArcFormats/Nekopack/ArcNEKO.cs
View File

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

103
ArcFormats/Psp/ArcQPK.cs Normal file
View File

@ -0,0 +1,103 @@
//! \file ArcQPK.cs
//! \date 2023 Sep 13
//! \brief PSP resource archive.
//
// Copyright (C) 2023 by morkt
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to
// deal in the Software without restriction, including without limitation the
// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
// sell copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
// IN THE SOFTWARE.
//
using GameRes.Compression;
using System;
using System.Collections.Generic;
using System.ComponentModel.Composition;
using System.IO;
namespace GameRes.Formats.Psp
{
[Export(typeof(ArchiveFormat))]
public class PakOpener : ArchiveFormat
{
public override string Tag => "QPK";
public override string Description => "PSP resource archive";
public override uint Signature => 0x4B5051; // 'QPK'
public override bool IsHierarchic => false;
public override bool CanWrite => false;
public override ArcFile TryOpen (ArcView file)
{
var index_name = Path.ChangeExtension (file.Name, "QPI");
List<Entry> dir;
using (var index = VFS.OpenView (index_name))
{
if (!index.View.AsciiEqual (0, "QPI\0"))
return null;
int count = index.View.ReadInt32 (4);
if (!IsSaneCount (count))
return null;
var base_name = Path.GetFileNameWithoutExtension (file.Name);
string ext = "";
string type = "";
if ("TGA" == base_name)
{
ext = ".tga";
type = "image";
}
dir = new List<Entry> (count);
uint index_pos = 0x1C;
for (int i = 0; i < count; ++i)
{
uint offset = index.View.ReadUInt32 (index_pos);
uint size = index.View.ReadUInt32 (index_pos+4);
if (offset > file.MaxOffset)
return null;
index_pos += 8;
if ((size & 0x80000000) != 0 || size == 0)
continue;
var entry = new PackedEntry {
Name = string.Format ("{0}#{1:D5}{2}", base_name, i, ext),
Type = type,
Offset = offset,
UnpackedSize = size & 0x3FFFFFFF,
IsPacked = (size & 0x40000000) != 0,
};
dir.Add (entry);
}
long last_offset = file.MaxOffset;
for (int i = dir.Count - 1; i >= 0; --i)
{
dir[i].Size = (uint)(last_offset - dir[i].Offset);
last_offset = dir[i].Offset;
}
return new ArcFile (file, this, dir);
}
}
public override Stream OpenEntry (ArcFile arc, Entry entry)
{
var pent = (PackedEntry)entry;
if (!pent.IsPacked || !arc.File.View.AsciiEqual (pent.Offset, "CZL\0"))
return base.OpenEntry (arc, pent);
uint size = arc.File.View.ReadUInt32 (pent.Offset+4);
var input = arc.File.CreateStream (pent.Offset+12, size);
return new ZLibStream (input, CompressionMode.Decompress);
}
}
}

2
ArcFormats/StudioJikkenshitsu/ImageDAT.cs
View File

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

41
ArcFormats/StudioJikkenshitsu/ImageGRC.cs
View File

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

75
Experimental/Microsoft/ArcEXE.cs
View File

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

11
GameRes/ArcView.cs
View File

@ -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])

40
GameRes/BinaryStream.cs
View File

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

301
Legacy/Bom/ImageGRP.cs
View File

@ -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;
}
}

27
Legacy/Discovery/ArcDAT.cs
View File

@ -33,6 +33,7 @@ using GameRes.Compression;
// [000225][Discovery] Tsukiyo no Hitomi wa Kurenai ni
// [001102][Discovery] Twins Rhapsody
// [020414][Studio Air] Tamayura
namespace GameRes.Formats.Discovery
{
@ -43,6 +44,7 @@ namespace GameRes.Formats.Discovery
public int BPP;
public int Colors;
public int Extra;
public bool IsMask;
}
internal class EDataEntry : PackedEntry
@ -102,12 +104,14 @@ namespace GameRes.Formats.Discovery
var entry = FormatCatalog.Instance.Create<BDataEntry> (name);
entry.Size = index.ToUInt32 (index_offset+4);
entry.UnpackedSize = index.ToUInt32 (index_offset+8);
entry.IsPacked = entry.Size != entry.UnpackedSize;
entry.Offset = index.ToUInt32 (index_offset+0xC);
if (!entry.CheckPlacement (file.MaxOffset))
return null;
entry.Width = index.ToUInt32 (index_offset+0x10);
entry.Height = index.ToUInt32 (index_offset+0x14);
entry.BPP = index[index_offset+1];
entry.IsMask = index[index_offset+2] == 1;
entry.Extra = index.ToUInt16 (index_offset+0x28);
entry.Colors = index.ToUInt16 (index_offset+0x2A);
dir.Add (entry);
@ -263,6 +267,8 @@ namespace GameRes.Formats.Discovery
ImageData m_image;
int m_colors;
int m_extra;
bool m_is_packed;
bool m_is_mask;
public Stream Source { get { m_input.Position = 0; return m_input.AsStream; } }
public ImageFormat SourceFormat { get { return null; } }
@ -276,12 +282,17 @@ namespace GameRes.Formats.Discovery
public BDataDecoder (ArcFile arc, BDataEntry entry)
{
Info = new ImageMetaData { Width = entry.Width, Height = entry.Height, BPP = entry.BPP };
m_is_packed = entry.IsPacked;
m_is_mask = entry.IsMask;
uint total_size = entry.Size;
total_size += (uint)entry.Colors * 4;
if (entry.Extra > 0)
total_size += 10 * (uint)entry.Extra + 2;
Stride = ((int)entry.Width * entry.BPP / 8 + 3) & ~3;
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;

206
Legacy/Koei/ArcYK.cs Normal file
View File

@ -0,0 +1,206 @@
//! \file ArcYK.cs
//! \date 2023 Sep 10
//! \brief Koei data archive.
//
// Copyright (C) 2023 by morkt
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to
// deal in the Software without restriction, including without limitation the
// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
// sell copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
// IN THE SOFTWARE.
//
using GameRes.Utility;
using System.Collections.Generic;
using System.ComponentModel.Composition;
using System.IO;
using System.Windows.Media;
// [990312][Koei] Yakusoku no Kizuna
namespace GameRes.Formats.Koei
{
internal class YkArchive : ArcFile
{
public readonly string YkName;
public YkArchive (ArcView arc, ArchiveFormat impl, ICollection<Entry> dir, string name)
: base (arc, impl, dir)
{
YkName = name;
}
}
internal class YkEntry : Entry
{
public int Id;
}
[Export(typeof(ArchiveFormat))]
public partial class YkOpener : ArchiveFormat
{
public override string Tag => "YK";
public override string Description => "Koei resource archive";
public override uint Signature => 0;
public override bool IsHierarchic => false;
public override bool CanWrite => false;
public override ArcFile TryOpen (ArcView file)
{
if (!file.Name.HasExtension (".YK"))
return null;
var name = Path.GetFileNameWithoutExtension (file.Name).ToUpperInvariant();
List<Entry> dir = null;
if ("DATA01" == name)
dir = GetData01Index (file);
else if (OffsetTable.ContainsKey (name))
dir = GetDataIndex (file, OffsetTable[name], name);
if (null == dir)
return null;
return new YkArchive (file, this, dir, name);
}
List<Entry> GetData01Index (ArcView file)
{
int count = (int)(file.MaxOffset / 0x4B400);
if (!IsSaneCount (count) || count * 0x4B400 != file.MaxOffset)
return null;
uint offset = 0;
var dir = new List<Entry> (count);
for (int i = 0; i < count; ++i)
{
var entry = new Entry {
Name = string.Format ("{0:D5}.BMP", i),
Type = "image",
Offset = offset,
Size = 0x4B400
};
dir.Add (entry);
offset += 0x4B400;
}
return dir;
}
List<Entry> GetDataIndex (ArcView file, uint[] offsets, string name)
{
var dir = new List<Entry> (offsets.Length);
uint current_offset = 0;
for (int i = 0; i < offsets.Length; ++i)
{
var entry = new YkEntry {
Name = string.Format ("{0}#{1:D4}", name, i),
Offset = current_offset,
Size = offsets[i] - current_offset,
Id = i
};
if (!entry.CheckPlacement (file.MaxOffset))
return null;
if ("DATA02" == name && (i >= 11 || Data02Images.ContainsKey (i)))
{
entry.Name += ".BMP";
entry.Type = "image";
}
else if (IsAudio.Contains (name))
{
entry.Name += ".WAV";
entry.Type = "audio";
}
dir.Add (entry);
current_offset = offsets[i];
}
return dir;
}
public override Stream OpenEntry (ArcFile arc, Entry entry)
{
var yarc = (YkArchive)arc;
if ("DATA03" == yarc.YkName)
{
var data = arc.File.View.ReadBytes (entry.Offset, entry.Size);
DecryptData03 (data);
return new BinMemoryStream (data, entry.Name);
}
else if (IsAudio.Contains (yarc.YkName))
return OpenAudio (arc, entry);
else
return base.OpenEntry (arc, entry);
}
public override IImageDecoder OpenImage (ArcFile arc, Entry entry)
{
var yarc = (YkArchive)arc;
if (yarc.YkName == "DATA02")
return OpenData02Image (arc, (YkEntry)entry);
else if (yarc.YkName != "DATA01")
return base.OpenImage (arc, entry);
var input = arc.File.CreateStream (entry.Offset, entry.Size);
return new YkImageDecoder (input, new ImageMetaData { Width = 640, Height = 480, BPP = 8 });
}
IImageDecoder OpenData02Image (ArcFile arc, YkEntry entry)
{
ImageMetaData info;
if (entry.Id >= 189)
info = new ImageMetaData { Width = 128, Height = 192, BPP = 8 };
else if (!Data02Images.TryGetValue (entry.Id, out info) || null == info)
return base.OpenImage (arc, entry);
var input = arc.File.CreateStream (entry.Offset, entry.Size);
return new YkImageDecoder (input, info);
}
static readonly byte[] RiffHeader = new byte[] {
(byte)'R', (byte)'I', (byte)'F', (byte)'F', 0, 0, 0, 0,
(byte)'W', (byte)'A', (byte)'V', (byte)'E', (byte)'f', (byte)'m', (byte)'t', (byte)' ',
};
Stream OpenAudio (ArcFile arc, Entry entry)
{
var header = RiffHeader.Clone() as byte[];
LittleEndian.Pack (entry.Size+8u, header, 4);
var wave = arc.File.CreateStream (entry.Offset, entry.Size);
return new PrefixStream (header, wave);
}
unsafe void DecryptData03 (byte[] data)
{
int count = data.Length >> 2;
fixed (byte* data8 = &data[0])
{
uint* data32 = (uint*)data8;
while (count --> 0)
{
*data32++ ^= 0x12C4D65u;
}
}
}
}
internal class YkImageDecoder : BinaryImageDecoder
{
public YkImageDecoder (IBinaryStream input, ImageMetaData info) : base (input, info)
{
}
protected override ImageData GetImageData ()
{
m_input.Position = 0;
var palette = ImageFormat.ReadPalette (m_input.AsStream);
int size = Info.iWidth * Info.iHeight;
var pixels = m_input.ReadBytes (size);
return ImageData.CreateFlipped (Info, PixelFormats.Indexed8, palette, pixels, Info.iWidth);
}
}
}

923
Legacy/Koei/YkTables.cs Normal file
View File

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

5
Legacy/Legacy.csproj
View File

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

97
Legacy/Nug/ArcDAT.cs Normal file
View File

@ -0,0 +1,97 @@
//! \file ArcDAT.cs
//! \date 2023 Sep 10
//! \brief NUG System resource archive.
//
// Copyright (C) 2023 by morkt
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to
// deal in the Software without restriction, including without limitation the
// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
// sell copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
// IN THE SOFTWARE.
//
using GameRes.Compression;
using System;
using System.Collections.Generic;
using System.ComponentModel.Composition;
using System.IO;
namespace GameRes.Formats.Nug
{
[Export(typeof(ArchiveFormat))]
public class FwaOpener : ArchiveFormat
{
public override string Tag => "DAT/FWA";
public override string Description => "Frontwing resource archive";
public override uint Signature => 0x46574131; // '1AWF'
public override bool IsHierarchic => false;
public override bool CanWrite => false;
public override ArcFile TryOpen (ArcView file)
{
int count = file.View.ReadInt32 (0xC);
if (!IsSaneCount (count))
return null;
long index_offset = file.View.ReadUInt32 (0x10) + count * 4;
uint index_size = (uint)count * 0x40u;
if (index_size > file.View.Reserve (index_offset, index_size))
return null;
var dir = new List<Entry> (count);
for (int i = 0; i < count; ++i)
{
uint entry_size = file.View.ReadUInt32 (index_offset);
if (entry_size < 0x40)
return null;
var name = file.View.ReadString (index_offset+0x10, 0x30);
var entry = Create<PackedEntry> (name);
entry.Offset = file.View.ReadUInt32 (index_offset+4);
entry.Size = file.View.ReadUInt32 (index_offset+8);
if (!entry.CheckPlacement (file.MaxOffset))
return null;
entry.UnpackedSize = entry.Size;
dir.Add (entry);
index_offset += entry_size;
}
return new ArcFile (file, this, dir);
}
public override Stream OpenEntry (ArcFile arc, Entry entry)
{
var pent = (PackedEntry)entry;
var offset = entry.Offset;
uint signature = arc.File.View.ReadUInt32 (offset);
if (!pent.IsPacked && entry.Size > 0x20)
{
if (signature == 0x46574353) // 'SCWF'
{
pent.IsPacked = true;
pent.UnpackedSize = arc.File.View.ReadUInt32 (offset+0x10);
entry.Offset += 0x20;
entry.Size -= 0x20;
}
else if (signature == 0x46574343) // 'CCWF'
{
entry.Offset += 0x20;
entry.Size = arc.File.View.ReadUInt32 (offset+0x10);
}
}
Stream input = arc.File.CreateStream (entry.Offset, entry.Size);
if (pent.IsPacked)
input = new LzssStream (input);
return input;
}
}
}

4
Legacy/Properties/AssemblyInfo.cs
View File

@ -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")]