├── include
    ├── msvc
    │   └── unistd.h
    ├── npaversion.hpp.in
    ├── onpafile.hpp
    ├── flex.hpp
    ├── isgfile.hpp
    ├── fscommon.hpp
    ├── npafile.hpp
    ├── exefile.hpp
    ├── inpafile.hpp
    ├── buffer.hpp
    ├── scriptfile.hpp
    ├── inipafile.hpp
    ├── nsbconstants.hpp
    └── nsbmagic.hpp
├── .gitignore
├── src
    ├── inpafile.cpp
    ├── npafile.cpp
    ├── onpafile.cpp
    ├── isgfile.cpp
    ├── fscommon.cpp
    ├── buffer.cpp
    ├── exefile.cpp
    ├── lexer.l
    ├── scriptfile.cpp
    ├── inipafile.cpp
    ├── nsscompiler.hpp
    ├── nsscompiler.cpp
    ├── parser.y
    ├── nsbmagic.cpp
    ├── nsbconstants.cpp
    └── npakeys.cpp
├── README.md
├── LICENSE
├── cmake
    └── Modules
    │   └── get-git-revision.cmake
├── .travis.yml
└── CMakeLists.txt


/include/msvc/unistd.h:
--------------------------------------------------------------------------------
1 | // msvc doesn't have unistd.h, the equivalent is io.h
2 | // thus, a dummy unistd.h that includes io.h is used
3 | // if msvc is detected
4 | #include <io.h>
5 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | 
 2 | # cmake files
 3 | CMakeFiles/
 4 | CMakeCache.txt
 5 | *.cmake
 6 | Makefile
 7 | _CPack_Packages
 8 | install_manifest.txt
 9 | *.tar.bz2
10 | include/npaversion.hpp
11 | !cmake/Modules/*.cmake
12 | 
13 | # libraries
14 | *.a
15 | *.dll
16 | *.dylib
17 | *.lib
18 | *.so
19 | 


--------------------------------------------------------------------------------
/include/npaversion.hpp.in:
--------------------------------------------------------------------------------
 1 | #ifndef NPA_VERSION_HPP
 2 | #define NPA_VERSION_HPP
 3 | 
 4 | #define NPA_VERSION       "@LIBNPA_VERSION@"
 5 | #define NPA_VERSION_MAJOR "@LIBNPA_VERSION_MAJOR@"
 6 | #define NPA_VERSION_MINOR "@LIBNPA_VERSION_MINOR@"
 7 | #define NPA_VERSION_PATCH "@LIBNPA_VERSION_PATCH@"
 8 | #define NPA_VERSION_GIT   "@LIBNPA_VERSION_GIT@"
 9 | 
10 | #endif
11 | 


--------------------------------------------------------------------------------
/include/onpafile.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef O_NPA_FILE_HPP
 2 | #define O_NPA_FILE_HPP
 3 | 
 4 | #include "npafile.hpp"
 5 | #include <map>
 6 | 
 7 | class ONpaFile : NpaFile
 8 | {
 9 | public:
10 |     ONpaFile(const string& Filename);
11 |     virtual ~ONpaFile();
12 | 
13 |     void WriteFile(const string& Filename);
14 | 
15 | private:
16 |     void WriteToDisk();
17 |     map<string, uint32_t> Registry;
18 | };
19 | 
20 | #endif
21 | 


--------------------------------------------------------------------------------
/src/inpafile.cpp:
--------------------------------------------------------------------------------
 1 | #include "inpafile.hpp"
 2 | 
 3 | INpaFile::~INpaFile()
 4 | {
 5 |      for (auto i = Registry.begin(); i != Registry.end(); ++i)
 6 |         delete i->second;
 7 | }
 8 | 
 9 | char* INpaFile::ReadFile(const string& Filename, uint32_t& Size)
10 | {
11 |     auto iter = FindFile(Filename);
12 |     if (iter == End())
13 |         return nullptr;
14 | 
15 |     char* pData = ReadFile(iter);
16 |     Size = GetFileSize(iter);
17 |     return pData;
18 | }
19 | 


--------------------------------------------------------------------------------
/include/flex.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef FLEX_HPP
 2 | #define FLEX_HPP
 3 | 
 4 | typedef struct yy_buffer_state* YY_BUFFER_STATE;
 5 | extern int yyparse();
 6 | #if ((FLEX_VERSION_MAJOR == 2 && FLEX_VERSION_MINOR == 6 && FLEX_VERSION_PATCH == 0) || \
 7 |     (FLEX_VERSION_MAJOR == 2 && FLEX_VERSION_MINOR == 5 && FLEX_VERSION_PATCH > 35))
 8 | extern YY_BUFFER_STATE yy_scan_bytes(const char* bytes, size_t len);
 9 | #else
10 | extern YY_BUFFER_STATE yy_scan_bytes(const char* bytes, int len);
11 | #endif
12 | extern void yy_delete_buffer(YY_BUFFER_STATE buffer);
13 | 
14 | #endif
15 | 


--------------------------------------------------------------------------------
/include/isgfile.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef I_SG_FILE_HPP
 2 | #define I_SG_FILE_HPP
 3 | 
 4 | #include "inpafile.hpp"
 5 | #include <map>
 6 | 
 7 | class ISGFile : public INpaFile
 8 | {
 9 | public:
10 |     ISGFile(const string& Filename);
11 |     ~ISGFile();
12 | 
13 |     struct SGEntry : INpaFile::Entry
14 |     {
15 |         uint32_t Unk;
16 |     };
17 | 
18 |     char* ReadFile(NpaIterator iter);
19 |     virtual char* ReadData(NpaIterator iter, uint32_t LocalOffset, uint32_t Size, void *(*Alloc)(size_t) = DefaultAlloc);
20 |     bool IsDirectory(NpaIterator iter);
21 | 
22 | private:
23 |     void ReadHeader();
24 | };
25 | 
26 | #endif
27 | 


--------------------------------------------------------------------------------
/include/fscommon.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef FS_COMMON_HPP
 2 | #define FS_COMMON_HPP
 3 | 
 4 | #include <string>
 5 | #include <cstdint>
 6 | using namespace std;
 7 | 
 8 | namespace fs
 9 | {
10 |     uint32_t FileSize(ifstream& File);
11 |     uint32_t FileSize(const string& Filename);
12 |     char* ReadFile(const string& Filename, uint32_t& Size);
13 |     void WriteFileDirectory(const string& Filename, const char* pData, uint32_t Size);
14 |     void WriteFile(const string& Filename, const char* pData, uint32_t Size);
15 |     bool Exists(const string& Path);
16 |     void CreateDirectory(const string& Path);
17 |     void DeleteFile(const string& Path);
18 |     void DeleteDirectory(const string& Path);
19 | }
20 | 
21 | #endif
22 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | libnpa
 2 | ======
 3 | 
 4 | libnpa is a free library for manipulating .npa (NitroPlus Archive) files.
 5 | It can also parse and recompile .nsb and .map scripts from nss.npa archive.
 6 | 
 7 | Building
 8 | --------
 9 | 
10 | It is the choice of the Steins Gate if you can build from master branch today:
11 | [![Travis Build Status](https://travis-ci.org/FGRE/libnpa.svg?branch=master)][1]
12 | 
13 |     $ git clone https://github.com/FGRE/libnpa.git
14 |     $ cd libnpa
15 | 
16 | optionally, check out latest tag, if master branch status is red:
17 | 
18 |     $ git checkout `git describe --tags --abbrev=0`
19 | 
20 | now compile:
21 | 
22 |     $ cmake .
23 |     $ make
24 | 
25 | [1]: https://travis-ci.org/FGRE/libnpa
26 | 


--------------------------------------------------------------------------------
/include/npafile.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef NPA_FILE_HPP
 2 | #define NPA_FILE_HPP
 3 | 
 4 | #include <string>
 5 | #include <boost/locale.hpp>
 6 | using namespace std;
 7 | 
 8 | class NpaFile
 9 | {
10 | public:
11 |     NpaFile(const string& Name);
12 |     virtual ~NpaFile() = 0;
13 | 
14 |     static void SetLocale(const char* LocaleStr);
15 |     static string ToUtf8(const char* pBuff, uint32_t Size);
16 |     static string ToUtf8(const string& String);
17 |     static string ToUtf8(const char* pText);
18 |     static string FromUtf8(const string& String);
19 |     static char* Decrypt(char* pBuff, uint32_t Size, uint32_t Offset = 0);
20 |     static char* Encrypt(char* pBuff, uint32_t Size);
21 | 
22 | protected:
23 |     string Name;
24 | private:
25 |     static locale Locale;
26 | };
27 | 
28 | #endif
29 | 


--------------------------------------------------------------------------------
/include/exefile.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef EXE_FILE_HPP
 2 | #define EXE_FILE_HPP
 3 | 
 4 | #include <string>
 5 | #include <vector>
 6 | #include <fstream>
 7 | using namespace std;
 8 | 
 9 | class ExeFile
10 | {
11 |     struct SectionHeader
12 |     {
13 |         uint32_t VirtualAddress;
14 |         uint32_t SizeOfRawData;
15 |         uint32_t PointerToRawData;
16 |     };
17 | public:
18 |     ExeFile(const string& Name, uint8_t CharWidth);
19 |     template <class T> T Read(uint32_t Address);
20 | 
21 | private:
22 |     uint32_t VirtualToPhysical(uint32_t Address);
23 | 
24 |     uint8_t CharWidth;
25 |     uint32_t ImageBase;
26 |     const string Name;
27 |     vector<SectionHeader> Sections;
28 | };
29 | 
30 | template <class T> T ExeFile::Read(uint32_t Address)
31 | {
32 |     T Ret;
33 |     ifstream File(Name, ios::binary);
34 |     uint32_t PhysicalAddress = VirtualToPhysical(Address);
35 | 
36 |     if (PhysicalAddress == 0)
37 |         return T();
38 | 
39 |     File.seekg(PhysicalAddress);
40 |     File.read((char*)&Ret, sizeof(T));
41 |     return Ret;
42 | }
43 | 
44 | template <> string ExeFile::Read(uint32_t Address);
45 | 
46 | #endif
47 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) 2013-2016,2018 Mislav Blažević
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy of
 6 | this software and associated documentation files (the "Software"), to deal in
 7 | the Software without restriction, including without limitation the rights to
 8 | use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
 9 | the Software, and to permit persons to whom the Software is furnished to do so,
10 | subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
17 | FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
18 | COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
19 | IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
20 | CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
21 | 


--------------------------------------------------------------------------------
/include/inpafile.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef I_NPA_FILE_HPP
 2 | #define I_NPA_FILE_HPP
 3 | 
 4 | #include "npafile.hpp"
 5 | #include <map>
 6 | 
 7 | // GStreamer requires g_malloc instead of ::operator new because it deallocates memory with g_free
 8 | void* DefaultAlloc(size_t Size);
 9 | 
10 | class INpaFile : public NpaFile
11 | {
12 | public:
13 |     struct Entry
14 |     {
15 |         virtual ~Entry() {}
16 |         uint32_t Size;
17 |         uint32_t Offset;
18 |     };
19 |     typedef map<string, Entry*> NpaRegistry;
20 |     typedef NpaRegistry::iterator NpaIterator;
21 | 
22 |     INpaFile(const string& Filename) : NpaFile(Filename) { }
23 |     virtual ~INpaFile() = 0;
24 | 
25 |     virtual bool IsDirectory(NpaIterator iter) = 0;
26 |     char* ReadFile(const string& Filename, uint32_t& Size);
27 |     virtual char* ReadFile(NpaIterator iter) = 0;
28 |     virtual char* ReadData(NpaIterator iter, uint32_t LocalOffset, uint32_t Size, void *(*Alloc)(size_t) = DefaultAlloc) = 0;
29 | 
30 |     NpaIterator Begin() { return Registry.begin(); }
31 |     NpaIterator End() { return Registry.end(); }
32 |     NpaIterator FindFile(const string& Filename) { return Registry.find(Filename); }
33 |     uint32_t GetFileSize(NpaIterator iter) { return iter->second->Size; }
34 | 
35 | protected:
36 |     NpaRegistry Registry;
37 | };
38 | 
39 | #endif
40 | 


--------------------------------------------------------------------------------
/include/buffer.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef BUFFER_HPP
 2 | #define BUFFER_HPP
 3 | 
 4 | #include <vector>
 5 | #include <string>
 6 | using namespace std;
 7 | 
 8 | namespace Npa
 9 | {
10 | 
11 | class Buffer
12 | {
13 | public:
14 |     Buffer();
15 |     Buffer(char* pData, uint32_t Size);
16 |     ~Buffer();
17 | 
18 |     template <class T> void Write(T Integer)
19 |     {
20 |         static_assert(is_fundamental<T>::value, "Buffer::Write<T> T must be trivial!");
21 |         Write(&Integer, sizeof(T));
22 |     }
23 |     void WriteStr16(const string& String);
24 |     void WriteStr32(const string& String);
25 |     void Write(const void* pData, uint32_t Size);
26 |     void Write(const void* pData, uint32_t Size, uint32_t Offset);
27 | 
28 |     template <class T> T Read()
29 |     {
30 |         static_assert(is_fundamental<T>::value, "Buffer::Read<T> T must be trivial!");
31 |         T Integer;
32 |         Read(&Integer, sizeof(T));
33 |         return Integer;
34 |     }
35 |     string ReadStr16();
36 |     string ReadStr32();
37 |     void Read(void* pDest, uint32_t Size);
38 |     void Read(void* pDest, uint32_t Size, uint32_t Offset);
39 | 
40 |     char* GetData();
41 |     uint32_t GetSize();
42 |     uint32_t GetIter();
43 |     bool EndOfBuffer();
44 | private:
45 |     uint32_t Size, Capacity, Iter;
46 |     char* pData;
47 | };
48 | 
49 | }
50 | #endif
51 | 


--------------------------------------------------------------------------------
/src/npafile.cpp:
--------------------------------------------------------------------------------
 1 | #include "npafile.hpp"
 2 | 
 3 | locale NpaFile::Locale;
 4 | 
 5 | NpaFile::NpaFile(const string& Name) : Name(Name)
 6 | {
 7 | }
 8 | 
 9 | NpaFile::~NpaFile()
10 | {
11 | }
12 | 
13 | void NpaFile::SetLocale(const char* LocaleStr)
14 | {
15 |     Locale = boost::locale::generator().generate(LocaleStr);
16 | }
17 | 
18 | char* NpaFile::Decrypt(char* pBuff, uint32_t Size, uint32_t Offset)
19 | {
20 |     static const uint8_t Key[8] = { 0xBD, 0xAA, 0xBC, 0xB4, 0xAB, 0xB6, 0xBC, 0xB4 };
21 |     for (uint32_t i = 0; i < Size; ++i)
22 |         pBuff[i] ^= Key[(i + Offset) % 8];
23 |     return pBuff;
24 | }
25 | 
26 | char* NpaFile::Encrypt(char* pBuff, uint32_t Size)
27 | {
28 |     return Decrypt(pBuff, Size);
29 | }
30 | 
31 | string NpaFile::ToUtf8(const char* pBuff, uint32_t Size)
32 | {
33 |     return boost::locale::conv::to_utf<char>(pBuff, pBuff + Size, Locale);
34 | }
35 | 
36 | string NpaFile::ToUtf8(const string& String)
37 | {
38 |     return boost::locale::conv::to_utf<char>(String.c_str(), String.c_str() + String.size(), Locale);
39 | }
40 | 
41 | string NpaFile::ToUtf8(const char* pText)
42 | {
43 |     return boost::locale::conv::to_utf<char>(pText, Locale);
44 | }
45 | 
46 | string NpaFile::FromUtf8(const string& String)
47 | {
48 |     return boost::locale::conv::from_utf<char>(String.c_str(), String.c_str() + String.size(), Locale);
49 | }
50 | 


--------------------------------------------------------------------------------
/cmake/Modules/get-git-revision.cmake:
--------------------------------------------------------------------------------
 1 | 
 2 | # this function returns the git hash of the current checkout, if the 'git'
 3 | # command is available, it is a git checkout and it is not a tagged release.
 4 | function(get_git_revision _hashvar)
 5 |     # got git?
 6 |     if(NOT GIT_FOUND)
 7 |         find_package(Git QUIET)
 8 |     endif()
 9 |     if(GIT_FOUND)
10 |         # TODO: look for source directory (for out-of-source builds)?
11 | 
12 |         # check, if we have a tagged release
13 |         execute_process(COMMAND ${GIT_EXECUTABLE} describe --tags --exact-match
14 |             WORKING_DIRECTORY "${CMAKE_SOURCE_DIR}"
15 |             RESULT_VARIABLE EXIT_CODE
16 |             OUTPUT_QUIET
17 |             ERROR_QUIET
18 |         )
19 |         # it failed => not a tagged revision
20 |         if(NOT ${EXIT_CODE} EQUAL 0)
21 |             execute_process(COMMAND ${GIT_EXECUTABLE} rev-parse --short=10 HEAD
22 |                 WORKING_DIRECTORY "${CMAKE_SOURCE_DIR}"
23 |                 RESULT_VARIABLE EXIT_CODE
24 |                 OUTPUT_VARIABLE GIT_REV
25 |                 ERROR_QUIET
26 |                 OUTPUT_STRIP_TRAILING_WHITESPACE
27 |             )
28 |             if(${EXIT_CODE} EQUAL 0)
29 |                 # all good, set hash
30 |                 set(${_hashvar} "${GIT_REV}" PARENT_SCOPE)
31 |                 return()
32 |             endif()
33 |         endif()
34 |     endif()
35 |     # no git available or any other error above, set to empty string
36 |     set(${_hashvar} "" PARENT_SCOPE)
37 | endfunction()
38 | 


--------------------------------------------------------------------------------
/src/onpafile.cpp:
--------------------------------------------------------------------------------
 1 | #include "onpafile.hpp"
 2 | #include "fscommon.hpp"
 3 | #include "buffer.hpp"
 4 | #include <fstream>
 5 | using namespace Npa;
 6 | 
 7 | ONpaFile::ONpaFile(const string& Filename) : NpaFile(Filename)
 8 | {
 9 | }
10 | 
11 | ONpaFile::~ONpaFile()
12 | {
13 |     WriteToDisk();
14 | }
15 | 
16 | void ONpaFile::WriteFile(const string& Filename)
17 | {
18 |     Registry[Filename] = 0;
19 | }
20 | 
21 | void ONpaFile::WriteToDisk()
22 | {
23 |     // Create header
24 |     Buffer Header;
25 |     Header.Write<uint32_t>(Registry.size());
26 |     for (auto iter = Registry.begin(); iter != Registry.end(); ++iter)
27 |     {
28 |         Header.WriteStr32(FromUtf8(iter->first));
29 |         Header.Write<uint32_t>(fs::FileSize(iter->first));
30 |         iter->second = Header.GetSize();
31 |         Header.Write<uint32_t>(0); // Offset
32 |         Header.Write<uint32_t>(0); // Unk
33 |     }
34 | 
35 |     // Calculate offsets
36 |     uint32_t Pos = 4 + Header.GetSize();
37 |     for (auto iter = Registry.begin(); iter != Registry.end(); ++iter)
38 |     {
39 |         Header.Write(&Pos, 4, iter->second);
40 |         Pos += fs::FileSize(iter->first);
41 |     }
42 | 
43 |     // Write data
44 |     ofstream File(Name, ios::binary);
45 |     uint32_t Size = Header.GetSize();
46 |     File.write((char*)&Size, 4);
47 |     File.write(Encrypt(Header.GetData(), Size), Size);
48 |     for (auto iter = Registry.begin(); iter != Registry.end(); ++iter)
49 |     {
50 |         uint32_t Size;
51 |         char* pData = fs::ReadFile(iter->first, Size);
52 |         File.write(Encrypt(pData, Size), Size);
53 |         delete[] pData;
54 |     }
55 | }
56 | 


--------------------------------------------------------------------------------
/include/scriptfile.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef SCRIPT_FILE_HPP
 2 | #define SCRIPT_FILE_HPP
 3 | 
 4 | #include <vector>
 5 | #include <string>
 6 | #include <map>
 7 | #include <list>
 8 | #include <cstdint>
 9 | using namespace std;
10 | #define NSB_INVALIDE_LINE ~(uint32_t)0
11 | 
12 | namespace Npa
13 | {
14 |     class Buffer;
15 | }
16 | 
17 | struct Line
18 | {
19 |     uint16_t Magic;
20 |     vector<string> Params;
21 |     string Stringify() const;
22 | };
23 | 
24 | class ScriptFile
25 | {
26 | public:
27 |     enum FileType
28 |     {
29 |         NSB,
30 |         NSS
31 |     };
32 | 
33 |     ScriptFile(const string& Name, const char* NssData, uint32_t NssSize);
34 |     ScriptFile(const string& Name, char* NsbData, uint32_t NsbSize, char* MapData, uint32_t MapSize);
35 |     ScriptFile(const string& Name, FileType Type);
36 | 
37 |     const map<string, uint32_t> GetSymbols() { return Symbols; }
38 |     const list<string>& GetIncludes() { return Includes; }
39 |     uint32_t GetSymbol(const string& Symbol);
40 |     const string& GetName() const { return Name; }
41 |     Line* GetLine(uint32_t Entry) { return Entry < Source.size() ? &Source[Entry] : nullptr; }
42 | 
43 | private:
44 |     void OpenNss(const string& Name);
45 |     void OpenNsb(string Name);
46 |     void ReadNss(const char* NssData, uint32_t NssSize);
47 |     void ReadNsb(Npa::Buffer& NsbData, Npa::Buffer& MapData);
48 | 
49 |     map<string, uint32_t> Symbols;
50 |     list<string> Includes;
51 |     vector<Line> Source;
52 |     const string Name;
53 | };
54 | 
55 | namespace Nss
56 | {
57 |     void Compile(const char* pBuffer, uint32_t Length, Npa::Buffer* NsbBuffer, Npa::Buffer* MapBuffer);
58 | }
59 | 
60 | #endif
61 | 


--------------------------------------------------------------------------------
/.travis.yml:
--------------------------------------------------------------------------------
 1 | language: cpp
 2 | 
 3 | compiler:
 4 |   - gcc
 5 |   - clang
 6 | 
 7 | env:
 8 |   # this is our secret upload key $UPLOAD_TOKEN:
 9 |   secure: "I14aeKfPaQ7nWFW5Gn4g4bnO01iCP//Zmm9dfdhbvd7k21VfB3azxo/NkAYTYN9Z1tyZTeVP41yfGUIDCIep3+fOdhJ+qcFeOzm83CoMqffdnRgDGXdCzIMpelEMUcbRCA+5M9E0fmWk3Dt0FZVVFzpmJ+zVvpyg5zg/HjYw178="
10 | 
11 | branches:
12 |   only:
13 |     - master
14 | 
15 | notifications:
16 |   email:
17 |     on_success: change
18 |     on_failure: change
19 |   irc:
20 |     channels:
21 |       # WORKAROUND: prevents notifications from forks
22 |       secure: HI4IIeMAn+dJ0/mzLL4XioTO7nppC5tbsqfns+VbY4fS2nSQAfyspPck1Hc7ovZT9WfikZmz4yqBxkwQdIiGXjmyV0My+SLwjiWuyLtNtIVr8YnUE3dDbpOz1saZXel/PbmU0z5b8dda5SC+ps5VcdfzSh7NeHLC8J4LABgQhN4=
23 |     template:
24 |       - "%{repository_name} (%{commit}): %{message}, details: %{build_url}"
25 |     on_success: change
26 |     on_failure: change
27 |     use_notice: true
28 |     skip_join: true
29 | 
30 | before_install:
31 |   - sudo add-apt-repository -y ppa:ubuntu-toolchain-r/test
32 |   - sudo add-apt-repository -y ppa:boost-latest/ppa
33 |   - sudo apt-get update -qq
34 | 
35 | install:
36 |   - sudo apt-get install -qq libboost-locale1.55-dev libboost-filesystem1.55-dev curl
37 |   - if [ "$CXX" = "g++" ]; then sudo apt-get install -qq g++-4.8; fi
38 | 
39 | before_script:
40 |   - if [ "$CXX" = "g++" ]; then export CXX="g++-4.8"; fi
41 | 
42 | script:
43 |   - cmake . && make
44 | 
45 | after_success:
46 |   - |
47 |     if [ "$CXX" = "g++-4.8" ]; then
48 |       curl https://gist.githubusercontent.com/carstene1ns/a23f152a40a589f098c6/raw/upload.sh > upload.sh
49 |       make package && bash upload.sh libnpa-*.tar.bz2
50 |     fi
51 | 


--------------------------------------------------------------------------------
/src/isgfile.cpp:
--------------------------------------------------------------------------------
 1 | #include "isgfile.hpp"
 2 | #include "buffer.hpp"
 3 | #include <fstream>
 4 | 
 5 | void* DefaultAlloc(size_t Size)
 6 | {
 7 |     return new char[Size];
 8 | }
 9 | 
10 | ISGFile::ISGFile(const string& Filename) : INpaFile(Filename)
11 | {
12 |     ReadHeader();
13 | }
14 | 
15 | ISGFile::~ISGFile()
16 | {
17 | }
18 | 
19 | void ISGFile::ReadHeader()
20 | {
21 |     ifstream File(Name, ios::binary);
22 |     if (!File)
23 |         return;
24 | 
25 |     uint32_t HeaderSize;
26 |     File.read((char*)&HeaderSize, 4);
27 |     Npa::Buffer SGBuffer(new char[HeaderSize], HeaderSize);
28 |     File.read(SGBuffer.GetData(), HeaderSize);
29 |     Decrypt(SGBuffer.GetData(), HeaderSize);
30 | 
31 |     uint32_t EntryCount = SGBuffer.Read<uint32_t>();
32 |     for (uint32_t i = 0; i < EntryCount; ++i)
33 |     {
34 |         string Filename = SGBuffer.ReadStr32();
35 |         SGEntry* pEntry = new SGEntry;
36 |         pEntry->Size = SGBuffer.Read<uint32_t>();
37 |         pEntry->Offset = SGBuffer.Read<uint32_t>();
38 |         pEntry->Unk = SGBuffer.Read<uint32_t>();
39 |         Registry[ToUtf8(Filename)] = pEntry;
40 |     }
41 | }
42 | 
43 | char* ISGFile::ReadFile(NpaIterator iter)
44 | {
45 |     return ReadData(iter, 0, GetFileSize(iter));
46 | }
47 | 
48 | char* ISGFile::ReadData(NpaIterator iter, uint32_t LocalOffset, uint32_t Size, void *(*Alloc)(size_t))
49 | {
50 |     ifstream File(Name, ios::binary);
51 |     if (!File)
52 |         return nullptr;
53 | 
54 |     char* pData = (char*)Alloc(Size);
55 |     File.seekg(iter->second->Offset + LocalOffset, File.beg);
56 |     File.read(pData, Size);
57 |     Decrypt(pData, Size, LocalOffset);
58 |     return pData;
59 | }
60 | 
61 | bool ISGFile::IsDirectory(NpaIterator iter)
62 | {
63 |     return false;
64 | }
65 | 


--------------------------------------------------------------------------------
/src/fscommon.cpp:
--------------------------------------------------------------------------------
 1 | #include "fscommon.hpp"
 2 | #include <fstream>
 3 | #include <boost/filesystem.hpp>
 4 | using namespace boost::filesystem;
 5 | 
 6 | namespace fs
 7 | {
 8 | 
 9 | uint32_t FileSize(std::ifstream& File)
10 | {
11 |     uint32_t Size;
12 |     File.seekg(0, ios::end);
13 |     Size = File.tellg();
14 |     File.seekg(0, ios::beg);
15 |     return Size;
16 | }
17 | 
18 | uint32_t FileSize(const string& Filename)
19 | {
20 |     std::ifstream File(Filename, ios::binary);
21 |     return File ? FileSize(File) : 0;
22 | }
23 | 
24 | char* ReadFile(const string& Filename, uint32_t& Size)
25 | {
26 |     std::ifstream File(Filename, ios::binary);
27 |     if (!File)
28 |         return nullptr;
29 | 
30 |     Size = FileSize(File);
31 |     char* pData = new char[Size];
32 |     File.read(pData, Size);
33 |     return pData;
34 | }
35 | 
36 | void WriteFileDirectory(const string& Filename, const char* pData, uint32_t Size)
37 | {
38 |     // Create directories
39 |     string Path = Filename;
40 |     if (char* delim = strchr((char*)Path.c_str(), '/'))
41 |     {
42 |         do
43 |         {
44 |             *delim = 0;
45 |             if (!Exists(Path))
46 |                 CreateDirectory(Path);
47 |             *delim = '/';
48 |         } while ((delim = strchr(delim + 1, '/')));
49 |     }
50 | 
51 |     WriteFile(Filename, pData, Size);
52 | }
53 | 
54 | void WriteFile(const string& Filename, const char* pData, uint32_t Size)
55 | {
56 |     std::ofstream File(Filename, ios::binary);
57 |     File.write(pData, Size);
58 | }
59 | 
60 | bool Exists(const string& Path)
61 | {
62 |     return exists(path(Path));
63 | }
64 | 
65 | void CreateDirectory(const string& Path)
66 | {
67 |     create_directory(path(Path));
68 | }
69 | 
70 | void DeleteFile(const string& Path)
71 | {
72 |     remove(path(Path));
73 | }
74 | 
75 | void DeleteDirectory(const string& Path)
76 | {
77 |     remove_all(path(Path));
78 | }
79 | 
80 | }
81 | 


--------------------------------------------------------------------------------
/include/inipafile.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef I_NIPA_FILE
 2 | #define I_NIPA_FILE
 3 | 
 4 | #include "inpafile.hpp"
 5 | 
 6 | class INipaFile : public INpaFile
 7 | {
 8 |     struct
 9 |     {
10 |         char Magic[7];
11 |         int32_t Key1;
12 |         int32_t Key2;
13 |         uint8_t Encrypt;
14 |         uint8_t Compress;
15 |         uint32_t FileCount;
16 |         uint32_t FolderCount;
17 |         uint32_t TotalCount;
18 |         uint64_t Unk;
19 |         uint32_t Start;
20 |     } NPAHeader;
21 | public:
22 |     enum
23 |     {
24 |         CHAOSHEAD = 0,
25 |         CHAOSHEADTR1,
26 |         CHAOSHEADTR2,
27 |         MURAMASATR,
28 |         MURAMASA,
29 |         SUMAGA,
30 |         DJANGO,
31 |         DJANGOTR,
32 |         LAMENTO,
33 |         LAMENTOTR,
34 |         SWEETPOOL,
35 |         SUMAGASP,
36 |         DEMONBANE,
37 |         MURAMASAAD,
38 |         AXANAEL,
39 |         KIKOKUGAI,
40 |         SONICOMITR2,
41 |         SUMAGA3P,
42 |         SONICOMI,
43 |         LOSTX,
44 |         LOSTXTRAILER,
45 |         DRAMATICALMURDER,
46 |         TOTONO
47 |     };
48 | 
49 |     struct NipaEntry : INpaFile::Entry
50 |     {
51 |         //uint32_t NameSize;
52 |         string Filename;
53 |         uint8_t Type;
54 |         uint32_t FileID;
55 |         uint32_t CompSize;
56 |     };
57 | 
58 |     INipaFile(const string& Name, uint8_t GameID);
59 |     ~INipaFile();
60 | 
61 |     char* ReadFile(NpaIterator iter);
62 |     virtual char* ReadData(NpaIterator iter, uint32_t LocalOffset, uint32_t Size, void *(*Alloc)(size_t) = DefaultAlloc);
63 |     bool IsDirectory(NpaIterator iter);
64 | 
65 |     static uint8_t GameStringToID(const string& String);
66 |     static const char** GetGameStringList();
67 | 
68 | protected:
69 |     void ReadHeader();
70 |     char FilenameCrypt(int32_t CharIndex, int32_t FileIndex);
71 |     char Crypt2(const char* Filename, int32_t origsize);
72 | 
73 |     uint8_t GameID;
74 | };
75 | 
76 | #endif
77 | 


--------------------------------------------------------------------------------
/src/buffer.cpp:
--------------------------------------------------------------------------------
  1 | #include "buffer.hpp"
  2 | #include <cstring>
  3 | 
  4 | namespace Npa
  5 | {
  6 | 
  7 | Buffer::Buffer() : pData(nullptr), Size(0), Capacity(0), Iter(0)
  8 | {
  9 | }
 10 | 
 11 | Buffer::Buffer(char* pData, uint32_t Size) : pData(pData), Size(Size), Iter(0)
 12 | {
 13 | }
 14 | 
 15 | Buffer::~Buffer()
 16 | {
 17 |     delete[] pData;
 18 | }
 19 | 
 20 | void Buffer::WriteStr16(const string& String)
 21 | {
 22 |     Write<uint16_t>(String.size());
 23 |     Write(String.c_str(), String.size());
 24 | }
 25 | 
 26 | void Buffer::WriteStr32(const string& String)
 27 | {
 28 |     Write<uint32_t>(String.size());
 29 |     Write(String.c_str(), String.size());
 30 | }
 31 | 
 32 | void Buffer::Write(const void* pData, uint32_t Size)
 33 | {
 34 |     if (!Capacity)
 35 |         Capacity = 1;
 36 | 
 37 |     while (Capacity < this->Size + Size)
 38 |         Capacity <<= 1;
 39 | 
 40 |     char* pNew = new char[Capacity];
 41 |     memcpy(pNew, this->pData, this->Size);
 42 |     delete[] this->pData;
 43 |     this->pData = pNew;
 44 |     Write(pData, Size, this->Size);
 45 |     this->Size += Size;
 46 | }
 47 | 
 48 | void Buffer::Write(const void* pData, uint32_t Size, uint32_t Offset)
 49 | {
 50 |     memcpy(this->pData + Offset, pData, Size);
 51 | }
 52 | 
 53 | string Buffer::ReadStr16()
 54 | {
 55 |     string String;
 56 |     String.resize(Read<uint16_t>());
 57 |     Read(&String[0], String.size());
 58 |     return String;
 59 | }
 60 | 
 61 | string Buffer::ReadStr32()
 62 | {
 63 |     string String;
 64 |     String.resize(Read<uint32_t>());
 65 |     Read(&String[0], String.size());
 66 |     return String;
 67 | }
 68 | 
 69 | void Buffer::Read(void* pDest, uint32_t Size)
 70 | {
 71 |     Read(pDest, Size, Iter);
 72 |     Iter += Size;
 73 | }
 74 | 
 75 | void Buffer::Read(void* pDest, uint32_t Size, uint32_t Offset)
 76 | {
 77 |     memcpy(pDest, pData + Offset, Size);
 78 | }
 79 | 
 80 | char* Buffer::GetData()
 81 | {
 82 |     return pData;
 83 | }
 84 | 
 85 | uint32_t Buffer::GetSize()
 86 | {
 87 |     return Size;
 88 | }
 89 | 
 90 | uint32_t Buffer::GetIter()
 91 | {
 92 |     return Iter;
 93 | }
 94 | 
 95 | bool Buffer::EndOfBuffer()
 96 | {
 97 |     return Iter >= Size;
 98 | }
 99 | 
100 | }
101 | 


--------------------------------------------------------------------------------
/src/exefile.cpp:
--------------------------------------------------------------------------------
 1 | #include "exefile.hpp"
 2 | #include "npafile.hpp"
 3 | #include <cstdint>
 4 | #include <cstring>
 5 | 
 6 | static const char PeSig[4] = { 'P', 'E', 0, 0 };
 7 | 
 8 | ExeFile::ExeFile(const string& Name, uint8_t CharWidth) :
 9 | Name(Name),
10 | ImageBase(0),
11 | CharWidth(CharWidth)
12 | {
13 |     ifstream File(Name, ios::binary);
14 |     if (!File)
15 |     {
16 |         cerr << "Could not open " << Name << endl;
17 |         return;
18 |     }
19 | 
20 |     // Signature
21 |     File.seekg(0x3C);
22 |     uint32_t PeOffset;
23 |     File.read((char*)&PeOffset, 4);
24 |     File.seekg(PeOffset);
25 |     char Sig[4];
26 |     File.read(Sig, 4);
27 |     if (memcmp(Sig, PeSig, 4) != 0)
28 |     {
29 |         cerr << "Invalid PE signature" << endl;
30 |         return;
31 |     }
32 | 
33 |     // File header
34 |     uint16_t NumSections;
35 |     File.seekg(2, File.cur);
36 |     File.read((char*)&NumSections, 2);
37 |     Sections.resize(NumSections);
38 |     File.seekg(16, File.cur);
39 | 
40 |     // Optional header
41 |     File.seekg(28, File.cur);
42 |     File.read((char*)&ImageBase, 4);
43 |     File.seekg(192, File.cur);
44 | 
45 |     // Section header
46 |     for (auto& i : Sections)
47 |     {
48 |         File.seekg(12, File.cur);
49 |         File.read((char*)&i.VirtualAddress, 4);
50 |         File.read((char*)&i.SizeOfRawData, 4);
51 |         File.read((char*)&i.PointerToRawData, 4);
52 |         File.seekg(16, File.cur);
53 |     }
54 | }
55 | 
56 | uint32_t ExeFile::VirtualToPhysical(uint32_t Address)
57 | {
58 |     Address -= ImageBase;
59 |     for (uint16_t i = 0; i < Sections.size(); ++i)
60 |     {
61 |         int32_t Diff = Address - Sections[i].VirtualAddress;
62 |         if (Diff >= 0 && Diff < Sections[i].SizeOfRawData)
63 |             return Diff + Sections[i].PointerToRawData;
64 |     }
65 |     return 0;
66 | }
67 | 
68 | template <> string ExeFile::Read(uint32_t Address)
69 | {
70 |     string Ret;
71 |     ifstream File(Name, ios::binary);
72 |     uint32_t PhysicalAddress = VirtualToPhysical(Address);
73 | 
74 |     if (PhysicalAddress == 0)
75 |         return Ret;
76 | 
77 |     File.seekg(PhysicalAddress);
78 |     uint16_t Char = 0;
79 |     do
80 |     {
81 |         File.read((char*)&Char, CharWidth);
82 |         if (Char) Ret.append((char*)&Char, CharWidth);
83 |     } while (Char);
84 |     return Ret.empty() ? Ret : NpaFile::ToUtf8(Ret);
85 | }
86 | 


--------------------------------------------------------------------------------
/src/lexer.l:
--------------------------------------------------------------------------------
 1 | %{
 2 | #include <string>
 3 | #include "nsscompiler.hpp"
 4 | #include "parser.hpp"
 5 | #define SAVE_TOKEN yylval.string = new std::string(yytext, yyleng)
 6 | #define TOKEN(t) (yylval.token = t)
 7 | %}
 8 | 
 9 | %option noyywrap
10 | 
11 | %%
12 | 
13 | "/*"((\*+[^/*])|([^*]))*\**"*/" ;
14 | "<PRE"(.|[ \t\v\n])*"</PRE>" SAVE_TOKEN; return TXML;
15 | [ \t\n\r]               ;
16 | "call_chapter"          return TOKEN(TCALLCHAPTER);
17 | "call_scene"            return TOKEN(TCALLSCENE);
18 | "function"              return TOKEN(TFUNCTION);
19 | "chapter"               return TOKEN(TCHAPTER);
20 | "scene"                 return TOKEN(TSCENE);
21 | "if"                    return TOKEN(TIF);
22 | "else"                  return TOKEN(TELSE);
23 | "while"                 return TOKEN(TWHILE);
24 | "select"                return TOKEN(TSELECT);
25 | "case"                  return TOKEN(TCASE);
26 | "return"                return TOKEN(TRETURN);
27 | "break"                 return TOKEN(TBREAK);
28 | "\""                    return TOKEN(TQUOTE);
29 | [a-zA-Zａ-ｚＡ-Ｚあ-ゖァ-ヺ一-龯_][/.a-zA-Zａ-ｚＡ-Ｚあ-ゖァ-ヺ一-龯０-９0-9_]*  SAVE_TOKEN; return TIDENTIFIER;
30 | \"([^\\\"]|\\.)*\"      SAVE_TOKEN; return TSTRING;
31 | [0-9]+\.[0-9]*          SAVE_TOKEN; return TFLOAT;
32 | [0-9]+                  SAVE_TOKEN; return TINTEGER;
33 | "#"[0-9A-Fa-f]{6}       SAVE_TOKEN; return THEX;
34 | ","                     return TOKEN(TCOMMA);
35 | ";"                     return TOKEN(TSEMICOLON);
36 | ":"                     return TOKEN(TCOLON);
37 | "$"                     return TOKEN(TDOLLAR);
38 | "#"                     return TOKEN(THASH);
39 | "="                     return TOKEN(TEQUAL);
40 | "("                     return TOKEN(TLPAREN);
41 | ")"                     return TOKEN(TRPAREN);
42 | "{"                     return TOKEN(TLBRACE);
43 | "}"                     return TOKEN(TRBRACE);
44 | "["                     return TOKEN(TLABRACE);
45 | "]"                     return TOKEN(TRABRACE);
46 | "+"                     return TOKEN(TADD);
47 | "-"                     return TOKEN(TSUB);
48 | "/"                     return TOKEN(TDIV);
49 | "%"                     return TOKEN(TMOD);
50 | "*"                     return TOKEN(TMUL);
51 | "<"                     return TOKEN(TLESS);
52 | ">"                     return TOKEN(TGREATER);
53 | "=="                    return TOKEN(TEQUALEQUAL);
54 | "!="                    return TOKEN(TNEQUAL);
55 | ">="                    return TOKEN(TGEQUAL);
56 | "<="                    return TOKEN(TLEQUAL);
57 | "&&"                    return TOKEN(TAND);
58 | "||"                    return TOKEN(TOR);
59 | "!"                     return TOKEN(TNOT);
60 | "@"                     return TOKEN(TAT);
61 | "#include"              return TOKEN(TINCLUDE);
62 | "BezierMove".*
63 | "//".*
64 | ".".*
65 | .                       printf("Unknown token!\n"); yyterminate();
66 | 
67 | %%
68 | 


--------------------------------------------------------------------------------
/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | cmake_minimum_required(VERSION 2.8)
 2 | 
 3 | # add modules
 4 | set (CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/Modules")
 5 | 
 6 | # set version
 7 | set(LIBNPA_VERSION_MAJOR "0")
 8 | set(LIBNPA_VERSION_MINOR "5")
 9 | set(LIBNPA_VERSION_PATCH "3")
10 | set(LIBNPA_VERSION "${LIBNPA_VERSION_MAJOR}.${LIBNPA_VERSION_MINOR}.${LIBNPA_VERSION_PATCH}")
11 | 
12 | # make sure all symbols are exported on Windows
13 | # currently requires cmake-dev (CMake 3.3.20150721 or newer)
14 | set(CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS ON)
15 | 
16 | # append git revision if available
17 | include(get-git-revision)
18 | get_git_revision(LIBNPA_VERSION_GIT)
19 | if(NOT "${LIBNPA_VERSION_GIT}" STREQUAL "")
20 |     set(LIBNPA_VERSION "${LIBNPA_VERSION}-${LIBNPA_VERSION_GIT}")
21 | endif()
22 | 
23 | message(STATUS "Configuring libnpa version " ${LIBNPA_VERSION})
24 | 
25 | # project name and language
26 | project (libnpa CXX)
27 | 
28 | set(CMAKE_BUILD_TYPE Debug)
29 | set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11 -O2")
30 | 
31 | # include version number in header
32 | configure_file(${PROJECT_SOURCE_DIR}/include/npaversion.hpp.in
33 |     ${PROJECT_SOURCE_DIR}/include/npaversion.hpp)
34 | 
35 | find_package(Boost REQUIRED COMPONENTS system locale filesystem)
36 | find_package(ZLIB REQUIRED)
37 | find_package(FLEX REQUIRED)
38 | find_package(BISON REQUIRED)
39 | 
40 | string(REPLACE "." ";" VERSION_LIST ${FLEX_VERSION})
41 | list(GET VERSION_LIST 0 FLEX_VERSION_MAJOR)
42 | list(GET VERSION_LIST 1 FLEX_VERSION_MINOR)
43 | list(GET VERSION_LIST 2 FLEX_VERSION_PATCH)
44 | add_definitions(-DFLEX_VERSION_MAJOR=${FLEX_VERSION_MAJOR})
45 | add_definitions(-DFLEX_VERSION_MINOR=${FLEX_VERSION_MINOR})
46 | add_definitions(-DFLEX_VERSION_PATCH=${FLEX_VERSION_PATCH})
47 | 
48 | include_directories(${PROJECT_SOURCE_DIR}/include
49 |     ${Boost_INCLUDE_DIR}
50 |     ${ZLIB_INCLUDE_DIR}
51 | )
52 | 
53 | # msvc doesn't have unistd.h, the equivalent is io.h
54 | # thus, a dummy unistd.h that includes io.h is used
55 | # if msvc is detected
56 | if(MSVC)
57 | 	include_directories(${PROJECT_SOURCE_DIR}/include/msvc)
58 | endif()
59 | 
60 | flex_target(lexer ${CMAKE_SOURCE_DIR}/src/lexer.l ${CMAKE_SOURCE_DIR}/src/lexer.cpp)
61 | bison_target(parser ${CMAKE_SOURCE_DIR}/src/parser.y ${CMAKE_SOURCE_DIR}/src/parser.cpp)
62 | add_flex_bison_dependency(lexer parser)
63 | 
64 | add_library(npa SHARED
65 |     src/inpafile.cpp
66 |     src/npafile.cpp
67 |     src/nsbmagic.cpp
68 |     src/onpafile.cpp
69 |     src/scriptfile.cpp
70 |     src/exefile.cpp
71 |     src/fscommon.cpp
72 |     src/inipafile.cpp
73 |     src/isgfile.cpp
74 |     src/npakeys.cpp
75 |     src/buffer.cpp
76 |     src/nsscompiler.cpp
77 |     ${BISON_parser_OUTPUTS}
78 |     ${FLEX_lexer_OUTPUTS}
79 |     src/nsbconstants.cpp
80 | )
81 | target_link_libraries(npa ${Boost_LIBRARIES} ${ZLIB_LIBRARIES})
82 | 
83 | # install headers and library
84 | install(DIRECTORY ${PROJECT_SOURCE_DIR}/include/
85 |     DESTINATION include/libnpa
86 |     FILES_MATCHING PATTERN "*.hpp")
87 | install(TARGETS npa DESTINATION lib)
88 | 
89 | # create packages
90 | set(CPACK_GENERATOR "TBZ2")
91 | set(CPACK_PACKAGE_VERSION ${LIBNPA_VERSION})
92 | include(CPack)
93 | 


--------------------------------------------------------------------------------
/src/scriptfile.cpp:
--------------------------------------------------------------------------------
  1 | #include "scriptfile.hpp"
  2 | #include "npafile.hpp"
  3 | #include "fscommon.hpp"
  4 | #include "buffer.hpp"
  5 | #include "nsbmagic.hpp"
  6 | #include <cstring>
  7 | using namespace Npa;
  8 | 
  9 | ScriptFile::ScriptFile(const string& Name, const char* NssData, uint32_t NssSize) :
 10 | Name(Name)
 11 | {
 12 |     ReadNss(NssData, NssSize);
 13 | }
 14 | 
 15 | ScriptFile::ScriptFile(const string& Name, char* NsbData, uint32_t NsbSize, char* MapData, uint32_t MapSize) :
 16 | Name(Name)
 17 | {
 18 |     Buffer NsbBuffer(NsbData, NsbSize);
 19 |     Buffer MapBuffer(MapData, MapSize);
 20 |     ReadNsb(NsbBuffer, MapBuffer);
 21 | }
 22 | 
 23 | ScriptFile::ScriptFile(const string& Name, FileType Type) :
 24 | Name(Name)
 25 | {
 26 |     switch (Type)
 27 |     {
 28 |         case NSS: OpenNss(Name); break;
 29 |         case NSB: OpenNsb(Name); break;
 30 |         default: assert(false);
 31 |     }
 32 | }
 33 | 
 34 | void ScriptFile::OpenNss(const string& Name)
 35 | {
 36 |     uint32_t NssSize;
 37 |     char* NssData = fs::ReadFile(Name, NssSize);
 38 |     ReadNss(NssData, NssSize);
 39 |     delete[] NssData;
 40 | }
 41 | 
 42 | void ScriptFile::OpenNsb(string Name)
 43 | {
 44 |     string MapName = string(Name, 0, Name.size() - 3) + "map";
 45 |     uint32_t NsbSize, MapSize;
 46 |     char* NsbData = fs::ReadFile(Name, NsbSize);
 47 |     char* MapData = fs::ReadFile(MapName, MapSize);
 48 |     Buffer NsbBuffer(NsbData, NsbSize);
 49 |     Buffer MapBuffer(MapData, MapSize);
 50 |     ReadNsb(NsbBuffer, MapBuffer);
 51 | }
 52 | 
 53 | void ScriptFile::ReadNss(const char* NssData, uint32_t NssSize)
 54 | {
 55 |     Buffer NsbBuffer, MapBuffer;
 56 |     Nss::Compile(NssData, NssSize, &NsbBuffer, &MapBuffer);
 57 |     ReadNsb(NsbBuffer, MapBuffer);
 58 | }
 59 | 
 60 | void ScriptFile::ReadNsb(Npa::Buffer& NsbData, Npa::Buffer& MapData)
 61 | {
 62 |     uint32_t Entry;
 63 |     uint16_t NumParams;
 64 | 
 65 |     // Read source code lines
 66 |     while (!NsbData.EndOfBuffer())
 67 |     {
 68 |         Entry = NsbData.Read<uint32_t>() - 1; // Start counting at zero
 69 |         Source.resize(Source.size() + 1);
 70 |         Source[Entry].Magic = NsbData.Read<uint16_t>();
 71 |         NumParams = NsbData.Read<uint16_t>();
 72 |         Source[Entry].Params.reserve(NumParams);
 73 | 
 74 |         // Read parameters
 75 |         for (uint16_t i = 0; i < NumParams; ++i)
 76 |             Source[Entry].Params.push_back(NpaFile::ToUtf8(NsbData.ReadStr32()));
 77 |     }
 78 | 
 79 |     // Read symbols
 80 |     while (!MapData.EndOfBuffer())
 81 |     {
 82 |         NsbData.Read(&Entry, sizeof(uint32_t), MapData.Read<uint32_t>());
 83 |         string Label = NpaFile::ToUtf8(MapData.ReadStr16());
 84 |         if (Label.substr(0, 7) == "include")
 85 |             Includes.push_back(Label.substr(8));
 86 |         else
 87 |             Symbols[Label] = Entry - 1;
 88 |     }
 89 | }
 90 | 
 91 | uint32_t ScriptFile::GetSymbol(const string& Symbol)
 92 | {
 93 |     auto iter = Symbols.find(Symbol);
 94 |     if (iter != Symbols.end())
 95 |         return iter->second;
 96 |     return NSB_INVALIDE_LINE;
 97 | }
 98 | 
 99 | string Line::Stringify() const
100 | {
101 |     string String = Nsb::StringifyMagic(Magic) + string("(");
102 |     for (unsigned i = 0; i < Params.size(); ++i)
103 |     {
104 |         String += Params[i];
105 |         String += ((i == Params.size() - 1) ? "" : ", ");
106 |     }
107 |     return String + ");";
108 | }
109 | 


--------------------------------------------------------------------------------
/include/nsbconstants.hpp:
--------------------------------------------------------------------------------
  1 | #ifndef NSB_CONSTANTS_H
  2 | #define NSB_CONSTANTS_H
  3 | 
  4 | #include <string>
  5 | #include <cstdint>
  6 | #include <map>
  7 | #include <boost/bimap.hpp>
  8 | using namespace std;
  9 | 
 10 | namespace Nsb
 11 | {
 12 | 	namespace Constant
 13 | 	{
 14 | 		bool IsValidConstant(const string& String);
 15 | 	}
 16 | 
 17 |     enum PhoneMail
 18 |     {
 19 |         //...
 20 |     };
 21 | 
 22 |     enum ePhoneMode
 23 |     {
 24 |         PHONE_MODE_DEFAULT,
 25 |         PHONE_MODE_MAIL_MENU,
 26 |         PHONE_MODE_SEND_BOX,
 27 |         PHONE_MODE_RECEIVE_BOX,
 28 |         PHONE_MODE_SEND_MAIL,
 29 |         PHONE_MODE_RECEIVED_NEW_MAIL,
 30 |         PHONE_MODE_ADDRESS_BOOK,
 31 |         PHONE_MODE_ADDRESS_CONFIRM,
 32 |         PHONE_MODE_SENDING,
 33 |         PHONE_MODE_RINGING,
 34 |         PHONE_MODE_ENGAGE_NORMAL,
 35 |         PHONE_MODE_ENGAGE_VISUAL,
 36 |         PHONE_MODE_OPTION,
 37 |         PHONE_MODE_CHANGE_WALLPAPER,
 38 |         PHONE_MODE_CHANGE_RINGING_MELODY,
 39 |         PHONE_MODE_CHANGE_RECEIVEING_MELODY,
 40 |         PHONE_MODE_CHANGE_RINGING_VIBRATION,
 41 |         PHONE_MODE_CHANGE_RECEIVING_VIBRATION,
 42 |         PHONE_MODE_MAIL_SUB_MENU,
 43 |         PHONE_MODE_DEFAULT_OPERATABLE,
 44 |         PHONE_MODE_SEND_MAIL_EDIT,
 45 |         PHONE_MODE_DIALING_OPERATABLE,
 46 |         PHONE_MODE_COMPLETE_SEND_MAIL,
 47 |         PHONE_MODE_RECEIVING_MAIL,
 48 |         PHONE_MODE_COMPLETE_RECEIVE_MAIL,
 49 |         PHONE_MODE_END,
 50 |         PHONE_MODE_RECEIVED_MAIL,
 51 |         PHONE_MODE_CALLING,
 52 |         PHONE_MODE_DIALOG_SEND_MAIL_EDIT,
 53 |         PHONE_MODE_ADDRESS_CONFIRM_MAIL,
 54 |         PHONE_MODE_ADDRESS_CONFIRM_DIAL,
 55 |         PHONE_MODE_POWER_OFF,
 56 | 
 57 |         NUM_MODES
 58 |     };
 59 | 
 60 |     enum PhID
 61 |     {
 62 |         PHID_MAY,
 63 |         PHID_DAR,
 64 |         PHID_RUK,
 65 |         PHID_OVEN,
 66 |         PHID_MOE,
 67 |         PHID_JOHN,
 68 |         PHID_CRS_0,
 69 |         PHID_CRS,
 70 |         PHID_SUZ,
 71 |         PHID_FEI,
 72 |         PHID_MASTER,
 73 |         PHID_OKA,
 74 |         PHID_SUZ_0
 75 |     };
 76 | 
 77 |     enum Null
 78 |     {
 79 |         NSB_NULL = 0
 80 |     };
 81 | 
 82 |     enum Boolean
 83 |     {
 84 |         NSB_TRUE = 1,
 85 |         NSB_FALSE = 0
 86 |     };
 87 | 
 88 |     enum Request
 89 |     {
 90 |         STOP,
 91 |         PLAY,
 92 |         DISUSED,
 93 |         ADD_RENDER,
 94 |         LOCK,
 95 |         ERASE,
 96 |         UN_CLICKABLE,
 97 |         UN_LOCK,
 98 |         START,
 99 |         ENTER,
100 |         PASSIVE,
101 |         SMOOTHING,
102 |         NO_LOG,
103 |         PUSH_TEXT,
104 |         NO_ICON,
105 |         HIDEABLE,
106 |         PAUSE,
107 |         RESUME,
108 |         ENTRUST_SUSPEND,
109 |         COMPULSORY_SUSPEND,
110 |         SUB_RENDER,
111 |         FADE_ENTER,
112 |         INCREMENT,
113 |         DECREMENT,
114 |         NEXT,
115 |         PREV,
116 |         TYPING,
117 |         CLICKABLE,
118 |         MUL_RENDER,
119 |         OVERLAY_RENDER,
120 |         NORMAL_RENDER,
121 |         OPEN
122 |     };
123 | 
124 |     enum Tempo
125 |     {
126 |         AXL_1,
127 |         AXL_2,
128 |         AXL_3,
129 |         DXL_1,
130 |         DXL_2,
131 |         DXL_3,
132 |         AXL_DXL,
133 |         DXL_AXL,
134 |         AXL_AUTO,
135 |         DXL_AUTO
136 |     };
137 | 
138 |     enum Shade
139 |     {
140 |         EXTRALIGHT,
141 |         LIGHT,
142 |         MEDIUM,
143 |         SEMIHEAVY,
144 |         HEAVY,
145 |         EXTRAHEAVY,
146 |         NOMORE
147 |     };
148 | 
149 |     enum Color
150 |     {
151 |         BLACK = 0xFF000000,
152 |         WHITE = 0xFFFFFFFF,
153 |         BLUE = 0xFF0000FF,
154 |         RED = 0xFFFF0000,
155 |         GREEN = 0xFF00FF00
156 |     };
157 | 
158 |     enum Tone
159 |     {
160 |         NEGA_POSI,
161 |         MONOCHROME,
162 |         SEPIA,
163 |         KITANO_BLUE
164 |     };
165 | 
166 |     // TODO: investigate Lens, Drop, Plain
167 |     enum Effect
168 |     {
169 |         NEGA_POSI_E,
170 |         MONOCHROME_E,
171 |         SEPIA_E,
172 |         KITANO_BLUE_E,
173 |         RAIN
174 |     };
175 | 
176 |     template <class T>
177 |     struct ConstantHolder
178 |     {
179 |         static boost::bimap<string, int32_t> Constants;
180 |     };
181 | 
182 |     template <class T>
183 |     bool IsValidConstant(const string& String)
184 |     {
185 |         return ConstantHolder<T>::Constants.left.find(String) != ConstantHolder<T>::Constants.left.end();
186 |     }
187 | 
188 | 	// non template version
189 | 	bool IsValidConstant(const string& String);
190 | 
191 |     template <class T>
192 |     int32_t ConstantToValue(const string& String)
193 |     {
194 |         auto iter = ConstantHolder<T>::Constants.left.find(String);
195 |         if (iter != ConstantHolder<T>::Constants.left.end())
196 |             return iter->second;
197 |         return -1;
198 |     }
199 | 
200 |     template <class T>
201 |     string ValueToConstant(int32_t Value)
202 |     {
203 |         auto iter = ConstantHolder<T>::Constants.right.find(Value);
204 |         if (iter != ConstantHolder<T>::Constants.right.end())
205 |             return iter->second;
206 |         return "";
207 |     }
208 | }
209 | 
210 | #endif
211 | 


--------------------------------------------------------------------------------
/src/inipafile.cpp:
--------------------------------------------------------------------------------
  1 | #include "inipafile.hpp"
  2 | #include "fscommon.hpp"
  3 | #include "buffer.hpp"
  4 | #include <fstream>
  5 | #include <boost/algorithm/string/replace.hpp>
  6 | #include <zlib.h>
  7 | 
  8 | extern uint8_t NpaKeyTable[][0x100];
  9 | 
 10 | static const char* NipaGames[] =
 11 | {
 12 |     "ChaosHead",
 13 |     "ChaosHeadTR1",
 14 |     "ChaosHeadTR2",
 15 |     "MuramasaTR",
 16 |     "Muramasa",
 17 |     "Sumaga",
 18 |     "Django",
 19 |     "DjangoTR",
 20 |     "Lamento",
 21 |     "LamentoTR",
 22 |     "SweetPool",
 23 |     "SumagaSP",
 24 |     "Demonbane",
 25 |     "MuramasaAD",
 26 |     "Axanel",
 27 |     "Kikokugai",
 28 |     "SoniComiTR2",
 29 |     "Sumaga3P",
 30 |     "SoniComi",
 31 |     "LostX",
 32 |     "LostXTrailer",
 33 |     "DramaticalMurder",
 34 |     "Totono",
 35 |     nullptr
 36 | };
 37 | 
 38 | const char** INipaFile::GetGameStringList()
 39 | {
 40 |     return NipaGames;
 41 | }
 42 | 
 43 | uint8_t INipaFile::GameStringToID(const string& String)
 44 | {
 45 |     for (int i = 0; NipaGames[i]; ++i)
 46 |         if (String == NipaGames[i])
 47 |             return i;
 48 |     return -1;
 49 | }
 50 | 
 51 | INipaFile::INipaFile(const string& Name, uint8_t GameID) : INpaFile(Name), GameID(GameID)
 52 | {
 53 |     ReadHeader();
 54 | }
 55 | 
 56 | INipaFile::~INipaFile()
 57 | {
 58 | }
 59 | 
 60 | void INipaFile::ReadHeader()
 61 | {
 62 |     uint32_t Size;
 63 |     char* pData = fs::ReadFile(Name, Size);
 64 |     if (!pData)
 65 |         return;
 66 | 
 67 |     Npa::Buffer File(pData, Size);
 68 |     File.Read(NPAHeader.Magic, 7);
 69 |     assert(strncmp("NPA\x01\x00\x00\x00", NPAHeader.Magic, 7) == 0);
 70 | 
 71 |     NPAHeader.Key1 = File.Read<int32_t>();
 72 |     NPAHeader.Key2 = File.Read<int32_t>();
 73 |     NPAHeader.Compress = File.Read<uint8_t>();
 74 |     NPAHeader.Encrypt = File.Read<uint8_t>();
 75 |     NPAHeader.TotalCount = File.Read<uint32_t>();
 76 |     NPAHeader.FolderCount = File.Read<uint32_t>();
 77 |     NPAHeader.FileCount = File.Read<uint32_t>();
 78 |     NPAHeader.Unk = File.Read<uint64_t>();
 79 |     NPAHeader.Start = File.Read<uint32_t>();
 80 | 
 81 |     for (uint32_t i = 0; i < NPAHeader.TotalCount; ++i)
 82 |     {
 83 |         NipaEntry* NPAEntry = new NipaEntry;
 84 |         NPAEntry->Filename = File.ReadStr32();
 85 |         for (int x = 0; x < NPAEntry->Filename.size(); ++x)
 86 |             NPAEntry->Filename[x] += FilenameCrypt(x, i);
 87 | 
 88 |         NPAEntry->Type = File.Read<uint8_t>();
 89 |         NPAEntry->FileID = File.Read<uint32_t>();
 90 |         NPAEntry->Offset = File.Read<uint32_t>();
 91 |         NPAEntry->CompSize = File.Read<uint32_t>();
 92 |         NPAEntry->Size = File.Read<uint32_t>();
 93 | 
 94 |         string UtfPath = NpaFile::ToUtf8(NPAEntry->Filename);
 95 |         boost::replace_all(UtfPath, "\\", "/");
 96 |         Registry[UtfPath] = NPAEntry;
 97 |     }
 98 | }
 99 | 
100 | char INipaFile::FilenameCrypt(int32_t CharIndex, int32_t FileIndex)
101 | {
102 |     int32_t Key = 0xFC * CharIndex;
103 |     int32_t Temp = 0;
104 | 
105 |     if (NPAHeader.Encrypt && (GameID == LAMENTO || GameID == LAMENTOTR))
106 |         Temp = NPAHeader.Key1 + NPAHeader.Key2;
107 |     else
108 |         Temp = NPAHeader.Key1 * NPAHeader.Key2;
109 | 
110 |     Key -= Temp >> 0x18;
111 |     Key -= Temp >> 0x10;
112 |     Key -= Temp >> 0x08;
113 |     Key -= Temp & 0xff;
114 |     Key -= FileIndex >> 0x18;
115 |     Key -= FileIndex >> 0x10;
116 |     Key -= FileIndex >> 0x08;
117 |     Key -= FileIndex;
118 |     return Key & 0xff;
119 | }
120 | 
121 | char INipaFile::Crypt2(const char* Filename, int32_t origsize)
122 | {
123 |     int i = 0;
124 |     int key1 = 0; /* 2345678 hurr */
125 |     int key2 = NPAHeader.Key1 * NPAHeader.Key2;
126 | 
127 |     switch (GameID)
128 |     {
129 |         case AXANAEL:
130 |         case KIKOKUGAI:
131 |         case SONICOMITR2:
132 |         case SONICOMI:
133 |         case LOSTX:
134 |         case DRAMATICALMURDER:
135 |             key1 = 0x20101118;
136 |             break;
137 |         case TOTONO:
138 |             key1 = 0x12345678;
139 |             break;
140 |         default:
141 |             key1 = 0x87654321;
142 |             break;
143 |     }
144 | 
145 |     for (i = 0; Filename[i] != 0; ++i)
146 |         key1 -= Filename[i];
147 | 
148 |     int key = key1 * i;
149 |     if (GameID != LAMENTO && GameID != LAMENTOTR)
150 |     {
151 |         key += key2;
152 |         key *= origsize;
153 |     }
154 |     return key & 0xff;
155 | }
156 | 
157 | char* INipaFile::ReadFile(NpaIterator iter)
158 | {
159 |     return ReadData(iter, 0, ((NipaEntry*)iter->second)->CompSize);
160 | }
161 | 
162 | char* INipaFile::ReadData(NpaIterator iter, uint32_t LocalOffset, uint32_t Size, void *(*Alloc)(size_t))
163 | {
164 |     // Cannot offset into compressed file
165 |     if (LocalOffset != 0 && NPAHeader.Compress == 1)
166 |         return nullptr;
167 | 
168 |     ifstream File(Name, ios::binary);
169 |     if (!File)
170 |         return nullptr;
171 | 
172 |     NipaEntry* NPAEntry = (NipaEntry*)iter->second;
173 |     uint8_t* buffer = new uint8_t[Size];
174 | 
175 |     File.seekg(NPAEntry->Offset + LocalOffset + NPAHeader.Start + 0x29);
176 |     File.read((char*)buffer, Size);
177 | 
178 |     if (NPAHeader.Encrypt == 1)
179 |     {
180 |         int key = Crypt2(NPAEntry->Filename.c_str(), NPAEntry->Size);
181 |         int len = 0x1000;
182 | 
183 |         if (GameID != LAMENTO && GameID != LAMENTOTR)
184 |             len += NPAEntry->Filename.size();
185 | 
186 |         for (int x = LocalOffset; x < Size + LocalOffset && x < len + LocalOffset; ++x)
187 |         {
188 |             if (GameID == TOTONO)
189 |             {
190 |                 uint8_t r = buffer[x];
191 |                 char r2;
192 |                 r = NpaKeyTable[GameID][r];
193 |                 r = NpaKeyTable[GameID][r];
194 |                 r = NpaKeyTable[GameID][r];
195 |                 r = ~r;
196 |                 r2 = (char)r - key - x;
197 |                 buffer[x] = (uint8_t)r2;
198 |             }
199 |             else if (GameID == LAMENTO || GameID == LAMENTOTR)
200 |                 buffer[x] = NpaKeyTable[GameID][buffer[x]] - key;
201 |             else
202 |                 buffer[x] = (NpaKeyTable[GameID][buffer[x]] - key) - x;
203 |         }
204 |     }
205 | 
206 |     if (NPAHeader.Compress == 1)
207 |     {
208 |         char* zbuffer = new char[NPAEntry->Size];
209 |         uLongf sz = NPAEntry->Size;
210 |         assert(uncompress((Bytef*)zbuffer, &sz, buffer, NPAEntry->CompSize) == Z_OK);
211 |         delete[] buffer;
212 |         return zbuffer;
213 |     }
214 |     return (char*)buffer;
215 | }
216 | 
217 | bool INipaFile::IsDirectory(NpaIterator iter)
218 | {
219 |     return ((NipaEntry*)iter->second)->Type == 1;
220 | }
221 | 


--------------------------------------------------------------------------------
/src/nsscompiler.hpp:
--------------------------------------------------------------------------------
  1 | #ifndef NSS_COMPILER_HPP
  2 | #define NSS_COMPILER_HPP
  3 | 
  4 | #include <vector>
  5 | #include <cstdint>
  6 | #include <string>
  7 | #include "nsbmagic.hpp"
  8 | #include "npafile.hpp"
  9 | using namespace std;
 10 | 
 11 | class Statement;
 12 | class Expression;
 13 | class Subroutine;
 14 | class Argument;
 15 | typedef vector<Statement*> StatementList;
 16 | typedef vector<Expression*> ExpressionList;
 17 | typedef vector<Argument*> ArgumentList;
 18 | typedef vector<Subroutine*> SubroutineList;
 19 | 
 20 | enum ArgumentType
 21 | {
 22 |     ARG_INT = 0,
 23 |     ARG_STRING,
 24 |     ARG_FLOAT,
 25 |     ARG_VARIABLE,
 26 |     ARG_FUNCTION,
 27 |     ARG_ARRAY
 28 | };
 29 | 
 30 | struct Node
 31 | {
 32 |     virtual ~Node() {}
 33 |     void Compile(uint16_t Magic, uint16_t NumParams);
 34 | };
 35 | 
 36 | struct Statement : virtual Node
 37 | {
 38 |     virtual ~Statement() {}
 39 |     virtual void Compile() = 0;
 40 | };
 41 | 
 42 | struct Expression : virtual Node
 43 | {
 44 |     virtual ~Expression() {}
 45 |     virtual void Compile() = 0;
 46 |     virtual void CompileRaw();
 47 | };
 48 | 
 49 | struct Argument : Expression
 50 | {
 51 |     Argument() : Type(ARG_STRING) {}
 52 |     Argument(const string& Data, ArgumentType Type) : Data(NpaFile::FromUtf8(Data)), Type(Type) {}
 53 |     virtual ~Argument() {}
 54 |     void CompileRaw();
 55 |     virtual void Compile();
 56 | 
 57 |     string Data;
 58 |     ArgumentType Type; // Todo: CallArgument : Argument?
 59 | };
 60 | 
 61 | struct Array : Argument
 62 | {
 63 |     Array(const string& Data) : Argument("__array_variable__", ARG_ARRAY), ArrayData(Data) {}
 64 |     virtual ~Array() { for (auto i : Arguments) delete i; }
 65 |     virtual void Compile();
 66 | 
 67 |     string ArrayData;
 68 |     ArgumentList Arguments;
 69 | };
 70 | 
 71 | struct Call : Expression, Statement
 72 | {
 73 |     Call(Argument* Name, ExpressionList& Arguments, uint16_t Magic) : Name(Name), Arguments(Arguments), Magic(Magic) {}
 74 |     virtual ~Call() { for (auto i : Arguments) delete i; delete Name; }
 75 |     virtual void Compile();
 76 | 
 77 |     uint16_t Magic;
 78 |     Argument* Name;
 79 |     ExpressionList Arguments;
 80 | };
 81 | 
 82 | struct CallStatement : Call
 83 | {
 84 |     CallStatement(Argument* Name, ExpressionList& Arguments, uint16_t Magic) : Call(Name, Arguments, Magic) {}
 85 |     virtual void Compile();
 86 | };
 87 | 
 88 | struct Block : Statement
 89 | {
 90 |     Block() {}
 91 |     Block(StatementList& Statements) : Statements(Statements) {}
 92 |     virtual ~Block() { for (auto i : Statements) delete i; }
 93 |     virtual void Compile();
 94 | 
 95 |     StatementList Statements;
 96 | };
 97 | 
 98 | struct Condition : Statement
 99 | {
100 |     Condition(Block* ConditionBlock, Expression* Expr, uint16_t Magic) : ConditionBlock(ConditionBlock), Expr(Expr), Magic(Magic) {}
101 |     virtual ~Condition() { delete Expr; delete ConditionBlock; }
102 |     virtual void Compile() = 0;
103 |     void _Compile(Argument& EndSym);
104 | 
105 |     uint16_t Magic;
106 |     Expression* Expr;
107 |     Block* ConditionBlock;
108 | };
109 | 
110 | struct If : Condition
111 | {
112 |     If(Block* ConditionBlock, Expression* Expr) : Condition(ConditionBlock, Expr, MAGIC_IF), ElseIf(nullptr), ElseBlock(nullptr) {}
113 |     If(Block* ConditionBlock, Expression* Expr, Statement* ElseIf) : Condition(ConditionBlock, Expr, MAGIC_IF), ElseIf(ElseIf), ElseBlock(nullptr) {}
114 |     If(Block* ConditionBlock, Expression* Expr, Block* ElseBlock) : Condition(ConditionBlock, Expr, MAGIC_IF), ElseIf(nullptr), ElseBlock(ElseBlock) {}
115 | 
116 |     virtual void Compile();
117 |     Statement* ElseIf;
118 |     Block* ElseBlock;
119 | };
120 | 
121 | struct While : Condition
122 | {
123 |     While(Block* ConditionBlock, Expression* Expr) : Condition(ConditionBlock, Expr, MAGIC_WHILE) {}
124 |     virtual void Compile();
125 | };
126 | 
127 | struct Select : Statement
128 | {
129 |     Select(Block* SelectBlock) : SelectBlock(SelectBlock) {}
130 |     virtual ~Select() { delete SelectBlock; }
131 |     virtual void Compile();
132 | 
133 |     Block* SelectBlock;
134 | };
135 | 
136 | struct Case : Statement
137 | {
138 |     Case(const string& Name, Block* CaseBlock) : Name(NpaFile::FromUtf8(Name)), CaseBlock(CaseBlock) {}
139 |     virtual ~Case() { delete CaseBlock; }
140 |     virtual void Compile();
141 | 
142 |     string Name;
143 |     Block* CaseBlock;
144 | };
145 | 
146 | struct Subroutine : Node
147 | {
148 |     Subroutine(Argument* Name, Block* SubroutineBlock) : Name(Name), SubroutineBlock(SubroutineBlock) {}
149 |     virtual ~Subroutine() { delete SubroutineBlock; delete Name; }
150 |     void CompilePrototype(uint16_t BeginMagic, uint32_t NumBeginParams);
151 |     virtual void Compile();
152 |     void CompileReturn(uint16_t EndMagic);
153 | 
154 |     const uint16_t NumEndParams = 0;
155 |     Argument* Name;
156 |     Block* SubroutineBlock;
157 | };
158 | 
159 | struct Program
160 | {
161 |     virtual ~Program() { for (auto i : Subroutines) delete i; }
162 |     virtual void Compile();
163 | 
164 |     SubroutineList Subroutines;
165 | };
166 | 
167 | struct Function : Subroutine
168 | {
169 |     Function(Argument* Name, ArgumentList& Arguments, Block* Statements) : Subroutine(Name, Statements), Arguments(Arguments) {}
170 |     virtual ~Function() { for (auto i : Arguments) delete i; }
171 |     virtual void Compile();
172 | 
173 |     ArgumentList Arguments;
174 | };
175 | 
176 | struct Chapter : Subroutine
177 | {
178 |     Chapter(Argument* Name, Block* Statements) : Subroutine(Name, Statements) {}
179 |     virtual void Compile();
180 | };
181 | 
182 | struct Scene : Subroutine
183 | {
184 |     Scene(Argument* Name, Block* Statements) : Subroutine(Name, Statements) {}
185 |     virtual void Compile();
186 | };
187 | 
188 | struct Assignment : Statement
189 | {
190 |     Assignment(Argument* Name, Expression* Rhs, uint16_t Magic) : Name(Name), Rhs(Rhs), Magic(Magic) {}
191 |     virtual ~Assignment() { delete Name; delete Rhs; }
192 |     virtual void Compile();
193 | 
194 |     uint16_t Magic;
195 |     Argument* Name;
196 |     Expression* Rhs;
197 | };
198 | 
199 | struct BinaryOperator : Expression
200 | {
201 |     BinaryOperator(Expression* Lhs, uint16_t Op, Expression* Rhs) : Lhs(Lhs), Magic(Op), Rhs(Rhs) {}
202 |     virtual ~BinaryOperator() { delete Lhs; delete Rhs; }
203 |     virtual void Compile();
204 | 
205 |     uint16_t Magic;
206 |     Expression* Lhs;
207 |     Expression* Rhs;
208 | };
209 | 
210 | struct UnaryOperator : Expression
211 | {
212 |     UnaryOperator(uint16_t Op, Expression* Rhs) : Magic(Op), Rhs(Rhs) {}
213 |     virtual ~UnaryOperator() { delete Rhs; }
214 |     virtual void Compile();
215 | 
216 |     uint16_t Magic;
217 |     Expression* Rhs;
218 | };
219 | 
220 | struct UnaryStatement : UnaryOperator, Statement
221 | {
222 |     UnaryStatement(uint16_t Op, Expression* Rhs) : UnaryOperator(Op, Rhs) {}
223 |     virtual void Compile();
224 | };
225 | 
226 | struct Label : Statement
227 | {
228 |     Label(const string& Symbol) : Symbol(Symbol) { }
229 |     virtual void Compile();
230 | 
231 |     string Symbol;
232 | };
233 | 
234 | #endif
235 | 


--------------------------------------------------------------------------------
/src/nsscompiler.cpp:
--------------------------------------------------------------------------------
  1 | #include <cstring>
  2 | #include "nsscompiler.hpp"
  3 | #include "scriptfile.hpp"
  4 | #include "flex.hpp"
  5 | #include "parser.hpp"
  6 | #include "buffer.hpp"
  7 | using namespace Npa;
  8 | 
  9 | class Program;
 10 | extern Program* pRoot;
 11 | 
 12 | // TODO: if/while/select have separate counters
 13 | static uint32_t SymCounter;
 14 | static uint32_t Counter;
 15 | static Buffer* Output;
 16 | static Buffer* MapOutput;
 17 | 
 18 | const char* ArgumentTypes[] =
 19 | {
 20 |     "INT",
 21 |     "STRING",
 22 |     "FLOAT"
 23 | };
 24 | 
 25 | Call* MakeCall(string Name, uint16_t Magic)
 26 | {
 27 |     ExpressionList Args;
 28 |     Args.push_back(new Argument(Name, ARG_STRING));
 29 |     Argument* Arg = new Argument(Nsb::StringifyMagic(Magic), ARG_FUNCTION);
 30 |     return new Call(Arg, Args, Magic);
 31 | }
 32 | 
 33 | void WriteSymbol(const string& Symbol)
 34 | {
 35 |     MapOutput->Write<uint32_t>(Output->GetSize());
 36 |     MapOutput->WriteStr16(Symbol);
 37 | }
 38 | 
 39 | void Node::Compile(uint16_t Magic, uint16_t NumParams)
 40 | {
 41 |     Output->Write<uint32_t>(Counter);
 42 |     Output->Write<uint16_t>(Magic);
 43 |     Output->Write<uint16_t>(NumParams);
 44 |     ++Counter;
 45 | }
 46 | 
 47 | void Argument::Compile()
 48 | {
 49 |     if (Type == ARG_VARIABLE)
 50 |         Node::Compile(MAGIC_VARIABLE, 1);
 51 |     else
 52 |     {
 53 |         Node::Compile(MAGIC_LITERAL, 2);
 54 |         Output->WriteStr32(NpaFile::FromUtf8(ArgumentTypes[Type]));
 55 |     }
 56 |     CompileRaw();
 57 | }
 58 | 
 59 | void Argument::CompileRaw()
 60 | {
 61 |     Output->WriteStr32(Data);
 62 | }
 63 | 
 64 | void Array::Compile()
 65 | {
 66 |     for (auto i = Arguments.begin(); i != Arguments.end(); ++i)
 67 |         (*i)->Compile();
 68 | 
 69 |     Node::Compile(MAGIC_SUB_SCRIPT, 2);
 70 |     Argument Arg1(ArrayData, ARG_STRING);
 71 |     Arg1.CompileRaw();
 72 |     Argument Arg2(to_string(Arguments.size()), ARG_INT);
 73 |     Arg2.CompileRaw();
 74 | }
 75 | 
 76 | void Expression::CompileRaw()
 77 | {
 78 |     Output->WriteStr32("@");
 79 | }
 80 | 
 81 | void Call::Compile()
 82 | {
 83 |     uint16_t NumParams = Arguments.size();
 84 |     uint32_t BuiltinMagic = Nsb::MagicifyString(Name->Data.c_str());
 85 | 
 86 |     // Parameters
 87 |     if (BuiltinMagic != MAGIC_PARSE_TEXT &&
 88 |         BuiltinMagic != MAGIC_CALL_SCENE &&
 89 |         BuiltinMagic != MAGIC_CALL_CHAPTER)
 90 |         for (auto i = Arguments.begin(); i != Arguments.end(); ++i)
 91 |             (*i)->Compile();
 92 | 
 93 |     // Builtin function
 94 |     if (BuiltinMagic != 0)
 95 |         Node::Compile(BuiltinMagic, NumParams);
 96 |     // Script function
 97 |     else
 98 |     {
 99 |         NumParams += 1;
100 |         Node::Compile(Magic, NumParams);
101 |         Name->CompileRaw();
102 |     }
103 |     // Arguments
104 |     for (auto i = Arguments.begin(); i != Arguments.end(); ++i)
105 |         (*i)->CompileRaw();
106 | }
107 | 
108 | void CallStatement::Compile()
109 | {
110 |     Call::Compile();
111 |     Node::Compile(MAGIC_CLEAR_PARAMS, 0);
112 | }
113 | 
114 | void Block::Compile()
115 | {
116 |     Node::Compile(MAGIC_SCOPE_BEGIN, 0);
117 |     for (auto i = Statements.begin(); i != Statements.end(); ++i)
118 |         (*i)->Compile();
119 |     Node::Compile(MAGIC_SCOPE_END, 0);
120 | }
121 | 
122 | void Subroutine::CompilePrototype(uint16_t BeginMagic, uint32_t NumBeginParams)
123 | {
124 |     WriteSymbol(Name->Data);
125 |     Node::Compile(BeginMagic, NumBeginParams);
126 |     Name->CompileRaw();
127 | }
128 | 
129 | void Subroutine::Compile()
130 | {
131 |     SubroutineBlock->Compile();
132 | }
133 | 
134 | void Subroutine::CompileReturn(uint16_t EndMagic)
135 | {
136 |     Node::Compile(EndMagic, NumEndParams);
137 | }
138 | 
139 | void Program::Compile()
140 | {
141 |     for (auto i = Subroutines.begin(); i != Subroutines.end(); ++i)
142 |         (*i)->Compile();
143 | }
144 | 
145 | void Function::Compile()
146 | {
147 |     CompilePrototype(MAGIC_FUNCTION_DECLARATION, Arguments.size() + 1);
148 |     for (auto i = Arguments.begin(); i != Arguments.end(); ++i)
149 |         (*i)->CompileRaw();
150 |     Subroutine::Compile();
151 |     CompileReturn(MAGIC_END_FUNCTION);
152 | }
153 | 
154 | void Chapter::Compile()
155 | {
156 |     CompilePrototype(MAGIC_CHAPTER_DECLARATION, 1);
157 |     Subroutine::Compile();
158 |     CompileReturn(MAGIC_END_CHAPTER);
159 | }
160 | 
161 | void Scene::Compile()
162 | {
163 |     CompilePrototype(MAGIC_SCENE_DECLARATION, 1);
164 |     Subroutine::Compile();
165 |     CompileReturn(MAGIC_END_SCENE);
166 | }
167 | 
168 | void Assignment::Compile()
169 | {
170 |     if (Name->Type == ARG_ARRAY)
171 |         Name->Compile();
172 |     Rhs->Compile();
173 |     Node::Compile(Magic, 1);
174 |     Name->CompileRaw();
175 |     Node::Compile(MAGIC_CLEAR_PARAMS, 0);
176 | }
177 | 
178 | void BinaryOperator::Compile()
179 | {
180 |     Lhs->Compile();
181 |     Rhs->Compile();
182 |     Node::Compile(Magic, 0);
183 | }
184 | 
185 | void UnaryOperator::Compile()
186 | {
187 |     Rhs->Compile();
188 |     Node::Compile(Magic, 0);
189 | }
190 | 
191 | void UnaryStatement::Compile()
192 | {
193 |     UnaryOperator::Compile();
194 |     Node::Compile(MAGIC_CLEAR_PARAMS, 0);
195 | }
196 | 
197 | void Condition::_Compile(Argument& EndSym)
198 | {
199 |     Expr->Compile();
200 |     Node::Compile(Magic, 1);
201 |     EndSym.CompileRaw();
202 |     ConditionBlock->Compile();
203 | }
204 | 
205 | void If::Compile()
206 | {
207 |     Argument ElseSym("label.if." + to_string(SymCounter++), ARG_STRING);
208 |     Argument EndSym("label.if.end." + to_string(SymCounter++), ARG_STRING);
209 |     Condition::_Compile(ElseSym);
210 |     Node::Compile(MAGIC_JUMP, 1);
211 |     EndSym.CompileRaw();
212 |     WriteSymbol(ElseSym.Data);
213 |     if (ElseBlock) ElseBlock->Compile();
214 |     if (ElseIf) ElseIf->Compile();
215 |     WriteSymbol(EndSym.Data);
216 | }
217 | 
218 | void While::Compile()
219 | {
220 |     Argument BeginSym("label.while.begin." + to_string(SymCounter), ARG_STRING);
221 |     Argument EndSym("label.while.end." + to_string(SymCounter++), ARG_STRING);
222 |     WriteSymbol(BeginSym.Data);
223 |     Condition::_Compile(EndSym);
224 |     Node::Compile(MAGIC_WHILE_END, 0);
225 |     Node::Compile(MAGIC_JUMP, 1);
226 |     BeginSym.CompileRaw();
227 |     WriteSymbol(EndSym.Data);
228 | }
229 | 
230 | // ugly hack
231 | static Argument SelEndSym;
232 | 
233 | void Select::Compile()
234 | {
235 |     Argument BeginSym("label.select.begin." + to_string(SymCounter), ARG_STRING);
236 |     Argument EndSym("label.select.end." + to_string(SymCounter++), ARG_STRING);
237 |     Node::Compile(MAGIC_SELECT, 1);
238 |     EndSym.CompileRaw();
239 |     WriteSymbol(BeginSym.Data);
240 | 
241 |     // pass the end symbol down the tree to case
242 |     Argument Old = SelEndSym;
243 |     SelEndSym = EndSym;
244 |     SelectBlock->Compile();
245 |     SelEndSym = Old;
246 | 
247 |     Node::Compile(MAGIC_SELECT_END, 0);
248 |     Node::Compile(MAGIC_JUMP, 1);
249 |     BeginSym.CompileRaw();
250 |     WriteSymbol(EndSym.Data);
251 |     Node::Compile(MAGIC_SELECT_BREAK_END, 0);
252 | }
253 | 
254 | void Case::Compile()
255 | {
256 |     Argument Label(Name, ARG_STRING);
257 |     Argument StartSym("label.case.start." + to_string(SymCounter), ARG_STRING);
258 |     Argument EndSym("label.case.end." + to_string(SymCounter++), ARG_STRING);
259 |     Node::Compile(MAGIC_CASE, 3);
260 |     Label.CompileRaw();
261 |     EndSym.CompileRaw();
262 |     StartSym.CompileRaw();
263 |     WriteSymbol(StartSym.Data);
264 |     CaseBlock->Compile();
265 |     Node::Compile(MAGIC_CASE_END, 1);
266 |     Label.CompileRaw();
267 |     Node::Compile(MAGIC_JUMP, 1);
268 |     SelEndSym.CompileRaw();
269 |     WriteSymbol(EndSym.Data);
270 | }
271 | 
272 | void Label::Compile()
273 | {
274 |     // TODO
275 | }
276 | 
277 | namespace Nss
278 | {
279 | 
280 | void Compile(const char* pBuffer, uint32_t Length, Buffer* NsbBuffer, Buffer* MapBuffer)
281 | {
282 |     Counter = 1;
283 |     SymCounter = 1;
284 |     Output = NsbBuffer;
285 |     MapOutput = MapBuffer;
286 |     YY_BUFFER_STATE buffer = yy_scan_bytes(pBuffer, Length);
287 |     yyparse();
288 |     pRoot->Compile();
289 |     yy_delete_buffer(buffer);
290 |     delete pRoot;
291 | }
292 | 
293 | }
294 | 


--------------------------------------------------------------------------------
/src/parser.y:
--------------------------------------------------------------------------------
  1 | %{
  2 |     #include "nsscompiler.hpp"
  3 |     #include <cstdio>
  4 |     #include <cstdlib>
  5 |     #include <boost/algorithm/string/replace.hpp>
  6 | 
  7 |     Call* MakeCall(string Name, uint16_t Magic);
  8 |     void WriteSymbol(const string& Symbol);
  9 | 
 10 |     Program* pRoot;
 11 |     extern int yylex();
 12 |     void yyerror(const char* s) { std::printf("Error: %s\n", s); std::abort(); }
 13 | %}
 14 | 
 15 | %union
 16 | {
 17 |     Node* node;
 18 |     Program* program;
 19 |     Block* block;
 20 |     Statement* stmt;
 21 |     Argument* arg;
 22 |     Expression* expr;
 23 |     Subroutine* subr;
 24 |     std::vector<Argument*>* argvec;
 25 |     std::vector<Expression*>* expvec;
 26 |     std::string* string;
 27 |     int token;
 28 | }
 29 | 
 30 | %token <string> TIDENTIFIER TFLOAT TINTEGER TXML TSTRING THEX
 31 | %token <token> TLPAREN TRPAREN TLBRACE TRBRACE TFUNCTION TSEMICOLON TEQUAL TCOMMA TQUOTE TCHAPTER TSCENE TINCLUDE
 32 | %token <token> TADD TSUB TMUL TDIV TMOD TIF TWHILE TLESS TGREATER TEQUALEQUAL TNEQUAL TGEQUAL TLEQUAL TAND TOR TNOT
 33 | %token <token> TRETURN TCALLCHAPTER TCALLSCENE TELSE TSELECT TCASE TCOLON TAT TDOLLAR THASH TBREAK TLABRACE TRABRACE
 34 | 
 35 | %type <program> start
 36 | %type <arg> arg array
 37 | %type <argvec> func_args
 38 | %type <expvec> func_exps
 39 | %type <block> stmts block
 40 | %type <stmt> stmt call cond
 41 | %type <subr> func_decl
 42 | %type <expr> expr
 43 | 
 44 | %nonassoc TLESS TGREATER TEQUALEQUAL TNEQUAL TGEQUAL TLEQUAL
 45 | %left TOR
 46 | %left TAND
 47 | %left TADD TSUB
 48 | %left TMUL TDIV TMOD
 49 | %left UNARY
 50 | 
 51 | %start start
 52 | 
 53 | %%
 54 | 
 55 | start : { pRoot = new Program; } program { }
 56 |       ;
 57 | 
 58 | program : func_decl { pRoot->Subroutines.push_back($1); }
 59 |         | program func_decl { pRoot->Subroutines.push_back($2); }
 60 |         | include
 61 |         | program include
 62 |         ;
 63 | 
 64 | include : TINCLUDE TSTRING { WriteSymbol("include." + $2->substr(1, $2->size() - 2)); delete $2; }
 65 |         ;
 66 | 
 67 | stmts : stmt { $$ = new Block(); $$->Statements.push_back($<stmt>1); }
 68 |       | stmts stmt { $1->Statements.push_back($<stmt>2); }
 69 |       ;
 70 | 
 71 | stmt : call | cond
 72 |      | arg TEQUAL expr TSEMICOLON { $$ = new Assignment($1, $3, MAGIC_ASSIGN); }
 73 |      | arg TADD TEQUAL expr TSEMICOLON { $$ = new Assignment($1, $4, MAGIC_ADD_ASSIGN); }
 74 |      | arg TSUB TEQUAL expr TSEMICOLON { $$ = new Assignment($1, $4, MAGIC_SUB_ASSIGN); }
 75 |      | arg TMOD TEQUAL expr TSEMICOLON { $$ = new Assignment($1, $4, MAGIC_MOD_ASSIGN); }
 76 |      | arg TADD TADD TSEMICOLON { $$ = new UnaryStatement(MAGIC_INCREMENT, $1); }
 77 |      | arg TSUB TSUB TSEMICOLON { $$ = new UnaryStatement(MAGIC_DECREMENT, $1); }
 78 |      | TIDENTIFIER TCOLON { $$ = new Label(*$1); delete $1; }
 79 |      ;
 80 | 
 81 | block : TLBRACE stmts TRBRACE { $$ = $2; }
 82 |       | TLBRACE TRBRACE { $$ = new Block(); }
 83 |       ;
 84 | 
 85 | func_decl : TFUNCTION arg TLPAREN func_args TRPAREN block { $2->Data = string("function.") + $2->Data; $$ = new Function($2, *$4, $6); delete $4; }
 86 |           | TCHAPTER arg block { $2->Data = string("chapter.") + $2->Data; $$ = new Chapter($2, $3); }
 87 |           | TSCENE arg block { $2->Data = string("scene.") + $2->Data; $$ = new Scene($2, $3); }
 88 |           ;
 89 | 
 90 | func_args : { $$ = new ArgumentList(); }
 91 |           | arg { $$ = new ArgumentList(); $$->push_back($<arg>1); }
 92 |           | func_args TCOMMA arg { $1->push_back($<arg>3); }
 93 |           ;
 94 | 
 95 | func_exps : { $$ = new ExpressionList(); }
 96 |           | expr { $$ = new ExpressionList(); $$->push_back($<expr>1); }
 97 |           | func_exps TCOMMA expr { $1->push_back($<expr>3); }
 98 |           ;
 99 | 
100 | arg : TDOLLAR TIDENTIFIER { $$ = new Argument('$' + *$2, ARG_VARIABLE); delete $2; }
101 |       | THASH TIDENTIFIER { $$ = new Argument('#' + *$2, ARG_VARIABLE); delete $2; }
102 |       | THEX { $$ = new Argument(*$1, ARG_STRING); delete $1; }
103 |       | TIDENTIFIER { $$ = new Argument(*$1, ARG_STRING); delete $1; }
104 |       | TSTRING { std::string str = $1->substr(1, $1->size() - 2); boost::replace_all(str, "\\n", "\n"); $$ = new Argument(str, ARG_STRING); delete $1; }
105 |       | TINTEGER { $$ = new Argument(*$1, ARG_INT); delete $1; }
106 |       | TFLOAT { $$ = new Argument(*$1, ARG_FLOAT); delete $1; }
107 |       | array { $$ = $1; }
108 |       ;
109 | 
110 | array : TDOLLAR TIDENTIFIER TLABRACE arg TRABRACE { $$ = new Array('$' + *$2); ((Array*)$$)->Arguments.push_back($4); delete $2; }
111 |       | THASH TIDENTIFIER TLABRACE arg TRABRACE { $$ = new Array('#' + *$2); ((Array*)$$)->Arguments.push_back($4); delete $2; }
112 |       | array TLABRACE arg TRABRACE { $$ = $1; ((Array*)$$)->Arguments.push_back($3); }
113 | 
114 | call : arg TLPAREN func_exps TRPAREN TSEMICOLON { $$ = new CallStatement($1, *$3, MAGIC_CALL_FUNCTION); delete $3; }
115 |      | TRETURN TSEMICOLON
116 |           {
117 |                ExpressionList Args;
118 |                Argument* Arg = new Argument("Return", ARG_FUNCTION);
119 |                $$ = new Call(Arg, Args, 0);
120 |           }
121 |      | TBREAK TSEMICOLON
122 |           {
123 |                ExpressionList Args;
124 |                Argument* Arg = new Argument("Break", ARG_FUNCTION);
125 |                $$ = new Call(Arg, Args, 0);
126 |           }
127 |      | TXML {
128 |                size_t i = $1->find("<PRE ") + 5;
129 |                size_t j = $1->find(">", i);
130 |                size_t k = $1->find("[", j + 1) + 1;
131 |                size_t l = $1->find("]", k + 1);
132 |                ExpressionList Args;
133 |                Args.push_back(new Argument($1->substr(k, l - k), ARG_STRING));
134 |                Args.push_back(new Argument($1->substr(i, j - i), ARG_STRING));
135 |                Args.push_back(new Argument(*$1, ARG_STRING));
136 |                Argument* Arg = new Argument("ParseText", ARG_FUNCTION);
137 |                $$ = new Call(Arg, Args, 0);
138 |                delete $1;
139 |             }
140 |      | TCALLCHAPTER TIDENTIFIER TSEMICOLON { $$ = MakeCall(*$2, MAGIC_CALL_CHAPTER); delete $2; }
141 |      | TCALLCHAPTER TDOLLAR TIDENTIFIER TSEMICOLON { $$ = MakeCall('$' + *$3, MAGIC_CALL_CHAPTER); delete $3; }
142 |      | TCALLSCENE TIDENTIFIER TSEMICOLON { $$ = MakeCall(*$2, MAGIC_CALL_SCENE); delete $2; }
143 |      | TCALLSCENE TDOLLAR TIDENTIFIER TSEMICOLON { $$ = MakeCall('$' + *$3, MAGIC_CALL_SCENE); delete $3; }
144 |      ;
145 | 
146 | expr : arg { $<arg>$ = $1; }
147 |      | expr TMUL expr { $$ = new BinaryOperator($1, MAGIC_MUL_EXPRESSION, $3); }
148 |      | expr TDIV expr { $$ = new BinaryOperator($1, MAGIC_DIV_EXPRESSION, $3); }
149 |      | expr TMOD expr { $$ = new BinaryOperator($1, MAGIC_MOD_EXPRESSION, $3); }
150 |      | expr TADD expr { $$ = new BinaryOperator($1, MAGIC_ADD_EXPRESSION, $3); }
151 |      | expr TSUB expr { $$ = new BinaryOperator($1, MAGIC_SUB_EXPRESSION, $3); }
152 |      | expr TLESS expr { $$ = new BinaryOperator($1, MAGIC_CMP_LESS, $3); }
153 |      | expr TGREATER expr { $$ = new BinaryOperator($1, MAGIC_CMP_GREATER, $3); }
154 |      | expr TEQUALEQUAL expr { $$ = new BinaryOperator($1, MAGIC_CMP_EQUAL, $3); }
155 |      | expr TNEQUAL expr { $$ = new BinaryOperator($1, MAGIC_CMP_NE, $3); }
156 |      | expr TGEQUAL expr { $$ = new BinaryOperator($1, MAGIC_CMP_GE, $3); }
157 |      | expr TLEQUAL expr { $$ = new BinaryOperator($1, MAGIC_CMP_LE, $3); }
158 |      | expr TAND expr { $$ = new BinaryOperator($1, MAGIC_CMP_LOGICAL_AND, $3); }
159 |      | expr TOR expr { $$ = new BinaryOperator($1, MAGIC_CMP_LOGICAL_OR, $3); }
160 |      | TNOT expr %prec UNARY { $$ = new UnaryOperator(MAGIC_NOT_EXPRESSION, $2); }
161 |      | TSUB expr %prec UNARY { $$ = new UnaryOperator(MAGIC_NEGA_EXPRESSION, $2); }
162 |      | TAT expr %prec UNARY { $$ = new UnaryOperator(MAGIC_AT_EXPRESSION, $2); }
163 |      | arg TLPAREN func_exps TRPAREN { $$ = new Call($1, *$3, MAGIC_CALL_FUNCTION); delete $3; }
164 |      ;
165 | 
166 | cond : TIF TLPAREN expr TRPAREN block { $$ = new If($5, $3); }
167 |      | TIF TLPAREN expr TRPAREN block TELSE cond { $$ = new If($5, $3, $7); }
168 |      | TIF TLPAREN expr TRPAREN block TELSE block { $$ = new If($5, $3, $7); }
169 |      | TSELECT block { $$ = new Select($2); }
170 |      | TCASE TIDENTIFIER TCOLON block { $$ = new Case(*$2, $4); delete $2; }
171 |      | TWHILE TLPAREN expr TRPAREN block { $$ = new While($5, $3); }
172 |      ;
173 | 
174 | %%
175 | 


--------------------------------------------------------------------------------
/src/nsbmagic.cpp:
--------------------------------------------------------------------------------
  1 | #include "nsbmagic.hpp"
  2 | #include <boost/assign/list_of.hpp>
  3 | #include <boost/bimap.hpp>
  4 | 
  5 | typedef boost::bimap<uint16_t, std::string> LookupTable;
  6 | 
  7 | static const LookupTable MagicStrings = boost::assign::list_of<LookupTable::value_type>
  8 |     (MAGIC_FWN_UNK, "FUWANOVEL")
  9 | 
 10 |     (MAGIC_PARSE_TEXT, "ParseText")
 11 |     (MAGIC_LITERAL, "Literal")
 12 |     (MAGIC_CHAPTER_DECLARATION, "ChapterDeclaration")
 13 |     (MAGIC_IF, "If")
 14 |     (MAGIC_JUMP, "Jump")
 15 |     (MAGIC_CALL_FUNCTION, "CallFunction")
 16 |     (MAGIC_CMP_LOGICAL_AND, "CmpLogicalAnd")
 17 |     (MAGIC_CMP_LOGICAL_OR, "CmpLogicalOr")
 18 |     (MAGIC_SCOPE_BEGIN, "ScopeBegin")
 19 |     (MAGIC_SCOPE_END, "ScopeEnd")
 20 |     (MAGIC_MODULE_FILE_NAME, "ModuleFileName")
 21 |     (MAGIC_CLEAR_PARAMS, "ClearParams")
 22 |     (MAGIC_RESET, "Reset")
 23 |     (MAGIC_CMP_NE, "CmpNE")
 24 |     (MAGIC_ADD_EXPRESSION, "AddExpression")
 25 |     (MAGIC_ASSIGN, "Assign")
 26 |     (MAGIC_VARIABLE, "Variable")
 27 |     (MAGIC_END_CHAPTER, "EndChapter")
 28 |     (MAGIC_SCENE_DECLARATION, "SceneDeclaration")
 29 |     (MAGIC_CALL_SCENE, "CallScene")
 30 |     (MAGIC_END_SCENE, "EndScene")
 31 |     (MAGIC_MOVE, "Move")
 32 |     (MAGIC_REQUEST, "Request")
 33 |     (MAGIC_DELETE, "Delete")
 34 |     (MAGIC_FADE, "Fade")
 35 |     (MAGIC_WAIT, "Wait")
 36 |     (MAGIC_WAIT_KEY, "WaitKey")
 37 |     (MAGIC_AT_EXPRESSION, "AtExpression")
 38 |     (MAGIC_NEGA_EXPRESSION, "NegaExpression")
 39 |     (MAGIC_SET_VOLUME, "SetVolume")
 40 |     (MAGIC_SHAKE, "Shake")
 41 |     (MAGIC_SUB_SCRIPT, "SubScript")
 42 |     (MAGIC_UNK27, "UNK27")
 43 |     (MAGIC_CREATE_WINDOW, "CreateWindow")
 44 |     (MAGIC_SET_ALIAS, "SetAlias")
 45 |     (MAGIC_CREATE_MOVIE, "CreateMovie")
 46 |     (MAGIC_SET_VERTEX, "SetVertex")
 47 |     (MAGIC_SET_SHADE, "SetShade")
 48 |     (MAGIC_CREATE_RENDER_TEXTURE, "CreateRenderTexture")
 49 |     (MAGIC_DRAW_TO_TEXTURE, "DrawToTexture")
 50 |     (MAGIC_CMP_EQUAL, "CmpEqual")
 51 |     (MAGIC_FUNCTION_DECLARATION, "FunctionDeclaration")
 52 |     (MAGIC_END_FUNCTION, "EndFunction")
 53 |     (MAGIC_UNK38, "UNK38")
 54 |     (MAGIC_UNK39, "UNK39")
 55 |     (MAGIC_VARIABLE_VALUE, "VariableValue")
 56 |     (MAGIC_CREATE_TEXTURE, "CreateTexture")
 57 |     (MAGIC_IMAGE_HORIZON, "ImageHorizon")
 58 |     (MAGIC_DIV_EXPRESSION, "DivExpression")
 59 |     (MAGIC_MUL_EXPRESSION, "MulExpression")
 60 |     (MAGIC_NOT_EXPRESSION, "NotExpression")
 61 |     (MAGIC_WHILE, "While")
 62 |     (MAGIC_REMAIN_TIME, "RemainTime")
 63 |     (MAGIC_BREAK, "Break")
 64 |     (MAGIC_CMP_LE, "CmpLE")
 65 |     (MAGIC_CREATE_EFFECT, "CreateEffect")
 66 |     (MAGIC_CREATE_SURFACE, "CreateSurface")
 67 |     (MAGIC_SET_SURFACE, "SetSurface")
 68 |     (MAGIC_ALLOW_PHONE_CALL, "AllowPhoneCall")
 69 |     (MAGIC_INCREMENT, "Increment")
 70 |     (MAGIC_CMP_GREATER, "CmpGreater")
 71 |     (MAGIC_DRAW_TRANSITION, "DrawTransition")
 72 |     (MAGIC_CMP_GE, "CmpGE")
 73 |     (MAGIC_SUB_EXPRESSION, "SubExpression")
 74 |     (MAGIC_UNK59, "UNK59")
 75 |     (MAGIC_UNK60, "UNK60")
 76 |     (MAGIC_ADD_ASSIGN, "AddAssign")
 77 |     (MAGIC_UNK62, "UNK62")
 78 |     (MAGIC_SUB_ASSIGN, "SubAssign")
 79 |     (MAGIC_CMP_LESS, "CmpLess")
 80 |     (MAGIC_WHILE_END, "WhileEnd")
 81 |     (MAGIC_LOCK_VIDEO, "LockVideo")
 82 |     (MAGIC_LOAD_FONT, "LoadFont")
 83 |     (MAGIC_LOAD_IMAGE, "LoadImage")
 84 |     (MAGIC_ARRAY, "Array")
 85 |     (MAGIC_ASSOC_ARRAY, "AssocArray")
 86 |     (MAGIC_CREATE_CHOICE, "CreateChoice")
 87 |     (MAGIC_IMAGE_VERTICAL, "ImageVertical")
 88 |     (MAGIC_COUNT, "Count")
 89 |     (MAGIC_SET_FONT, "SetFont")
 90 |     (MAGIC_CREATE_TEXT, "CreateText")
 91 |     (MAGIC_CREATE_COLOR, "CreateColor")
 92 |     (MAGIC_CREATE_NAME, "CreateName")
 93 |     (MAGIC_CREATE_SCROLLBAR, "CreateScrollbar")
 94 |     (MAGIC_SET_SCROLL_SPEED, "SetScrollSpeed")
 95 |     (MAGIC_SET_SCROLLBAR_WHEEL_AREA, "SetScrollbarWheelArea")
 96 |     (MAGIC_MOD_EXPRESSION, "ModExpression")
 97 |     (MAGIC_INTEGER, "Integer")
 98 |     (MAGIC_STRING, "String")
 99 |     (MAGIC_SET_SCROLLBAR_VALUE, "SetScrollbarValue")
100 |     (MAGIC_SELECT, "Select")
101 |     (MAGIC_CALL_CHAPTER, "CallChapter")
102 |     (MAGIC_CASE, "Case")
103 |     (MAGIC_CASE_END, "CaseEnd")
104 |     (MAGIC_SELECT_END, "SelectEnd")
105 |     (MAGIC_SELECT_BREAK_END, "SelectBreakEnd")
106 |     (MAGIC_CURSOR_POSITION, "CursorPosition")
107 |     (MAGIC_MOVE_CURSOR, "MoveCursor")
108 |     (MAGIC_SCROLLBAR_VALUE, "ScrollbarValue")
109 |     (MAGIC_SET_ACHIEVEMENT, "SetAchievement")
110 |     (MAGIC_CREATE_PROCESS, "CreateProcess")
111 |     (MAGIC_ZOOM, "Zoom")
112 |     (MAGIC_TIME, "Time")
113 |     (MAGIC_SET_NEXT_FOCUS, "SetNextFocus")
114 |     (MAGIC_RETURN, "Return")
115 |     (MAGIC_UNK100, "UNK100")
116 |     (MAGIC_UNK101, "UNK101")
117 |     (MAGIC_SET_SHORTCUT, "SetShortcut")
118 |     (MAGIC_SAVE, "Save")
119 |     (MAGIC_DELETE_SAVE_FILE, "DeleteSaveFile")
120 |     (MAGIC_DURATION_TIME, "DurationTime")
121 |     (MAGIC_CLEAR_SCORE, "ClearScore")
122 |     (MAGIC_CLEAR_BACKLOG, "ClearBacklog")
123 |     (MAGIC_EXIST_SAVE, "ExistSave")
124 |     (MAGIC_WAIT_ACTION, "WaitAction")
125 |     (MAGIC_DECREMENT, "Decrement")
126 |     (MAGIC_MOVIE_PLAY, "MoviePlay")
127 |     (MAGIC_SET_STREAM, "SetStream")
128 |     (MAGIC_WAIT_PLAY, "WaitPlay")
129 |     (MAGIC_SYSTEM, "System")
130 |     (MAGIC_UNK115, "UNK115")
131 |     (MAGIC_UNK116, "UNK116")
132 |     (MAGIC_UNK117, "UNK117")
133 |     (MAGIC_WAIT_FINISH_ATTACH_CG_VIEW, "WaitFinishAttachCgView")
134 |     (MAGIC_UNK119, "UNK119")
135 |     (MAGIC_WAIT_FINISH_SEND_MAIL_EDIT, "WaitFinishSendMailEdit")
136 |     (MAGIC_WAIT_FINISH_MAIL_VIEW, "WaitFinishMailView")
137 |     (MAGIC_UNK122, "UNK122")
138 |     (MAGIC_UNK123, "UNK123")
139 |     (MAGIC_UNK124, "UNK124")
140 |     (MAGIC_UNK125, "UNK125")
141 |     (MAGIC_UNK126, "UNK126")
142 |     (MAGIC_UNK127, "UNK127")
143 |     (MAGIC_UNK128, "UNK128")
144 |     (MAGIC_UNK129, "UNK129")
145 |     (MAGIC_SEND_MAIL_EDIT, "SendMailEdit")
146 |     (MAGIC_RANDOM, "Random")
147 |     (MAGIC_UNK132, "UNK132")
148 |     (MAGIC_START_ATCH, "StartAtch")
149 |     (MAGIC_WAIT_ATCH, "WaitAtch")
150 |     (MAGIC_DELETE_ATCH, "DeleteAtch")
151 |     (MAGIC_UNK136, "UNK136")
152 |     (MAGIC_UNK137, "UNK137")
153 |     (MAGIC_UNK138, "UNK138")
154 |     (MAGIC_UNK139, "UNK139")
155 |     (MAGIC_UNK140, "UNK140")
156 |     (MAGIC_UNK141, "UNK141")
157 |     (MAGIC_UNK142, "UNK142")
158 |     (MAGIC_UNK143, "UNK143")
159 |     (MAGIC_UNK144, "UNK144")
160 |     (MAGIC_TIME_LEAP_INIT, "TimeLeapInit")
161 |     (MAGIC_UNK146, "UNK146")
162 |     (MAGIC_DISP_ATTACH_CG, "DispAttachCg")
163 |     (MAGIC_ERASE_ATTACH_CG, "EraseAttachCg")
164 |     (MAGIC_UNK149, "UNK149")
165 |     (MAGIC_UNK150, "UNK150")
166 |     (MAGIC_CREATE_CLIP_TEXTURE, "CreateClipTexture")
167 |     (MAGIC_CREATE_STENCIL, "CreateStencil")
168 |     (MAGIC_CREATE_MASK, "CreateMask")
169 |     (MAGIC_UNK154, "UNK154")
170 |     (MAGIC_CREATE_SOUND, "CreateSound")
171 |     (MAGIC_SET_LOOP_POINT, "SetLoopPoint")
172 |     (MAGIC_SET_FREQUENCY, "SetFrequency")
173 |     (MAGIC_SET_PAN, "SetPan")
174 |     (MAGIC_SET_LOOP, "SetLoop")
175 |     (MAGIC_UNK160, "UNK160")
176 |     (MAGIC_CONQUEST, "Conquest")
177 |     (MAGIC_STR_STR, "Strstr")
178 |     (MAGIC_SET_TEXTBOX_ATTRIBUTES, "SetTextboxAttributes")
179 |     (MAGIC_LOAD_TEXT, "LoadText")
180 |     (MAGIC_WAIT_TEXT, "WaitText")
181 |     (MAGIC_SET_BACKLOG, "SetBacklog")
182 |     (MAGIC_ESCAPE, "Escape")
183 |     (MAGIC_PASSAGE_TIME, "PassageTime")
184 |     (MAGIC_SET_COLOR, "SetColor")
185 |     (MAGIC_WAIT_FADE, "WaitFade")
186 |     (MAGIC_POSITION, "Position")
187 |     (MAGIC_SOUND_AMPLITUDE, "SoundAmplitude")
188 |     (MAGIC_READ_FILE, "ReadFile")
189 |     (MAGIC_DATE_TIME, "DateTime")
190 |     (MAGIC_WRITE_FILE, "WriteFile")
191 |     (MAGIC_LOAD, "Load")
192 |     (MAGIC_MESSAGE, "Message")
193 |     (MAGIC_UNK178, "UNK178")
194 |     (MAGIC_UNK179, "UNK179")
195 |     (MAGIC_UNK180, "UNK180")
196 |     (MAGIC_CREATE_BACKLOG, "CreateBacklog")
197 |     (MAGIC_SET_BACKLOG_SCROLLBAR, "SetBacklogScrollbar")
198 |     (MAGIC_UNK183, "UNK183")
199 |     (MAGIC_ENABLE_BACKLOG, "EnableBacklog")
200 |     (MAGIC_UNK185, "UNK185")
201 |     (MAGIC_EXIT, "Exit")
202 |     (MAGIC_UNK187, "UNK187")
203 |     (MAGIC_UNK188, "UNK188")
204 |     (MAGIC_ROTATE, "Rotate")
205 |     (MAGIC_SET_TONE, "SetTone")
206 |     (MAGIC_SET_PRIO, "SetPrio")
207 |     (MAGIC_UNK192, "UNK192")
208 |     (MAGIC_UNK193, "UNK193")
209 |     (MAGIC_UNK194, "UNK194")
210 |     (MAGIC_MOD_ASSIGN, "ModAssign");
211 | 
212 | 
213 | namespace Nsb
214 | {
215 |     bool IsValidMagic(uint16_t Magic)
216 |     {
217 |         return MagicStrings.left.find(Magic) != MagicStrings.left.end();
218 |     }
219 | 
220 |     const char* StringifyMagic(uint16_t Magic)
221 |     {
222 |         auto iter = MagicStrings.left.find(Magic);
223 |         if (iter != MagicStrings.left.end())
224 |             return iter->second.c_str();
225 |         return nullptr;
226 |     }
227 | 
228 |     uint16_t MagicifyString(const char* String)
229 |     {
230 |         auto iter = MagicStrings.right.find(String);
231 |         if (iter != MagicStrings.right.end())
232 |             return iter->second;
233 |         return 0;
234 |     }
235 | }
236 | 


--------------------------------------------------------------------------------
/include/nsbmagic.hpp:
--------------------------------------------------------------------------------
  1 | #ifndef NSB_MAGIC_HPP
  2 | #define NSB_MAGIC_HPP
  3 | 
  4 | #include <cstdint>
  5 | #define SWAP_UINT16(x) ((uint16_t)(((x) >> 8) | ((x) << 8)))
  6 | 
  7 | /*
  8 |  * SG - Steins;Gate
  9 |  * CH - Chaos;Head
 10 |  * FMDM - Full Metal Daemon: Muramasa
 11 |  * GCLX - Guilty Crown: Lost Christmas
 12 |  * */
 13 | enum /* Magic */ : uint16_t
 14 | {
 15 |     MAGIC_FWN_UNK = 0, // Fuwanovel eof extension?
 16 | 
 17 |     MAGIC_PARSE_TEXT = SWAP_UINT16(0xD800), // Intrinsic
 18 |     MAGIC_LITERAL = SWAP_UINT16(0xD000), // SG
 19 |     MAGIC_CHAPTER_DECLARATION = SWAP_UINT16(0x9400), // SG
 20 |     MAGIC_IF = SWAP_UINT16(0x9800), // SG
 21 |     MAGIC_JUMP = SWAP_UINT16(0xCF00), // SG
 22 |     MAGIC_CALL_FUNCTION = SWAP_UINT16(0xCE00), // SG
 23 |     MAGIC_CMP_LOGICAL_AND = SWAP_UINT16(0xC600), // SG
 24 |     MAGIC_CMP_LOGICAL_OR = SWAP_UINT16(0xC700), // SG
 25 |     MAGIC_SCOPE_BEGIN = SWAP_UINT16(0xC800), // Intrinsic
 26 |     MAGIC_SCOPE_END = SWAP_UINT16(0xC900), // Intrinsic
 27 |     MAGIC_MODULE_FILE_NAME = SWAP_UINT16(0x6800), // GCLX, FMDM, SG (GetModuleFileName)
 28 |     MAGIC_CLEAR_PARAMS = SWAP_UINT16(0x8E00), // Intrinsic
 29 |     MAGIC_RESET = SWAP_UINT16(0x5B00), // CH, SG
 30 |     MAGIC_CMP_NE = SWAP_UINT16(0xC100), // SG
 31 |     MAGIC_ADD_EXPRESSION = SWAP_UINT16(0xA500), // SG
 32 |     MAGIC_ASSIGN = SWAP_UINT16(0xB000), // SG
 33 |     MAGIC_VARIABLE = SWAP_UINT16(0xD100), // SG
 34 |     MAGIC_END_CHAPTER = SWAP_UINT16(0xD400), // SG
 35 |     MAGIC_SCENE_DECLARATION = SWAP_UINT16(0x9500), // SG
 36 |     MAGIC_CALL_SCENE = SWAP_UINT16(0xA300), // SG
 37 |     MAGIC_END_SCENE = SWAP_UINT16(0xD500), // SG
 38 |     MAGIC_MOVE = SWAP_UINT16(0x2000), // CH, SG
 39 |     MAGIC_REQUEST = SWAP_UINT16(0x2300), // CH, SG
 40 |     MAGIC_DELETE = SWAP_UINT16(0x2400), // CH, SG
 41 |     MAGIC_FADE = SWAP_UINT16(0x2500), // CH, SG
 42 |     MAGIC_WAIT = SWAP_UINT16(0x3900), // GCLX, FMDM, CH, SG
 43 |     MAGIC_WAIT_KEY = SWAP_UINT16(0x3A00), // GCLX, FMDM, CH, SG
 44 |     MAGIC_AT_EXPRESSION = SWAP_UINT16(0x9100), // SG
 45 |     MAGIC_NEGA_EXPRESSION = SWAP_UINT16(0xD200), // SG
 46 |     MAGIC_SET_VOLUME = SWAP_UINT16(0x4300), // CH
 47 |     MAGIC_SHAKE = SWAP_UINT16(0x2800), // CH
 48 |     MAGIC_SUB_SCRIPT = SWAP_UINT16(0xDE00), // SG
 49 |     MAGIC_UNK27 = SWAP_UINT16(0xE400), // phone related
 50 |     MAGIC_CREATE_WINDOW = SWAP_UINT16(0x1400), // CH
 51 |     MAGIC_SET_ALIAS = SWAP_UINT16(0x2B00), // CH, SG
 52 |     MAGIC_CREATE_MOVIE = SWAP_UINT16(0x1200), // CH
 53 |     MAGIC_SET_VERTEX = SWAP_UINT16(0x2C00), // CH, SG
 54 |     MAGIC_SET_SHADE = SWAP_UINT16(0x2D00), // GCLX, FMDM, CH, SG
 55 |     MAGIC_CREATE_RENDER_TEXTURE = SWAP_UINT16(0x1B00),
 56 |     MAGIC_DRAW_TO_TEXTURE = SWAP_UINT16(0x3000),
 57 |     MAGIC_CMP_EQUAL = SWAP_UINT16(0xC000), // SG
 58 |     MAGIC_FUNCTION_DECLARATION = SWAP_UINT16(0x9700), // SG
 59 |     MAGIC_END_FUNCTION = SWAP_UINT16(0xD700), // SG
 60 |     MAGIC_UNK38 = SWAP_UINT16(0x0401), // phone/message related
 61 |     MAGIC_UNK39 = SWAP_UINT16(0x0501), // phone/message related
 62 |     MAGIC_VARIABLE_VALUE = SWAP_UINT16(0x7500), // GCLX, FMDM, SG (GetVariableValue)
 63 |     MAGIC_CREATE_TEXTURE = SWAP_UINT16(0x0D00), // CH
 64 |     MAGIC_IMAGE_HORIZON = SWAP_UINT16(0x6100), // FMDM, CH, SG (GetImageHorizon)
 65 |     MAGIC_DIV_EXPRESSION = SWAP_UINT16(0xA800), // SG
 66 |     MAGIC_MUL_EXPRESSION = SWAP_UINT16(0xA700), // SG
 67 |     MAGIC_NOT_EXPRESSION = SWAP_UINT16(0xAC00), // SG
 68 |     MAGIC_WHILE = SWAP_UINT16(0x9900), // SG
 69 |     MAGIC_REMAIN_TIME = SWAP_UINT16(0x5E00), // GCLX, FMDM, CH, SG
 70 |     MAGIC_BREAK = SWAP_UINT16(0x9D00), // SG
 71 |     MAGIC_CMP_LE = SWAP_UINT16(0xC200), // SG
 72 |     MAGIC_CREATE_EFFECT = SWAP_UINT16(0x0B00), // GCLX, FMDM, CH, SG
 73 |     MAGIC_CREATE_SURFACE = SWAP_UINT16(0x0700), // GCLX, SG
 74 |     MAGIC_SET_SURFACE = SWAP_UINT16(0x2F00), // GCLX, SG
 75 |     MAGIC_ALLOW_PHONE_CALL = SWAP_UINT16(0xFC00),
 76 |     MAGIC_INCREMENT = SWAP_UINT16(0xBE00), // SG
 77 |     MAGIC_CMP_LESS = SWAP_UINT16(0xC400), // SG
 78 |     MAGIC_DRAW_TRANSITION = SWAP_UINT16(0x3800), // CH
 79 |     MAGIC_CMP_GE = SWAP_UINT16(0xC300), // SG
 80 |     MAGIC_SUB_EXPRESSION = SWAP_UINT16(0xA600), // SG
 81 |     MAGIC_UNK59 = SWAP_UINT16(0xEB00), // FM_From_DAR0203
 82 |     MAGIC_UNK60 = SWAP_UINT16(0xEA00),
 83 |     MAGIC_ADD_ASSIGN = SWAP_UINT16(0xB100), // SG
 84 |     MAGIC_UNK62 = SWAP_UINT16(0xFB00),
 85 |     MAGIC_SUB_ASSIGN = SWAP_UINT16(0xB200), // SG
 86 |     MAGIC_CMP_GREATER = SWAP_UINT16(0xC500), // SG
 87 |     MAGIC_WHILE_END = SWAP_UINT16(0xDF00), // SG
 88 |     MAGIC_LOCK_VIDEO = SWAP_UINT16(0x7A00), // FMDM, SG
 89 |     MAGIC_LOAD_FONT = SWAP_UINT16(0x1C00), // CH, SG
 90 |     MAGIC_LOAD_IMAGE = SWAP_UINT16(0x1900), // CH, SG
 91 |     MAGIC_ARRAY = SWAP_UINT16(0x7200), // FMDM, SG
 92 |     MAGIC_ASSOC_ARRAY = SWAP_UINT16(0x7300), // FMDM, SG
 93 |     MAGIC_CREATE_CHOICE = SWAP_UINT16(0x1600),
 94 |     MAGIC_IMAGE_VERTICAL = SWAP_UINT16(0x6200), // FMDM, CH, SG (GetImageVertical)
 95 |     MAGIC_COUNT = SWAP_UINT16(0x7400), // FMDM, SG
 96 |     MAGIC_SET_FONT = SWAP_UINT16(0x4E00), // CH, SG
 97 |     MAGIC_CREATE_TEXT = SWAP_UINT16(0x1300), // CH, SG
 98 |     MAGIC_CREATE_COLOR = SWAP_UINT16(0x0A00), // GCLX, FMDM, CH, SG
 99 |     MAGIC_CREATE_NAME = SWAP_UINT16(0x0800), // GCLX, FMDM, SG
100 |     MAGIC_CREATE_SCROLLBAR = SWAP_UINT16(0x1800), // CH
101 |     MAGIC_SET_SCROLL_SPEED = SWAP_UINT16(0x3500), // SG
102 |     MAGIC_SET_SCROLLBAR_WHEEL_AREA = SWAP_UINT16(0x1C01), // SG
103 |     MAGIC_MOD_EXPRESSION = SWAP_UINT16(0xA900), // SG
104 |     MAGIC_INTEGER = SWAP_UINT16(0x6E00), // CH, SG
105 |     MAGIC_STRING = SWAP_UINT16(0x6500), // GCLX, FMDM, CH, SG
106 |     MAGIC_SET_SCROLLBAR_VALUE = SWAP_UINT16(0x8A00), // SG
107 |     MAGIC_SELECT = SWAP_UINT16(0x9A00), // SG
108 |     MAGIC_CALL_CHAPTER = SWAP_UINT16(0xA200), // SG
109 |     MAGIC_CASE = SWAP_UINT16(0x9B00), // SG
110 |     MAGIC_CASE_END = SWAP_UINT16(0xDD00), // SG
111 |     MAGIC_SELECT_END = SWAP_UINT16(0xE000), // SG
112 |     MAGIC_SELECT_BREAK_END = SWAP_UINT16(0x0101), // SG
113 |     MAGIC_CURSOR_POSITION = SWAP_UINT16(0x5400), // GCLX, FMDM, SG (GetMousePosition)
114 |     MAGIC_MOVE_CURSOR = SWAP_UINT16(0x5500), // GCLX, FMDM, SG (SetMousePosition)
115 |     MAGIC_SCROLLBAR_VALUE = SWAP_UINT16(0x6B00), // CH, SG (GetScrollBarValue)
116 |     MAGIC_SET_ACHIEVEMENT = SWAP_UINT16(0x0001), // SG
117 |     MAGIC_CREATE_PROCESS = SWAP_UINT16(0x0900), // GCLX, FMDM, CH, SG
118 |     MAGIC_ZOOM = SWAP_UINT16(0x2600), // GCLX, FMDM, CH, SG
119 |     MAGIC_TIME = SWAP_UINT16(0x6C00), // CH, SG
120 |     MAGIC_SET_NEXT_FOCUS = SWAP_UINT16(0x3400), // SG
121 |     MAGIC_RETURN = SWAP_UINT16(0x9C00), // SG
122 |     MAGIC_UNK100 = SWAP_UINT16(0xF700), // AddressBookResetAll
123 |     MAGIC_UNK101 = SWAP_UINT16(0xF800), // AddressBookSet
124 |     MAGIC_SET_SHORTCUT = SWAP_UINT16(0x5800), // FMDM, SG
125 |     MAGIC_SAVE = SWAP_UINT16(0x4F00), // FMDM, CH, SG
126 |     MAGIC_DELETE_SAVE_FILE = SWAP_UINT16(0x5100), // FMDM, SG
127 |     MAGIC_DURATION_TIME = SWAP_UINT16(0x5F00), // GCLX, FMDM, CH, SG
128 |     MAGIC_CLEAR_SCORE = SWAP_UINT16(0x4C00), // CH, SG
129 |     MAGIC_CLEAR_BACKLOG = SWAP_UINT16(0x4A00), // CH, SG
130 |     MAGIC_EXIST_SAVE = SWAP_UINT16(0x5200), // CH
131 |     MAGIC_WAIT_ACTION = SWAP_UINT16(0x4000), // GCLX, FMDM, CH, SG
132 |     MAGIC_DECREMENT = SWAP_UINT16(0xBF00), // SG
133 |     MAGIC_MOVIE_PLAY = SWAP_UINT16(0x4B00), // FMDM, CH, SG
134 |     MAGIC_SET_STREAM = SWAP_UINT16(0x3200), // GCLX, FMDM, CH, SG
135 |     MAGIC_WAIT_PLAY = SWAP_UINT16(0x4100), // GCLX, FMDM, CH, SG
136 |     MAGIC_SYSTEM = SWAP_UINT16(0x5C00), // GCLX, FMDM, CH, SG
137 |     MAGIC_UNK115 = SWAP_UINT16(0x1801),
138 |     MAGIC_UNK116 = SWAP_UINT16(0xAA00), // some kind of binary operation?
139 |     MAGIC_UNK117 = SWAP_UINT16(0xE800),
140 |     MAGIC_WAIT_FINISH_ATTACH_CG_VIEW = SWAP_UINT16(0x1301), // SG
141 |     MAGIC_UNK119 = SWAP_UINT16(0x1D01), // Phone related, Highest value? 0x11D
142 |     MAGIC_WAIT_FINISH_SEND_MAIL_EDIT = SWAP_UINT16(0x1201), // SG
143 |     MAGIC_WAIT_FINISH_MAIL_VIEW = SWAP_UINT16(0x1101), // SG
144 |     MAGIC_UNK122 = SWAP_UINT16(0xF100),
145 |     MAGIC_UNK123 = SWAP_UINT16(0x1601), // GetMailBoxCursor
146 |     MAGIC_UNK124 = SWAP_UINT16(0xE500),
147 |     MAGIC_UNK125 = SWAP_UINT16(0xE600), // Phone related
148 |     MAGIC_UNK126 = SWAP_UINT16(0xF600), // Phone related
149 |     MAGIC_UNK127 = SWAP_UINT16(0xED00), // see UNK59
150 |     MAGIC_UNK128 = SWAP_UINT16(0xFA00), // Phone related
151 |     MAGIC_UNK129 = SWAP_UINT16(0x0F01), // Phone related
152 |     MAGIC_SEND_MAIL_EDIT = SWAP_UINT16(0xE700),
153 |     MAGIC_RANDOM = SWAP_UINT16(0x5D00), // GCLX, FMDM, CH, SG (GetRandom)
154 |     MAGIC_UNK132 = SWAP_UINT16(0xE900), // Phone related
155 |     MAGIC_START_ATCH = SWAP_UINT16(0x0C01), // SG
156 |     MAGIC_WAIT_ATCH = SWAP_UINT16(0x0D01), // SG
157 |     MAGIC_DELETE_ATCH = SWAP_UINT16(0x1701), // SG
158 |     MAGIC_UNK136 = SWAP_UINT16(0x0701),
159 |     MAGIC_UNK137 = SWAP_UINT16(0xF300),
160 |     MAGIC_UNK138 = SWAP_UINT16(0xF000),
161 |     MAGIC_UNK139 = SWAP_UINT16(0x1901),
162 |     MAGIC_UNK140 = SWAP_UINT16(0x1001),
163 |     MAGIC_UNK141 = SWAP_UINT16(0xF500),
164 |     MAGIC_UNK142 = SWAP_UINT16(0xEC00), // see UNK127
165 |     MAGIC_UNK143 = SWAP_UINT16(0xF900), // AddressBookReset
166 |     MAGIC_UNK144 = SWAP_UINT16(0x0A01), // Phone related
167 |     MAGIC_TIME_LEAP_INIT = SWAP_UINT16(0xFE00), // SG
168 |     MAGIC_UNK146 = SWAP_UINT16(0xAE00),
169 |     MAGIC_DISP_ATTACH_CG = SWAP_UINT16(0x1401), // SG
170 |     MAGIC_ERASE_ATTACH_CG = SWAP_UINT16(0x1501), // SG
171 |     MAGIC_UNK149 = SWAP_UINT16(0xB900),
172 |     MAGIC_UNK150 = SWAP_UINT16(0xAB00), // some kind of binary operation?
173 |     MAGIC_CREATE_CLIP_TEXTURE = SWAP_UINT16(0x0E00), // SG
174 |     MAGIC_CREATE_STENCIL = SWAP_UINT16(0x0600), // FMDM, SG
175 |     MAGIC_CREATE_MASK = SWAP_UINT16(0x0F00), // CH, SG
176 |     MAGIC_UNK154 = SWAP_UINT16(0x3100), // void SetBlur(Handle, unk, unk, unk, unk, unk)
177 |     MAGIC_CREATE_SOUND = SWAP_UINT16(0x1100), // CH
178 |     MAGIC_SET_LOOP_POINT = SWAP_UINT16(0x4700), // CH
179 |     MAGIC_SET_FREQUENCY = SWAP_UINT16(0x4500), // CH
180 |     MAGIC_SET_PAN = SWAP_UINT16(0x4400), // CH
181 |     MAGIC_SET_LOOP = SWAP_UINT16(0x4600), // CH
182 |     MAGIC_UNK160 = SWAP_UINT16(0x3700),
183 |     MAGIC_CONQUEST = SWAP_UINT16(0x7000), // FMDM, SG
184 |     MAGIC_STR_STR = SWAP_UINT16(0x6400), // SG
185 |     MAGIC_SET_TEXTBOX_ATTRIBUTES = SWAP_UINT16(0x0E01), // SetTextboxAttributes(STRING handle, INT unk, STRING font, INT unk, STRING color1, STRING color2, INT unk, STRING unk)
186 |     MAGIC_LOAD_TEXT = SWAP_UINT16(0x1D00), // GCLX, FMDM, CH, SG
187 |     MAGIC_WAIT_TEXT = SWAP_UINT16(0x4200), // FMDM, CH, SG
188 |     MAGIC_SET_BACKLOG = SWAP_UINT16(0x4900), // GCLX, FMDM, CH, SG
189 |     MAGIC_ESCAPE = SWAP_UINT16(0x5900), // GCLX, SG
190 |     MAGIC_PASSAGE_TIME = SWAP_UINT16(0x6000), // GCLX, FMDM, CH, SG
191 |     MAGIC_SET_COLOR = SWAP_UINT16(0x0300), // SG, GCLX
192 |     MAGIC_WAIT_FADE = SWAP_UINT16(0x3C00), // GCLX, FMDM, CH, SG
193 |     MAGIC_POSITION = SWAP_UINT16(0x5300), // GCLX, FMDM, SG (GetPosition)
194 |     MAGIC_SOUND_AMPLITUDE = SWAP_UINT16(0x6F00), // GCLX, CH, SG
195 |     MAGIC_READ_FILE = SWAP_UINT16(0x6700), // CH, SG
196 |     MAGIC_DATE_TIME = SWAP_UINT16(0x5600), // GCLX, FMDM, CH, SG
197 |     MAGIC_WRITE_FILE = SWAP_UINT16(0x5700), // GCLX, FMDM, CH, SG
198 |     MAGIC_LOAD = SWAP_UINT16(0x5000), // CH, SG
199 |     MAGIC_MESSAGE = SWAP_UINT16(0x7100), // GCLX, FMDM, SG (MessageBox)
200 |     MAGIC_UNK178 = SWAP_UINT16(0x3600),
201 |     MAGIC_UNK179 = SWAP_UINT16(0xF200),
202 |     MAGIC_UNK180 = SWAP_UINT16(0xEF00),
203 |     MAGIC_CREATE_BACKLOG = SWAP_UINT16(0x1700), // SG, CH
204 |     MAGIC_SET_BACKLOG_SCROLLBAR = SWAP_UINT16(0x4800), // SG
205 |     MAGIC_UNK183 = SWAP_UINT16(0xE300), // SetEnableBacklog? (takes a bool)
206 |     MAGIC_ENABLE_BACKLOG = SWAP_UINT16(0x6600), // SG, CH
207 |     MAGIC_UNK185 = SWAP_UINT16(0x1A01),
208 |     MAGIC_EXIT = SWAP_UINT16(0x5A00), // CH, SG
209 |     MAGIC_UNK187 = SWAP_UINT16(0xFF00), // UnlockTip (from function.TipsOn)
210 |     MAGIC_UNK188 = SWAP_UINT16(0xD900), // occurs before Jumps
211 |     MAGIC_ROTATE = SWAP_UINT16(0x2700), // GCLX, FMDM, CH, SG
212 |     MAGIC_SET_TONE = SWAP_UINT16(0x2E00), // GCLX, FMDM, CH, SG
213 |     MAGIC_SET_PRIO = SWAP_UINT16(0x0200), // SG
214 |     MAGIC_UNK192 = SWAP_UINT16(0x2E00),
215 |     MAGIC_UNK193 = SWAP_UINT16(0xB800),
216 |     MAGIC_UNK194 = SWAP_UINT16(0x3B00),
217 |     MAGIC_MOD_ASSIGN = SWAP_UINT16(0xB500) // SG
218 | };
219 | 
220 | namespace Nsb
221 | {
222 |     bool IsValidMagic(uint16_t Magic);
223 |     const char* StringifyMagic(uint16_t Magic);
224 |     uint16_t MagicifyString(const char* String);
225 | }
226 | 
227 | #endif
228 | 


--------------------------------------------------------------------------------
/src/nsbconstants.cpp:
--------------------------------------------------------------------------------
  1 | #include "nsbconstants.hpp"
  2 | #include <boost/assign/list_of.hpp>
  3 | 
  4 | typedef boost::bimap<string, int32_t> LookupTable;
  5 | 
  6 | namespace Nsb
  7 | {
  8 | 	bool IsValidConstant(const string& String)
  9 | 	{
 10 |         return Nsb::IsValidConstant<Nsb::PhoneMail>(String) ||
 11 |             Nsb::IsValidConstant<Nsb::ePhoneMode>(String) ||
 12 |             Nsb::IsValidConstant<Nsb::PhID>(String) ||
 13 |             Nsb::IsValidConstant<Nsb::Null>(String) ||
 14 |             Nsb::IsValidConstant<Nsb::Boolean>(String) ||
 15 |             Nsb::IsValidConstant<Nsb::Request>(String) ||
 16 |             Nsb::IsValidConstant<Nsb::Tempo>(String) ||
 17 |             Nsb::IsValidConstant<Nsb::Shade>(String) ||
 18 |             Nsb::IsValidConstant<Nsb::Color>(String) ||
 19 |             Nsb::IsValidConstant<Nsb::Effect>(String) ||
 20 |             Nsb::IsValidConstant<Nsb::Tone>(String);
 21 |     }
 22 | 
 23 |     template <> LookupTable ConstantHolder<PhoneMail>::Constants = boost::assign::list_of<LookupTable::value_type>
 24 |         ("FM_From_XXX0001", 0)
 25 |         ("FM_From_XXX0002", 1)
 26 |         ("FM_To_DAR0001_0", 2)
 27 |         ("FM_To_DAR0001_1", 3)
 28 |         ("FM_To_DAR0001_2", 4)
 29 |         ("FM_To_DAR0001_3", 5)
 30 |         ("FM_To_DAR0001_4", 6)
 31 |         ("FM_To_DAR0001_5", 7)
 32 |         ("FM_To_DAR0001", 8)
 33 |         ("FM_To_DAR0102", 9)
 34 |         ("FM_From_DAR0102", 10)
 35 |         ("FM_From_DAR0103", 11)
 36 |         ("FM_To_DAR0101", 12)
 37 |         ("FM_To_XXX0101", 13)
 38 |         ("FM_To_MAY0101", 14)
 39 |         ("FM_To_RUK101", 15)
 40 |         ("FM_To_FEI0101", 16)
 41 |         ("FM_To_MOE0101", 17)
 42 |         ("FM_From_MOE0101", 18)
 43 |         ("FM_To_MOE0102_0", 19)
 44 |         ("FM_To_MOE0102_1", 20)
 45 |         ("FM_To_MOE0102_2", 21)
 46 |         ("FM_To_MOE0102_3", 22)
 47 |         ("FM_To_MOE0102_4", 23)
 48 |         ("FM_To_MOE0102", 24)
 49 |         ("FM_From_MOE0102", 25)
 50 |         ("FM_From_DAR0203", 26)
 51 |         ("FM_From_DAR0202", 27)
 52 |         ("FM_From_MOE0201", 28)
 53 |         ("FM_From_MOE0202", 29)
 54 |         ("FM_From_MOE0203", 30)
 55 |         ("FM_From_MOE0204", 31)
 56 |         ("FM_From_MOE0205", 32)
 57 |         ("FM_From_MOE0206", 33)
 58 |         ("FM_From_MOE0207", 34)
 59 |         ("FM_From_MOE0208", 35)
 60 |         ("FM_To_TIT0201_0", 36)
 61 |         ("FM_To_TIT0201_1", 37)
 62 |         ("FM_To_TIT0201_2", 38)
 63 |         ("FM_To_TIT0201_3", 39)
 64 |         ("FM_To_TIT0201_4", 40)
 65 |         ("FM_To_TIT0201_5", 41)
 66 |         ("FM_To_TIT0201_6", 42)
 67 |         ("FM_To_TIT0201_7", 43)
 68 |         ("FM_To_TIT0201_8", 44)
 69 |         ("FM_To_TIT0201_9", 45)
 70 |         ("FM_To_TIT0201_10", 46)
 71 |         ("FM_To_TIT0201_11", 47)
 72 |         ("FM_To_TIT0201_12", 48)
 73 |         ("FM_To_TIT0201", 49)
 74 |         ("FM_From_TIT0201", 50)
 75 |         ("FM_To_TIT0202", 51)
 76 |         ("FM_From_TIT0202", 52)
 77 |         ("FM_From_MOE0210", 53)
 78 |         ("FM_To_MOE0201_0", 54)
 79 |         ("FM_To_MOE0201", 55)
 80 |         ("FM_From_MOE0209", 56)
 81 |         ("FM_From_MOE0211", 57)
 82 |         ("FM_To_MOE0202", 58)
 83 |         ("FM_From_MOE0212", 59)
 84 |         ("FM_From_MOE0213", 60)
 85 |         ("FM_To_MOE0203", 61)
 86 |         ("FM_From_MOE0214", 62)
 87 |         ("FM_To_MOE0204", 63)
 88 |         ("FM_From_MOE0215", 64)
 89 |         ("FM_From_MOE0216", 65)
 90 |         ("FM_From_MOE0217", 66)
 91 |         ("FM_From_MOE0218", 67)
 92 |         ("FM_From_MOE0219", 68)
 93 |         ("FM_To_MAY0201", 69)
 94 |         ("FM_From_MAY0201", 70)
 95 |         ("FM_From_MOE0220", 71)
 96 |         ("FM_From_MOE0223", 72)
 97 |         ("FM_To_MOE0205", 73)
 98 |         ("FM_From_MOE0221", 74)
 99 |         ("FM_From_MOE0224", 75)
100 |         ("FM_To_MOE0206", 76)
101 |         ("FM_From_MOE0222", 77)
102 |         ("FM_To_MOE0207_0", 78)
103 |         ("FM_To_MOE0207_1", 79)
104 |         ("FM_To_MOE0207", 80)
105 |         ("FM_To_MOE0208_0", 81)
106 |         ("FM_To_MOE0208_1", 82)
107 |         ("FM_To_MOE0208", 83)
108 |         ("FM_From_CRS0302", 84)
109 |         ("FM_From_CRS0301", 85)
110 |         ("FM_From_CRS0305", 86)
111 |         ("FM_From_CRS0304", 87)
112 |         ("FM_From_CRS0303", 88)
113 |         ("FM_From_CRS0307", 89)
114 |         ("FM_From_CRS0306", 90)
115 |         ("FM_From_CRS0310", 91)
116 |         ("FM_From_CRS0309", 92)
117 |         ("FM_From_CRS0308", 93)
118 |         ("FM_From_CRS0313", 94)
119 |         ("FM_From_CRS0312", 95)
120 |         ("FM_From_CRS0311", 96)
121 |         ("FM_From_CRS0316", 97)
122 |         ("FM_From_CRS0315", 98)
123 |         ("FM_From_CRS0314", 99)
124 |         ("FM_From_CRS0318", 100)
125 |         ("FM_From_CRS0317", 101)
126 |         ("FM_From_CRS0321", 102)
127 |         ("FM_From_CRS0320", 103)
128 |         ("FM_From_CRS0319", 104)
129 |         ("FM_From_CRS0324", 105)
130 |         ("FM_From_CRS0323", 106)
131 |         ("FM_From_CRS0322", 107)
132 |         ("FM_From_CRS0325", 108)
133 |         ("FM_From_CRS0327", 109)
134 |         ("FM_From_CRS0326", 110)
135 |         ("FM_From_CRS0328", 111)
136 |         ("FM_From_CRS0329", 112)
137 |         ("FM_From_CRS0331", 113)
138 |         ("FM_From_CRS0330", 114)
139 |         ("FM_From_CRS0332", 115)
140 |         ("FM_From_CRS0333", 116)
141 |         ("FM_From_MOE0301", 117)
142 |         ("FM_From_MOE0302", 118)
143 |         ("FM_From_MOE0303", 119)
144 |         ("FM_From_MOE0304", 120)
145 |         ("FM_From_MOE0305", 121)
146 |         ("FM_From_MOE0306", 122)
147 |         ("FM_From_MOE0307", 123)
148 |         ("FM_From_MOE0308", 124)
149 |         ("FM_From_MOE0309", 125)
150 |         ("FM_From_MOE0310", 126)
151 |         ("FM_From_MOE0311", 127)
152 |         ("FM_From_MOE0313", 128)
153 |         ("FM_From_MOE0312", 129)
154 |         ("FM_From_MOE0314", 130)
155 |         ("FM_From_MOE0315", 131)
156 |         ("FM_From_MOE0316", 132)
157 |         ("FM_From_MOE0317", 133)
158 |         ("FM_From_MAY0302", 134)
159 |         ("FM_From_MAY0301", 135)
160 |         ("FM_To_OKA0301", 136)
161 |         ("FM_From_OKA0303", 137)
162 |         ("FM_From_OKA0302", 138)
163 |         ("FM_From_OKA0301", 139)
164 |         ("FM_From_MOE0318", 140)
165 |         ("FM_From_MOE0319", 141)
166 |         ("FM_From_MOE0320", 142)
167 |         ("FM_From_MOE0321", 143)
168 |         ("FM_From_MOE0322", 144)
169 |         ("FM_From_MOE0323", 145)
170 |         ("FM_From_MOE0324", 146)
171 |         ("FM_From_MOE0325", 147)
172 |         ("FM_From_MOE0326", 148)
173 |         ("FM_From_MOE0327", 149)
174 |         ("FM_From_MOE0328", 150)
175 |         ("FM_From_MOE0329", 151)
176 |         ("FM_To_TIT0301_0", 152)
177 |         ("FM_To_TIT0301_1", 153)
178 |         ("FM_To_TIT0301_2", 154)
179 |         ("FM_To_TIT0301_3", 155)
180 |         ("FM_To_TIT0301_4", 156)
181 |         ("FM_To_TIT0301_5", 157)
182 |         ("FM_To_TIT0301_6", 158)
183 |         ("FM_To_TIT0301", 159)
184 |         ("FM_From_TIT0301", 160)
185 |         ("FM_To_TIT0302_0", 161)
186 |         ("FM_To_TIT0302_1", 162)
187 |         ("FM_To_TIT0302_2", 163)
188 |         ("FM_To_TIT0302_3", 164)
189 |         ("FM_To_TIT0302_4", 165)
190 |         ("FM_To_TIT0302_5", 166)
191 |         ("FM_To_TIT0302_6", 167)
192 |         ("FM_To_TIT0302", 168)
193 |         ("FM_From_TIT0302", 169)
194 |         ("FM_To_TIT0303_0", 170)
195 |         ("FM_To_TIT0303_1", 171)
196 |         ("FM_To_TIT0303_2", 172)
197 |         ("FM_To_TIT0303_3", 173)
198 |         ("FM_To_TIT0303_4", 174)
199 |         ("FM_To_TIT0303", 175)
200 |         ("FM_From_TIT0303", 176)
201 |         ("FM_To_TIT0304_0", 177)
202 |         ("FM_To_TIT0304_1", 178)
203 |         ("FM_To_TIT0304", 179)
204 |         ("FM_From_TIT0304", 180)
205 |         ("FM_From_TIT0305", 181)
206 |         ("FM_To_TIT0305_0", 182)
207 |         ("FM_To_TIT0305_1", 183)
208 |         ("FM_To_TIT0305", 184)
209 |         ("FM_From_TIT0306", 185)
210 |         ("FM_To_TIT0306_0", 186)
211 |         ("FM_To_TIT0306_1", 187)
212 |         ("FM_To_TIT0306", 188)
213 |         ("FM_From_TIT0307", 189)
214 |         ("FM_From_TIT0308", 190)
215 |         ("FM_From_MOE0401", 191)
216 |         ("FM_From_MOE0402", 192)
217 |         ("FM_From_MOE0403", 193)
218 |         ("FM_To_MOE0401", 194)
219 |         ("FM_From_MOE0404", 195)
220 |         ("FM_From_MOE0405", 196)
221 |         ("FM_From_MOE0406", 197)
222 |         ("FM_From_MOE0407", 198)
223 |         ("FM_From_MOE0408", 199)
224 |         ("FM_From_MOE0409", 200)
225 |         ("FM_To_MOE0403", 201)
226 |         ("FM_From_MOE0410", 202)
227 |         ("FM_To_CRS0401", 203)
228 |         ("FM_To_MOE0402", 204)
229 |         ("FM_From_MOE0411", 205)
230 |         ("FM_From_MOE0412", 206)
231 |         ("FM_From_XXX0401", 207)
232 |         ("FM_From_DAR0402", 208)
233 |         ("FM_From_SUZ0401", 209)
234 |         ("FM_From_SUZ0402", 210)
235 |         ("FM_To_OKA0401", 211)
236 |         ("FM_From_OKA0401", 212)
237 |         ("FM_To_OKA0402", 213)
238 |         ("FM_From_OKA0404", 214)
239 |         ("FM_From_OKA0403", 215)
240 |         ("FM_From_OKA0402", 216)
241 |         ("FM_From_DAR0401", 217)
242 |         ("FM_From_MAY0401", 218)
243 |         ("FM_To_TIT0501", 219)
244 |         ("FM_From_MOE0501", 220)
245 |         ("FM_From_MOE0502", 221)
246 |         ("FM_From_MOE0503", 222)
247 |         ("FM_From_MOE0504", 223)
248 |         ("FM_From_MOE0505", 224)
249 |         ("FM_From_XXX0501", 225)
250 |         ("FM_From_MOE0601", 226)
251 |         ("FM_To_MOE0601", 227)
252 |         ("FM_From_CRS0601", 228)
253 |         ("FM_To_CRS0601", 229)
254 |         ("FM_From_SUZ0601", 230)
255 |         ("FM_To_OKA0601_0", 231)
256 |         ("FM_To_OKA0601_1", 232)
257 |         ("FM_To_OKA0601_2", 233)
258 |         ("FM_To_OKA0601", 234)
259 |         ("FM_From_OKA0703", 235)
260 |         ("FM_From_OKA0702", 236)
261 |         ("FM_From_OKA0701", 237)
262 |         ("FM_To_FEI0701_0", 238)
263 |         ("FM_To_FEI0701_1", 239)
264 |         ("FM_To_FEI0701_2", 240)
265 |         ("FM_To_FEI0701_3", 241)
266 |         ("FM_To_FEI0701", 242)
267 |         ("FM_To_FEI0702", 243)
268 |         ("FM_To_FEI0703", 244)
269 |         ("FM_To_FEI0704", 245)
270 |         ("FM_To_DAR0701_0", 246)
271 |         ("FM_To_DAR0701_1", 247)
272 |         ("FM_To_DAR0701_2", 248)
273 |         ("FM_To_DAR0701_3", 249)
274 |         ("FM_To_DAR0701_4", 250)
275 |         ("FM_To_DAR0701_5", 251)
276 |         ("FM_To_DAR0701_6", 252)
277 |         ("FM_To_DAR0701", 253)
278 |         ("FM_To_FEI0705", 254)
279 |         ("FM_From_RUK0802", 255)
280 |         ("FM_From_RUK0801", 256)
281 |         ("FM_From_RUK0803", 257)
282 |         ("FM_To_RUK0801_0", 258)
283 |         ("FM_To_RUK0801", 259)
284 |         ("FM_To_MOE0901", 260)
285 |         ("FM_From_MAY0901", 261)
286 |         ("FM_From_CRS0901", 262)
287 |         ("FM_From_CRS0902", 263)
288 |         ("FM_To_XXX0901", 264)
289 |         ("FM_To_MOE0904_0", 265)
290 |         ("FM_To_MOE0904_1", 266)
291 |         ("FM_To_MOE0904", 267)
292 |         ("FM_To_MOE0905_0", 268)
293 |         ("FM_To_MOE0905_1", 269)
294 |         ("FM_To_MOE0905", 270)
295 |         ("FM_To_MOE0906_0", 271)
296 |         ("FM_To_MOE0906_1", 272)
297 |         ("FM_To_MOE0906", 273)
298 |         ("FM_To_MOE0907_0", 274)
299 |         ("FM_To_MOE0907_1", 275)
300 |         ("FM_To_MOE0907", 276)
301 |         ("FM_To_DAR0901", 277)
302 |         ("FM_From_DAR0901", 278)
303 |         ("FM_From_TEN0901", 279)
304 |         ("FM_To_MOE0902", 280)
305 |         ("FM_From_MOE0901", 281)
306 |         ("FM_From_MOE0902", 282)
307 |         ("FM_From_MOE0903", 283)
308 |         ("FM_To_MOE0903_0", 284)
309 |         ("FM_To_MOE0903_1", 285)
310 |         ("FM_To_MOE0903_2", 286)
311 |         ("FM_To_MOE0903", 287)
312 |         ("FM_From_MOE0904", 288)
313 |         ("FM_From_MOE0905", 289)
314 |         ("FM_From_MOE0906", 290)
315 |         ("FM_From_MAY1001", 291)
316 |         ("FM_To_MAY1001", 292)
317 |         ("FM_To_MAY1002", 293)
318 |         ("FM_To_DAR1001", 294)
319 |         ("FM_From_CRS1001", 295)
320 |         ("FM_From_XXX1101", 296)
321 |         ("FM_From_XXX1102", 297)
322 |         ("RM_From_CRS04_01_A", 298)
323 |         ("RM_Res_CRS04_01_A1", 299)
324 |         ("RM_Res_CRS04_01_A2", 300)
325 |         ("RM_Res_CRS04_01_A3", 301)
326 |         ("RM_From_CRS04_02_A", 302)
327 |         ("RM_Res_CRS04_02_A1", 303)
328 |         ("RM_Res_CRS04_02_A2", 304)
329 |         ("RM_From_CRS04_03_A", 305)
330 |         ("RM_From_CRS04_03_B", 306)
331 |         ("RM_Res_CRS04_03_A1", 307)
332 |         ("RM_From_CRS04_04_A", 308)
333 |         ("RM_From_CRS04_04_B", 309)
334 |         ("RM_From_CRS04_04_C", 310)
335 |         ("RM_Res_CRS04_04_A1", 311)
336 |         ("RM_Res_CRS04_04_A2", 312)
337 |         ("RM_Res_CRS04_04_B1", 313)
338 |         ("RM_Res_CRS04_04_B2", 314)
339 |         ("RM_Res_CRS04_04_C1", 315)
340 |         ("RM_Res_CRS04_04_C2", 316)
341 |         ("RM_From_CRS04_05_A", 317)
342 |         ("RM_From_CRS04_05_B", 318)
343 |         ("RM_Res_CRS04_05_A1", 319)
344 |         ("RM_Res_CRS04_05_B1", 320)
345 |         ("RM_From_CRS04_06_A", 321)
346 |         ("RM_From_CRS04_06_B", 322)
347 |         ("RM_From_CRS04_06_C", 323)
348 |         ("RM_From_CRS04_06_D", 324)
349 |         ("RM_From_CRS04_06_E", 325)
350 |         ("RM_Res_CRS04_06_A1", 326)
351 |         ("RM_Res_CRS04_06_A2", 327)
352 |         ("RM_Res_CRS04_06_B1", 328)
353 |         ("RM_Res_CRS04_06_C1", 329)
354 |         ("RM_Res_CRS04_06_E1", 330)
355 |         ("RM_Res_CRS04_06_E2", 331)
356 |         ("RM_From_CRS04_07_A", 332)
357 |         ("RM_From_CRS04_07_B", 333)
358 |         ("RM_Res_CRS04_07_B1", 334)
359 |         ("RM_From_CRS04_08_A", 335)
360 |         ("RM_From_CRS05_01_A", 336)
361 |         ("RM_Res_CRS05_01_A1", 337)
362 |         ("RM_Res_CRS05_01_A2", 338)
363 |         ("RM_From_CRS05_02_A", 339)
364 |         ("RM_From_CRS05_02_B", 340)
365 |         ("RM_From_CRS05_03_A", 341)
366 |         ("RM_From_CRS07_01_A", 342)
367 |         ("RM_Res_CRS07_01_A1", 343)
368 |         ("RM_Res_CRS07_01_A2", 344)
369 |         ("RM_From_CRS07_02_A", 345)
370 |         ("RM_From_CRS07_02_B", 346)
371 |         ("RM_Res_CRS07_02_A1", 347)
372 |         ("RM_Res_CRS07_02_A2", 348)
373 |         ("RM_Res_CRS07_02_A3", 349)
374 |         ("RM_Res_CRS07_02_A4", 350)
375 |         ("RM_Res_CRS07_02_B1", 351)
376 |         ("RM_Res_CRS07_02_B2", 352)
377 |         ("RM_Res_CRS07_02_B3", 353)
378 |         ("RM_From_CRS07_03_A", 354)
379 |         ("RM_From_CRS07_04_A", 355)
380 |         ("RM_From_CRS07_04_B", 356)
381 |         ("RM_From_CRS07_04_C", 357)
382 |         ("RM_From_CRS07_04_D", 358)
383 |         ("RM_From_CRS07_04_E", 359)
384 |         ("RM_From_CRS07_04_F", 360)
385 |         ("RM_Res_CRS07_04_A1", 361)
386 |         ("RM_Res_CRS07_04_A2", 362)
387 |         ("RM_Res_CRS07_04_A3", 363)
388 |         ("RM_Res_CRS07_04_C1", 364)
389 |         ("RM_Res_CRS07_04_C2", 365)
390 |         ("RM_Res_CRS07_04_E1", 366)
391 |         ("RM_Res_CRS07_04_E2", 367)
392 |         ("RM_Res_CRS07_04_F1", 368)
393 |         ("RM_Res_CRS07_04_F2", 369)
394 |         ("RM_From_CRS07_05_A", 370)
395 |         ("RM_From_CRS07_05_B", 371)
396 |         ("RM_From_CRS07_05_C", 372)
397 |         ("RM_From_CRS07_05_D", 373)
398 |         ("RM_From_CRS07_05_E", 374)
399 |         ("RM_From_CRS07_05_F", 375)
400 |         ("RM_From_CRS07_05_G", 376)
401 |         ("RM_From_CRS07_05_H", 377)
402 |         ("RM_From_CRS08_01_A", 378)
403 |         ("RM_Res_CRS08_01_A1", 379)
404 |         ("RM_From_CRS08_02_A", 380)
405 |         ("RM_From_CRS08_03_A", 381)
406 |         ("RM_From_CRS09_01_A", 382)
407 |         ("RM_Res_CRS09_01_A1", 383)
408 |         ("RM_Res_CRS09_01_A2", 384)
409 |         ("RM_From_CRS09_02_A", 385)
410 |         ("RM_From_CRS09_02_B", 386)
411 |         ("RM_From_CRS10_01_A", 387)
412 |         ("RM_Res_CRS10_01_A1", 388)
413 |         ("RM_From_MAY01_01_A", 389)
414 |         ("RM_Res_MAY01_01_A1", 390)
415 |         ("RM_Res_MAY01_01_A2", 391)
416 |         ("RM_From_MAY01_02_A", 392)
417 |         ("RM_From_MAY01_02_B", 393)
418 |         ("RM_Res_MAY01_02_A1", 394)
419 |         ("RM_Res_MAY01_02_A2", 395)
420 |         ("RM_Res_MAY01_02_B1", 396)
421 |         ("RM_Res_MAY01_02_B2", 397)
422 |         ("RM_From_MAY01_03_A", 398)
423 |         ("RM_From_MAY01_03_B", 399)
424 |         ("RM_From_MAY01_03_C", 400)
425 |         ("RM_From_MAY01_03_D", 401)
426 |         ("RM_From_MAY02_01_A", 402)
427 |         ("RM_Res_MAY02_01_A1", 403)
428 |         ("RM_Res_MAY02_01_A2", 404)
429 |         ("RM_From_MAY02_02_A", 405)
430 |         ("RM_From_MAY02_03_A", 406)
431 |         ("RM_From_MAY02_03_B", 407)
432 |         ("RM_Res_MAY02_03_A1", 408)
433 |         ("RM_Res_MAY02_03_A2", 409)
434 |         ("RM_Res_MAY02_03_B1", 410)
435 |         ("RM_From_MAY02_04_A", 411)
436 |         ("RM_From_MAY02_04_B", 412)
437 |         ("RM_From_MAY02_04_C", 413)
438 |         ("RM_Res_MAY02_04_B1", 414)
439 |         ("RM_Res_MAY02_04_C1", 415)
440 |         ("RM_From_MAY02_05_A", 416)
441 |         ("RM_From_MAY02_05_B", 417)
442 |         ("RM_Res_MAY02_05_B1", 418)
443 |         ("RM_From_MAY03_01_A", 419)
444 |         ("RM_Res_MAY03_01_A1", 420)
445 |         ("RM_Res_MAY03_01_A2", 421)
446 |         ("RM_Res_MAY03_01_A3", 422)
447 |         ("RM_From_MAY03_02_A", 423)
448 |         ("RM_From_MAY03_02_B", 424)
449 |         ("RM_From_MAY03_02_C", 425)
450 |         ("RM_From_MAY04_01_A", 426)
451 |         ("RM_Res_MAY04_01_A1", 427)
452 |         ("RM_Res_MAY04_01_A2", 428)
453 |         ("RM_Res_MAY04_01_A3", 429)
454 |         ("RM_From_MAY04_02_A", 430)
455 |         ("RM_From_MAY04_02_B", 431)
456 |         ("RM_From_MAY04_02_C", 432)
457 |         ("RM_Res_MAY04_02_A1", 433)
458 |         ("RM_Res_MAY04_02_B1", 434)
459 |         ("RM_Res_MAY04_02_B2", 435)
460 |         ("RM_Res_MAY04_02_C1", 436)
461 |         ("RM_Res_MAY04_02_C2", 437)
462 |         ("RM_From_MAY04_03_A", 438)
463 |         ("RM_From_MAY04_03_B", 439)
464 |         ("RM_From_MAY04_03_C", 440)
465 |         ("RM_From_MAY04_03_D", 441)
466 |         ("RM_Res_MAY04_03_A1", 442)
467 |         ("RM_From_MAY04_04_A", 443)
468 |         ("RM_From_MAY05_01_A", 444)
469 |         ("RM_Res_MAY05_01_A1", 445)
470 |         ("RM_Res_MAY05_01_A2", 446)
471 |         ("RM_From_MAY05_02_A", 447)
472 |         ("RM_From_MAY05_02_B", 448)
473 |         ("RM_From_MAY07_01_A", 449)
474 |         ("RM_Res_MAY07_01_A1", 450)
475 |         ("RM_Res_MAY07_01_A2", 451)
476 |         ("RM_From_MAY07_02_A", 452)
477 |         ("RM_From_MAY07_02_B", 453)
478 |         ("RM_From_MAY07_03_A", 454)
479 |         ("RM_Res_MAY07_03_A1", 455)
480 |         ("RM_Res_MAY07_03_A2", 456)
481 |         ("RM_Res_MAY07_03_A3", 457)
482 |         ("RM_From_MAY07_04_A", 458)
483 |         ("RM_From_MAY07_04_B", 459)
484 |         ("RM_From_MAY07_04_C", 460)
485 |         ("RM_From_MAY08_01_A", 461)
486 |         ("RM_Res_MAY08_01_A1", 462)
487 |         ("RM_Res_MAY08_01_A2", 463)
488 |         ("RM_Res_MAY08_01_A3", 464)
489 |         ("RM_From_MAY08_02_A", 465)
490 |         ("RM_From_MAY08_03_A", 466)
491 |         ("RM_From_MAY08_03_B", 467)
492 |         ("RM_From_MAY08_03_C", 468)
493 |         ("RM_From_MAY09_01_A", 469)
494 |         ("RM_Res_MAY09_01_A1", 470)
495 |         ("RM_From_MAY09_02_A", 471)
496 |         ("RM_Res_MAY09_02_A1", 472)
497 |         ("RM_From_MAY09_03_A", 473)
498 |         ("RM_From_RUK01_01_A", 474)
499 |         ("RM_Res_RUK01_01_A1", 475)
500 |         ("RM_Res_RUK01_01_A2", 476)
501 |         ("RM_Res_RUK01_01_A3", 477)
502 |         ("RM_From_RUK01_02_A", 478)
503 |         ("RM_From_RUK01_02_B", 479)
504 |         ("RM_From_RUK01_02_C", 480)
505 |         ("RM_Res_RUK01_02_A1", 481)
506 |         ("RM_Res_RUK01_02_C1", 482)
507 |         ("RM_From_RUK01_03_A", 483)
508 |         ("RM_From_RUK02_01_A", 484)
509 |         ("RM_Res_RUK02_01_A1", 485)
510 |         ("RM_Res_RUK02_01_A2", 486)
511 |         ("RM_Res_RUK02_01_A3", 487)
512 |         ("RM_From_RUK02_02_A", 488)
513 |         ("RM_From_RUK02_02_B", 489)
514 |         ("RM_From_RUK02_02_C", 490)
515 |         ("RM_Res_RUK02_02_A1", 491)
516 |         ("RM_Res_RUK02_02_A2", 492)
517 |         ("RM_Res_RUK02_02_B1", 493)
518 |         ("RM_Res_RUK02_02_B2", 494)
519 |         ("RM_Res_RUK02_02_C1", 495)
520 |         ("RM_Res_RUK02_02_C2", 496)
521 |         ("RM_From_RUK02_03_A", 497)
522 |         ("RM_From_RUK02_03_B", 498)
523 |         ("RM_From_RUK02_03_C", 499)
524 |         ("RM_From_RUK02_03_D", 500)
525 |         ("RM_From_RUK02_03_E", 501)
526 |         ("RM_Res_RUK02_03_C1", 502)
527 |         ("RM_Res_RUK02_03_C2", 503)
528 |         ("RM_From_RUK02_04_A", 504)
529 |         ("RM_From_RUK03_01_A", 505)
530 |         ("RM_Res_RUK03_01_A1", 506)
531 |         ("RM_Res_RUK03_01_A2", 507)
532 |         ("RM_Res_RUK03_01_A3", 508)
533 |         ("RM_From_RUK03_02_A", 509)
534 |         ("RM_From_RUK03_02_B", 510)
535 |         ("RM_From_RUK03_02_C", 511)
536 |         ("RM_Res_RUK03_02_B1", 512)
537 |         ("RM_Res_RUK03_02_B2", 513)
538 |         ("RM_Res_RUK03_02_B3", 514)
539 |         ("RM_From_RUK03_03_A", 515)
540 |         ("RM_From_RUK03_03_B", 516)
541 |         ("RM_From_RUK03_03_C", 517)
542 |         ("RM_Res_RUK03_03_C1", 518)
543 |         ("RM_From_RUK04_01_A", 519)
544 |         ("RM_Res_RUK04_01_A1", 520)
545 |         ("RM_Res_RUK04_01_A2", 521)
546 |         ("RM_From_RUK04_02_A", 522)
547 |         ("RM_From_RUK05_01_A", 523)
548 |         ("RM_Res_RUK05_01_A1", 524)
549 |         ("RM_Res_RUK05_01_A2", 525)
550 |         ("RM_From_RU05_02_A", 526)
551 |         ("RM_From_RU05_02_B", 527)
552 |         ("RM_From_SUZ02_01_A", 528)
553 |         ("RM_Res_SUZ02_01_A1", 529)
554 |         ("RM_Res_SUZ02_01_A2", 530)
555 |         ("RM_Res_SUZ02_01_A3", 531)
556 |         ("RM_From_SUZ02_02_A", 532)
557 |         ("RM_From_SUZ02_02_B", 533)
558 |         ("RM_From_SUZ02_02_C", 534)
559 |         ("RM_Res_SUZ02_02_A1", 535)
560 |         ("RM_Res_SUZ02_02_A2", 536)
561 |         ("RM_Res_SUZ02_02_C1", 537)
562 |         ("RM_Res_SUZ02_02_C2", 538)
563 |         ("RM_Res_SUZ02_02_C3", 539)
564 |         ("RM_From_SUZ02_03_A", 540)
565 |         ("RM_From_SUZ02_03_B", 541)
566 |         ("RM_From_SUZ02_03_C", 542)
567 |         ("RM_From_SUZ02_03_D", 543)
568 |         ("RM_From_SUZ02_03_E", 544)
569 |         ("RM_Res_SUZ02_03_B1", 545)
570 |         ("RM_From_SUZ03_01_A", 546)
571 |         ("RM_Res_SUZ03_01_A1", 547)
572 |         ("RM_Res_SUZ03_01_A2", 548)
573 |         ("RM_From_SUZ03_02_A", 549)
574 |         ("RM_From_SUZ03_02_B", 550)
575 |         ("RM_From_SUZ04_01_A", 551)
576 |         ("RM_Res_SUZ04_01_A1", 552)
577 |         ("RM_Res_SUZ04_01_A2", 553)
578 |         ("RM_Res_SUZ04_01_A3", 554)
579 |         ("RM_From_SUZ04_02_A", 555)
580 |         ("RM_From_SUZ04_02_B", 556)
581 |         ("RM_From_SUZ04_02_C", 557)
582 |         ("RM_Res_SUB04_02_A1", 558)
583 |         ("RM_Res_SUB04_02_A2", 559)
584 |         ("RM_Res_SUB04_02_A3", 560)
585 |         ("RM_Res_SUB04_02_B1", 561)
586 |         ("RM_Res_SUB04_02_B2", 562)
587 |         ("RM_Res_SUB04_02_B3", 563)
588 |         ("RM_Res_SUB04_02_C1", 564)
589 |         ("RM_From_SUZ04_03_A", 565)
590 |         ("RM_From_SUZ04_03_B", 566)
591 |         ("RM_From_SUZ04_03_C", 567)
592 |         ("RM_From_SUZ04_03_D", 568)
593 |         ("RM_From_SUZ04_03_E", 569)
594 |         ("RM_From_SUZ04_03_F", 570)
595 |         ("RM_From_SUZ04_03_G", 571)
596 |         ("RM_Res_SUZ04_03_A1", 572)
597 |         ("RM_Res_SUZ04_03_F1", 573)
598 |         ("RM_From_SUZ05_01_A", 574)
599 |         ("RM_Res_SUZ05_01_A1", 575)
600 |         ("RM_From_SUZ05_02_A", 576)
601 |         ("RM_From_FEI01_01_A", 577)
602 |         ("RM_Res_FEI01_01_A1", 578)
603 |         ("RM_Res_FEI01_01_A2", 579)
604 |         ("RM_Res_FEI01_01_A3", 580)
605 |         ("RM_From_FEI01_02_A", 581)
606 |         ("RM_From_FEI01_02_B", 582)
607 |         ("RM_From_FEI01_02_C", 583)
608 |         ("RM_From_FEI02_01_A", 584)
609 |         ("RM_Res_FEI02_01_A1", 585)
610 |         ("RM_Res_FEI02_01_A2", 586)
611 |         ("RM_Res_FEI02_01_A3", 587)
612 |         ("RM_Res_FEI02_01_A4", 588)
613 |         ("RM_From_FEI02_02_A", 589)
614 |         ("RM_From_FEI02_02_B", 590)
615 |         ("RM_From_FEI02_02_C", 591)
616 |         ("RM_From_FEI02_02_D", 592)
617 |         ("RM_From_FEI03_01_A", 593)
618 |         ("RM_Res_FEI03_01_A1", 594)
619 |         ("RM_Res_FEI03_01_A2", 595)
620 |         ("RM_Res_FEI03_01_A3", 596)
621 |         ("RM_From_FEI03_02A", 597)
622 |         ("RM_From_FEI03_02B", 598)
623 |         ("RM_From_FE03_02C", 599)
624 |         ("RM_Res_FEI03_02_A1", 600)
625 |         ("RM_Res_FEI03_02_A2", 601)
626 |         ("RM_Res_FEI03_02_A3", 602)
627 |         ("RM_Res_FEI03_02_B1", 603)
628 |         ("RM_Res_FEI03_02_B2", 604)
629 |         ("RM_Res_FEI03_02_C1", 605)
630 |         ("RM_Res_FEI03_02_C2", 606)
631 |         ("RM_Res_FEI03_02_C3", 607)
632 |         ("RM_From_FEI03_03_A", 608)
633 |         ("RM_From_FEI03_03_B", 609)
634 |         ("RM_From_FEI03_03_C", 610)
635 |         ("RM_From_FEI03_03_D", 611)
636 |         ("RM_From_FEI03_03_E", 612)
637 |         ("RM_From_FEI03_03_F", 613)
638 |         ("RM_From_FEI03_03_G", 614)
639 |         ("RM_From_FEI04_01_A", 615)
640 |         ("RM_Res_FEI04_01_A1", 616)
641 |         ("RM_Res_FEI04_01_A2", 617)
642 |         ("RM_From_FEI04_02_A", 618)
643 |         ("RM_From_FEI04_02_B", 619)
644 |         ("RM_Res_FEI04_02_A1", 620)
645 |         ("RM_Res_FEI04_02_A2", 621)
646 |         ("RM_Res_FEI04_02_A3", 622)
647 |         ("RM_Res_FEI04_02_B1", 623)
648 |         ("RM_From_FEI04_03_A", 624)
649 |         ("RM_From_FEI04_03_B", 625)
650 |         ("RM_From_FEI04_03_C", 626)
651 |         ("RM_Res_FEI04_03_C1", 627)
652 |         ("RM_From_FEI04_04_A", 628)
653 |         ("RM_From_FEI05_01_A", 629)
654 |         ("RM_Res_FEI05_01_A1", 630)
655 |         ("RM_Res_FEI05_01_A2", 631)
656 |         ("RM_Res_FEI05_01_A3", 632)
657 |         ("RM_From_FEI05_02_A", 633)
658 |         ("RM_From_FEI05_02_B", 634)
659 |         ("RM_From_FEI05_02_C", 635)
660 |         ("RM_Res_FEI05_02_B1", 636);
661 | 
662 |     template <> LookupTable ConstantHolder<ePhoneMode>::Constants = boost::assign::list_of<LookupTable::value_type>
663 |         ("PhoneMode_Default", PHONE_MODE_DEFAULT)
664 |         ("PhoneMode_MailMenu", PHONE_MODE_MAIL_MENU)
665 |         ("PhoneMode_SendBox", PHONE_MODE_SEND_BOX)
666 |         ("PhoneMode_ReceiveBox", PHONE_MODE_RECEIVE_BOX)
667 |         ("PhoneMode_SendMail", PHONE_MODE_SEND_MAIL)
668 |         ("PhoneMode_ReceivedNewMail", PHONE_MODE_RECEIVED_NEW_MAIL)
669 |         ("PhoneMode_AddressBook", PHONE_MODE_ADDRESS_BOOK)
670 |         ("PhoneMode_AddressConfirm", PHONE_MODE_ADDRESS_CONFIRM)
671 |         ("PhoneMode_Sending", PHONE_MODE_SENDING)
672 |         ("PhoneMode_Ringing", PHONE_MODE_RINGING)
673 |         ("PhoneMode_EngageNormal", PHONE_MODE_ENGAGE_NORMAL)
674 |         ("PhoneMode_EngageVisual", PHONE_MODE_ENGAGE_VISUAL)
675 |         ("PhoneMode_Option", PHONE_MODE_OPTION)
676 |         ("PhoneMode_ChangeWallPaper", PHONE_MODE_CHANGE_WALLPAPER)
677 |         ("PhoneMode_ChangeRingingMelody", PHONE_MODE_CHANGE_RINGING_MELODY)
678 |         ("PhoneMode_ChangeReceiveingMelody", PHONE_MODE_CHANGE_RECEIVEING_MELODY)
679 |         ("PhoneMode_ChangeRingingVibration", PHONE_MODE_CHANGE_RINGING_VIBRATION)
680 |         ("PhoneMode_ChangeReceivingVibration", PHONE_MODE_CHANGE_RECEIVING_VIBRATION)
681 |         ("PhoneMode_MailSubMenu", PHONE_MODE_MAIL_SUB_MENU)
682 |         ("PhoneMode_DefaultOperatable", PHONE_MODE_DEFAULT_OPERATABLE)
683 |         ("PhoneMode_SendMailEdit", PHONE_MODE_SEND_MAIL_EDIT)
684 |         ("PhoneMode_DialingOperatable", PHONE_MODE_DIALING_OPERATABLE)
685 |         ("PhoneMode_CompleteSendMail", PHONE_MODE_COMPLETE_SEND_MAIL)
686 |         ("PhoneMode_ReceivingMail", PHONE_MODE_RECEIVING_MAIL)
687 |         ("PhoneMode_CompleteReceiveMail", PHONE_MODE_COMPLETE_RECEIVE_MAIL)
688 |         ("PhoneMode_End", PHONE_MODE_END)
689 |         ("PhoneMode_ReceivedMail", PHONE_MODE_RECEIVED_MAIL)
690 |         ("PhoneMode_Calling", PHONE_MODE_CALLING)
691 |         ("PhoneMode_DialogSendMailEdit", PHONE_MODE_DIALOG_SEND_MAIL_EDIT)
692 |         ("PhoneMode_AddressConfirmMail", PHONE_MODE_ADDRESS_CONFIRM_MAIL)
693 |         ("PhoneMode_AddressConfirmDial", PHONE_MODE_ADDRESS_CONFIRM_DIAL)
694 |         ("PhoneMode_PowerOff", PHONE_MODE_POWER_OFF);
695 | 
696 |     template <> LookupTable ConstantHolder<PhID>::Constants = boost::assign::list_of<LookupTable::value_type>
697 |         ("PhID_MAY", PHID_MAY)
698 |         ("PhID_DAR", PHID_DAR)
699 |         ("PhID_RUK", PHID_RUK)
700 |         ("PhID_Oven", PHID_OVEN)
701 |         ("PhID_MOE", PHID_MOE)
702 |         ("PhID_John", PHID_JOHN)
703 |         ("PhID_CRS_0", PHID_CRS_0)
704 |         ("PhID_CRS", PHID_CRS)
705 |         ("PhID_SUZ", PHID_SUZ)
706 |         ("PhID_FEI", PHID_FEI)
707 |         ("PhID_Master", PHID_MASTER)
708 |         ("PhID_OKA", PHID_OKA)
709 |         ("PhID_SUZ_0", PHID_SUZ_0);
710 | 
711 |     template <> LookupTable ConstantHolder<Null>::Constants = boost::assign::list_of<LookupTable::value_type>
712 |         ("null", NSB_NULL);
713 | 
714 |     template <> LookupTable ConstantHolder<Boolean>::Constants = boost::assign::list_of<LookupTable::value_type>
715 |         ("true", NSB_TRUE)
716 |         ("false", NSB_FALSE);
717 | 
718 |     template <> LookupTable ConstantHolder<Request>::Constants = boost::assign::list_of<LookupTable::value_type>
719 |         ("Stop", STOP)
720 |         ("Play", PLAY)
721 |         ("Disused", DISUSED)
722 |         ("AddRender", ADD_RENDER)
723 |         ("Lock", LOCK)
724 |         ("Erase", ERASE)
725 |         ("UnClickable", UN_CLICKABLE)
726 |         ("UnLock", UN_LOCK)
727 |         ("Start", START)
728 |         ("Enter", ENTER)
729 |         ("Passive", PASSIVE)
730 |         ("Smoothing", SMOOTHING)
731 |         ("NoLog", NO_LOG)
732 |         ("PushText", PUSH_TEXT)
733 |         ("NoIcon", NO_ICON)
734 |         ("Hideable", HIDEABLE)
735 |         ("Pause", PAUSE)
736 |         ("Resume", RESUME)
737 |         ("EntrustSuspend", ENTRUST_SUSPEND)
738 |         ("CompulsorySuspend", COMPULSORY_SUSPEND)
739 |         ("SubRender", SUB_RENDER)
740 |         ("FadeEnter", FADE_ENTER)
741 |         ("Increment", INCREMENT)
742 |         ("Decrement", DECREMENT)
743 |         ("Next", NEXT)
744 |         ("Prev", PREV)
745 |         ("Typing", TYPING)
746 |         ("Clickable", CLICKABLE)
747 |         ("MulRender", MUL_RENDER)
748 |         ("OverlayRender", OVERLAY_RENDER)
749 |         ("NormalRender", NORMAL_RENDER)
750 |         ("Open", OPEN);
751 | 
752 |     template <> LookupTable ConstantHolder<Tempo>::Constants = boost::assign::list_of<LookupTable::value_type>
753 |         ("Axl1", AXL_1)
754 |         ("Axl2", AXL_2)
755 |         ("Axl3", AXL_3)
756 |         ("Dxl1", DXL_1)
757 |         ("Dxl2", DXL_2)
758 |         ("Dxl3", DXL_3)
759 |         ("AxlDxl", AXL_DXL)
760 |         ("DxlDxl", DXL_AXL)
761 |         ("AxlAuto", AXL_AUTO)
762 |         ("DxlAuto", DXL_AUTO);
763 | 
764 |     template <> LookupTable ConstantHolder<Shade>::Constants = boost::assign::list_of<LookupTable::value_type>
765 |         ("EXTRALIGHT", EXTRALIGHT)
766 |         ("LIGHT", LIGHT)
767 |         ("MEDIUM", MEDIUM)
768 |         ("SEMIHEAVY", SEMIHEAVY)
769 |         ("HEAVY", HEAVY)
770 |         ("EXTRAHEAVY", EXTRAHEAVY)
771 |         ("NOMORE", NOMORE);
772 | 
773 |     template <> LookupTable ConstantHolder<Color>::Constants = boost::assign::list_of<LookupTable::value_type>
774 |         ("black", BLACK)
775 |         ("white", WHITE)
776 |         ("blue", BLUE)
777 |         ("red", RED)
778 |         ("green", GREEN);
779 | 
780 |     template <> LookupTable ConstantHolder<Tone>::Constants = boost::assign::list_of<LookupTable::value_type>
781 |         ("NegaPosi", NEGA_POSI)
782 |         ("Monochrome", MONOCHROME)
783 |         ("Sepia", SEPIA)
784 |         ("KitanoBlue", KITANO_BLUE);
785 | 
786 |     template <> LookupTable ConstantHolder<Effect>::Constants = boost::assign::list_of<LookupTable::value_type>
787 |         ("NegaPosi", NEGA_POSI_E)
788 |         ("Monochrome", MONOCHROME_E)
789 |         ("Sepia", SEPIA_E)
790 |         ("KitanoBlue", KITANO_BLUE_E)
791 |         ("Rain", RAIN);
792 | }
793 | 


--------------------------------------------------------------------------------
/src/npakeys.cpp:
--------------------------------------------------------------------------------
  1 | #include <cstdint>
  2 | 
  3 | uint8_t NpaKeyTable[][0x100] =
  4 | {
  5 | 	/* Chaos;Head Retail */
  6 | 	0xF1, 0x71, 0x80, 0x19, 0x17, 0x01, 0x74, 0x7D, 0x90, 0x47, 0xF9, 0x68, 0xDE, 0xB4, 0x24, 0x40,
  7 | 	0x73, 0x9E, 0x5B, 0x38, 0x4C, 0x3A, 0x2A, 0x0D, 0x2E, 0xB9, 0x5C, 0xE9, 0xCE, 0xE8, 0x3E, 0x39,
  8 | 	0xA2, 0xF8, 0xA8, 0x5E, 0x1D, 0x1B, 0xD3, 0x23, 0xCB, 0x9B, 0xB0, 0xD5, 0x59, 0xF0, 0x3B, 0x09,
  9 | 	0x4D, 0xE4, 0x4A, 0x30, 0x7F, 0x89, 0x44, 0xA0, 0x7A, 0x3C, 0xEE, 0x0E, 0x66, 0xBF, 0xC9, 0x46,
 10 | 	0x77, 0x21, 0x86, 0x78, 0x6E, 0x8E, 0xE6, 0x99, 0x33, 0x2B, 0x0C, 0xEA, 0x42, 0x85, 0xD2, 0x8F,
 11 | 	0x5F, 0x94, 0xDA, 0xAC, 0x76, 0xB7, 0x51, 0xBA, 0x0B, 0xD4, 0x91, 0x28, 0x72, 0xAE, 0xE7, 0xD6,
 12 | 	0xBD, 0x53, 0xA3, 0x4F, 0x9D, 0xC5, 0xCC, 0x5D, 0x18, 0x96, 0x02, 0xA5, 0xC2, 0x63, 0xF4, 0x00,
 13 | 	0x6B, 0xEB, 0x79, 0x95, 0x83, 0xA7, 0x8C, 0x9A, 0xAB, 0x8A, 0x4E, 0xD7, 0xDB, 0xCA, 0x62, 0x27,
 14 | 	0x0A, 0xD1, 0xDD, 0x48, 0xC6, 0x88, 0xB6, 0xA9, 0x41, 0x10, 0xFE, 0x55, 0xE0, 0xD9, 0x06, 0x29,
 15 | 	0x65, 0x6A, 0xED, 0xE5, 0x98, 0x52, 0xFF, 0x8D, 0x43, 0xF6, 0xA4, 0xCF, 0xA6, 0xF2, 0x97, 0x13,
 16 | 	0x12, 0x04, 0xFD, 0x25, 0x81, 0x87, 0xEF, 0x2F, 0x6C, 0x84, 0x2C, 0xAA, 0xA1, 0xAF, 0x36, 0xCD,
 17 | 	0x92, 0x0F, 0x2D, 0x67, 0x45, 0xE2, 0x64, 0xB3, 0x20, 0x50, 0x4B, 0xF3, 0x7B, 0x1F, 0x1C, 0x03,
 18 | 	0xC4, 0xC1, 0x16, 0x61, 0x6F, 0xC7, 0xBE, 0x05, 0xAD, 0x22, 0x34, 0xB2, 0x54, 0x37, 0xF7, 0xD0,
 19 | 	0xFA, 0x60, 0x8B, 0x14, 0x08, 0xBC, 0xEC, 0xBB, 0x26, 0x9C, 0x57, 0x32, 0x5A, 0x3F, 0x35, 0x6D,
 20 | 	0xC8, 0xC3, 0x69, 0x7C, 0x31, 0x58, 0xE3, 0x75, 0xD8, 0xE1, 0xC0, 0x9F, 0x11, 0xB5, 0x93, 0x56,
 21 | 	0xF5, 0x1E, 0xB1, 0x1A, 0x70, 0x3D, 0xFB, 0x82, 0xDC, 0xDF, 0x7E, 0x07, 0x15, 0x49, 0xFC, 0xB8,
 22 | 
 23 | 	/* Chaos;Head Trial 1 */
 24 | 	0xE0, 0x60, 0x7F, 0x08, 0x06, 0xF0, 0x63, 0x6C, 0x8F, 0x36, 0xE8, 0x57, 0xCD, 0xA3, 0x13, 0x3F,
 25 | 	0x62, 0x8D, 0x4A, 0x27, 0x3B, 0x29, 0x19, 0xFC, 0x1D, 0xA8, 0x4B, 0xD8, 0xBD, 0xD7, 0xC1, 0x28,
 26 | 	0x91, 0xE7, 0x97, 0x4D, 0x0C, 0x0A, 0xC2, 0x12, 0xBA, 0x8A, 0xAF, 0xC4, 0x48, 0xEF, 0x2A, 0xF8,
 27 | 	0x3C, 0xD3, 0x39, 0x2F, 0x6E, 0x78, 0x33, 0x9F, 0x69, 0x2B, 0xDD, 0xFD, 0x55, 0xAE, 0xB8, 0x35,
 28 | 	0x66, 0x10, 0x75, 0x67, 0x5D, 0x7D, 0xD5, 0x88, 0x22, 0x1A, 0xFB, 0xD9, 0x31, 0x74, 0x2D, 0x7E,
 29 | 	0x4E, 0x83, 0xC9, 0x9B, 0x65, 0xA6, 0x40, 0xA9, 0xFA, 0xC3, 0x80, 0x17, 0x61, 0x9D, 0xD6, 0xC5,
 30 | 	0xAC, 0x42, 0x92, 0x3E, 0x8C, 0xB4, 0x53, 0x4C, 0x07, 0x85, 0xF1, 0x94, 0xB1, 0x52, 0xE3, 0xFF,
 31 | 	0x5A, 0xDA, 0x68, 0x84, 0x72, 0x96, 0x7B, 0x89, 0x9A, 0x79, 0x3D, 0xC6, 0xCA, 0xB9, 0x51, 0x16,
 32 | 	0xF9, 0xC0, 0xCC, 0x37, 0xB5, 0x77, 0xA5, 0x98, 0x30, 0x0F, 0xED, 0x44, 0xDF, 0xC8, 0xF5, 0x18,
 33 | 	0x54, 0x59, 0xDC, 0xD4, 0x87, 0x41, 0xEE, 0x7C, 0x32, 0xE5, 0x93, 0xBE, 0x95, 0xE1, 0x86, 0x02,
 34 | 	0x01, 0xF3, 0xEC, 0x14, 0x70, 0x76, 0xDE, 0x1E, 0x5B, 0x73, 0x1B, 0x99, 0x90, 0x9E, 0x25, 0xBC,
 35 | 	0x81, 0xFE, 0x1C, 0x56, 0x34, 0xD1, 0xBB, 0xA2, 0x1F, 0x4F, 0x3A, 0xE2, 0x6A, 0x0E, 0x0B, 0xF2,
 36 | 	0xB3, 0xB0, 0x05, 0x50, 0x5E, 0xB6, 0xAD, 0xF4, 0x9C, 0x11, 0x23, 0xA1, 0x43, 0x26, 0xE6, 0xCF,
 37 | 	0xE9, 0x5F, 0x7A, 0x03, 0xF7, 0xAB, 0xDB, 0xAA, 0x15, 0x8B, 0x46, 0x21, 0x49, 0x2E, 0x24, 0x5C,
 38 | 	0xB7, 0xB2, 0x58, 0x6B, 0x20, 0x47, 0xD2, 0x64, 0xC7, 0xD0, 0xBF, 0x8E, 0x00, 0xA4, 0x82, 0x45,
 39 | 	0xE4, 0x0D, 0xA0, 0x09, 0x6F, 0x2C, 0xEA, 0x71, 0xCB, 0xCE, 0x6D, 0xF6, 0x04, 0x38, 0xEB, 0xA7,
 40 | 
 41 | 	/* Chaos;Head Trial 2 */
 42 | 	0xF1, 0x21, 0x30, 0x69, 0x67, 0x51, 0x24, 0x2D, 0x40, 0x97, 0xF9, 0x18, 0xDE, 0xB4, 0x74, 0x90,
 43 | 	0x23, 0x4E, 0x0B, 0x88, 0x9C, 0x8A, 0x7A, 0x5D, 0x7E, 0xB9, 0x0C, 0xE9, 0xCE, 0xE8, 0x8E, 0x89,
 44 | 	0xA2, 0xF8, 0xA8, 0x0E, 0x6D, 0x6B, 0xD3, 0x73, 0xCB, 0x4B, 0xB0, 0xD5, 0x09, 0xF0, 0x8B, 0x59,
 45 | 	0x9D, 0xE4, 0x9A, 0x80, 0x2F, 0x39, 0x94, 0xA0, 0x2A, 0x8C, 0xEE, 0x5E, 0x16, 0xBF, 0xC9, 0x96,
 46 | 	0x27, 0x71, 0x36, 0x28, 0x1E, 0x3E, 0xE6, 0x49, 0x83, 0x7B, 0x5C, 0xEA, 0x92, 0x35, 0xD2, 0x3F,
 47 | 	0x0F, 0x44, 0xDA, 0xAC, 0x26, 0xB7, 0x01, 0xBA, 0x5B, 0xD4, 0x41, 0x78, 0x22, 0xAE, 0xE7, 0xD6,
 48 | 	0xBD, 0x03, 0xA3, 0x9F, 0x4D, 0xC5, 0xCC, 0x0D, 0x68, 0x46, 0x52, 0xA5, 0xC2, 0x13, 0xF4, 0x50,
 49 | 	0x1B, 0xEB, 0x29, 0x45, 0x33, 0xA7, 0x3C, 0x4A, 0xAB, 0x3A, 0x9E, 0xD7, 0xDB, 0xCA, 0x12, 0x77,
 50 | 	0x5A, 0xD1, 0xDD, 0x98, 0xC6, 0x38, 0xB6, 0xA9, 0x91, 0x60, 0xFE, 0x05, 0xE0, 0xD9, 0x56, 0x79,
 51 | 	0x15, 0x1A, 0xED, 0xE5, 0x48, 0x02, 0xFF, 0x3D, 0x93, 0xF6, 0xA4, 0xCF, 0xA6, 0xF2, 0x47, 0x63,
 52 | 	0x62, 0x54, 0xFD, 0x75, 0x31, 0x37, 0xEF, 0x7F, 0x1C, 0x34, 0x7C, 0xAA, 0xA1, 0xAF, 0x86, 0xCD,
 53 | 	0x42, 0x5F, 0x7D, 0x17, 0x95, 0xE2, 0x14, 0xB3, 0x70, 0x00, 0x9B, 0xF3, 0x2B, 0x6F, 0x6C, 0x53,
 54 | 	0xC4, 0xC1, 0x66, 0x11, 0x1F, 0xC7, 0xBE, 0x55, 0xAD, 0x72, 0x84, 0xB2, 0x04, 0x87, 0xF7, 0xD0,
 55 | 	0xFA, 0x10, 0x3B, 0x64, 0x58, 0xBC, 0xEC, 0xBB, 0x76, 0x4C, 0x07, 0x82, 0x0A, 0x8F, 0x85, 0x1D,
 56 | 	0xC8, 0xC3, 0x19, 0x2C, 0x81, 0x08, 0xE3, 0x25, 0xD8, 0xE1, 0xC0, 0x4F, 0x61, 0xB5, 0x43, 0x06,
 57 | 	0xF5, 0x6E, 0xB1, 0x6A, 0x20, 0x8D, 0xFB, 0x32, 0xDC, 0xDF, 0x2E, 0x57, 0x65, 0x99, 0xFC, 0xB8,
 58 | 
 59 | 	/* Muramasa Trial */
 60 | 	0xBF, 0x7F, 0x63, 0x11, 0x19, 0xCF, 0x76, 0x7C, 0x93, 0x49, 0xB1, 0x50, 0xFD, 0xD6, 0x06, 0x43,
 61 | 	0x75, 0x9D, 0x3A, 0x20, 0x4B, 0x22, 0x02, 0xCC, 0x0D, 0xD1, 0x3B, 0x81, 0xED, 0x80, 0x2D, 0x21,
 62 | 	0xA4, 0xB0, 0xA0, 0x3D, 0x1C, 0x1A, 0xF5, 0x05, 0xEA, 0x9A, 0xD3, 0xF7, 0x31, 0xB3, 0x2A, 0xC1,
 63 | 	0x4C, 0x86, 0x42, 0x23, 0x7E, 0x61, 0x46, 0xA3, 0x72, 0x2B, 0x8D, 0xCD, 0x58, 0xDE, 0xE1, 0x48,
 64 | 	0x79, 0x0F, 0x68, 0x70, 0x5D, 0x6D, 0x88, 0x91, 0x25, 0x0A, 0xCB, 0x82, 0x44, 0x67, 0xF4, 0x6E,
 65 | 	0x3E, 0x96, 0xF2, 0xAB, 0x78, 0xD9, 0x3F, 0xD2, 0xCA, 0xF6, 0x9F, 0x00, 0x74, 0xAD, 0x89, 0xF8,
 66 | 	0xDC, 0x35, 0xA5, 0x4E, 0x9C, 0xE7, 0xEB, 0x3C, 0x10, 0x98, 0xC4, 0xA7, 0xE4, 0x55, 0xB6, 0xC3,
 67 | 	0x5A, 0x8A, 0x71, 0x97, 0x65, 0xA9, 0x6B, 0x92, 0xAA, 0x62, 0x4D, 0xF9, 0xFA, 0xE2, 0x54, 0x09,
 68 | 	0xC2, 0xFF, 0xFC, 0x40, 0xE8, 0x60, 0xD8, 0xA1, 0x4F, 0x13, 0xBD, 0x37, 0x83, 0xF1, 0xC8, 0x01,
 69 | 	0x57, 0x52, 0x8C, 0x87, 0x90, 0x34, 0xBE, 0x6C, 0x45, 0xB8, 0xA6, 0xEE, 0xA8, 0xB4, 0x99, 0x15,
 70 | 	0x14, 0xC6, 0xBC, 0x07, 0x6F, 0x69, 0x8E, 0x0E, 0x5B, 0x66, 0x0B, 0xA2, 0xAF, 0xAE, 0x28, 0xEC,
 71 | 	0x94, 0xCE, 0x0C, 0x59, 0x47, 0x84, 0x56, 0xD5, 0x03, 0x33, 0x4A, 0xB5, 0x7A, 0x1E, 0x1B, 0xC5,
 72 | 	0xE6, 0xEF, 0x18, 0x5F, 0x5E, 0xE9, 0xDD, 0xC7, 0xAC, 0x04, 0x26, 0xD4, 0x36, 0x29, 0xB9, 0xF3,
 73 | 	0xB2, 0x53, 0x6A, 0x16, 0xC0, 0xDB, 0x8B, 0xDA, 0x08, 0x9B, 0x39, 0x24, 0x32, 0x2E, 0x27, 0x5C,
 74 | 	0xE0, 0xE5, 0x51, 0x7B, 0x2F, 0x30, 0x85, 0x77, 0xF0, 0x8F, 0xE3, 0x9E, 0x1F, 0xD7, 0x95, 0x38,
 75 | 	0xB7, 0x1D, 0xDF, 0x12, 0x73, 0x2C, 0xBA, 0x64, 0xFB, 0xFE, 0x7D, 0xC9, 0x17, 0x41, 0xBB, 0xD0,
 76 | 
 77 | 	/* Muramasa Retail */
 78 | 	0x48, 0xE8, 0xD3, 0x11, 0x1D, 0x58, 0xEA, 0xE5, 0x23, 0xBD, 0x41, 0xC0, 0x86, 0x6A, 0x0A, 0xB3,
 79 | 	0xE9, 0x26, 0xAE, 0x90, 0xBF, 0x92, 0x02, 0x55, 0x06, 0x61, 0xAF, 0xF1, 0x76, 0xF0, 0x96, 0x91,
 80 | 	0x34, 0x40, 0x30, 0xA6, 0x15, 0x1E, 0x89, 0x09, 0x7E, 0x2E, 0x63, 0x8B, 0xA1, 0x43, 0x9E, 0x51,
 81 | 	0xB5, 0xFA, 0xB2, 0x93, 0xE7, 0xD1, 0xBA, 0x33, 0xE2, 0x9F, 0xF6, 0x56, 0xCC, 0x67, 0x71, 0xBC,
 82 | 	0xED, 0x08, 0xDC, 0xE0, 0xC6, 0xD6, 0xFC, 0x21, 0x99, 0x0E, 0x5F, 0xF2, 0xB4, 0xDB, 0x84, 0xD7,
 83 | 	0xA7, 0x2A, 0x82, 0x3F, 0xEC, 0x6D, 0xA8, 0x62, 0x5E, 0x8A, 0x28, 0x00, 0xE4, 0x36, 0xFD, 0x8C,
 84 | 	0x65, 0xA9, 0x39, 0xB7, 0x25, 0x7B, 0x7F, 0xA5, 0x10, 0x2C, 0x54, 0x3B, 0x74, 0xC9, 0x4A, 0x53,
 85 | 	0xCE, 0xFE, 0xE1, 0x2B, 0xD9, 0x3D, 0xDF, 0x22, 0x3E, 0xD2, 0xB6, 0x8D, 0x8E, 0x72, 0xC4, 0x0D,
 86 | 	0x52, 0x88, 0x85, 0xB0, 0x7C, 0xD0, 0x6C, 0x31, 0xB8, 0x13, 0x46, 0xAB, 0xF3, 0x81, 0x5C, 0x01,
 87 | 	0xCB, 0xC2, 0xF5, 0xFB, 0x20, 0xA4, 0x47, 0xD5, 0xB9, 0x4C, 0x3A, 0x77, 0x3C, 0x44, 0x2D, 0x19,
 88 | 	0x14, 0x5A, 0x45, 0x0B, 0xD8, 0xDD, 0xF7, 0x07, 0xCF, 0xDA, 0x0F, 0x32, 0x38, 0x37, 0x9C, 0x75,
 89 | 	0x24, 0x57, 0x05, 0xCD, 0xBB, 0xF4, 0xCA, 0x69, 0x03, 0xA3, 0xBE, 0x49, 0xEE, 0x17, 0x1F, 0x59,
 90 | 	0x7A, 0x78, 0x1C, 0xC8, 0xC7, 0x7D, 0x66, 0x5B, 0x35, 0x04, 0x9A, 0x64, 0xAA, 0x9D, 0x4D, 0x83,
 91 | 	0x42, 0xC3, 0xDE, 0x1A, 0x50, 0x6F, 0xFF, 0x6E, 0x0C, 0x2F, 0xAD, 0x94, 0xA2, 0x97, 0x9B, 0xC5,
 92 | 	0x70, 0x79, 0xC1, 0xEF, 0x98, 0xA0, 0xF9, 0xEB, 0x80, 0xF8, 0x73, 0x27, 0x18, 0x6B, 0x29, 0xAC,
 93 | 	0x4B, 0x16, 0x68, 0x12, 0xE3, 0x95, 0x4E, 0xD4, 0x8F, 0x87, 0xE6, 0x5D, 0x1B, 0xB1, 0x4F, 0x60,
 94 | 
 95 | 	/* Sumaga Retail */
 96 | 	0xBF, 0x7F, 0x63, 0x11, 0x19, 0xCF, 0x76, 0x7C, 0x83, 0x39, 0xB1, 0x50, 0xFD, 0xD6, 0x06, 0x33,
 97 | 	0x75, 0x8D, 0x4A, 0x20, 0x3B, 0x22, 0x02, 0xCC, 0x0D, 0xD1, 0x4B, 0xA1, 0xED, 0xA0, 0x2D, 0x21,
 98 | 	0x94, 0xB0, 0x90, 0x4D, 0x1C, 0x1A, 0xF5, 0x05, 0xEA, 0x8A, 0xD3, 0xF7, 0x41, 0xB3, 0x2A, 0xC1,
 99 | 	0x3C, 0xA6, 0x32, 0x23, 0x7E, 0x61, 0x36, 0x93, 0x72, 0x2B, 0xAD, 0xCD, 0x58, 0xDE, 0xE1, 0x38,
100 | 	0x79, 0x0F, 0x68, 0x70, 0x5D, 0x6D, 0xA8, 0x81, 0x25, 0x0A, 0xCB, 0xA2, 0x34, 0x67, 0xF4, 0x6E,
101 | 	0x4E, 0x86, 0xF2, 0x9B, 0x78, 0xD9, 0x4F, 0xD2, 0xCA, 0xF6, 0x8F, 0x00, 0x74, 0x9D, 0xA9, 0xF8,
102 | 	0xDC, 0x45, 0x95, 0x3E, 0x8C, 0xE7, 0xEB, 0x4C, 0x10, 0x88, 0xC4, 0x97, 0xE4, 0x55, 0xB6, 0xC3,
103 | 	0x5A, 0xAA, 0x71, 0x87, 0x65, 0x99, 0x6B, 0x82, 0x9A, 0x62, 0x3D, 0xF9, 0xFA, 0xE2, 0x54, 0x09,
104 | 	0xC2, 0xFF, 0xFC, 0x30, 0xE8, 0x60, 0xD8, 0x91, 0x3F, 0x13, 0xBD, 0x47, 0xA3, 0xF1, 0xC8, 0x01,
105 | 	0x57, 0x52, 0xAC, 0xA7, 0x80, 0x44, 0xBE, 0x6C, 0x35, 0xB8, 0x96, 0xEE, 0x98, 0xB4, 0x89, 0x15,
106 | 	0x14, 0xC6, 0xBC, 0x07, 0x6F, 0x69, 0xAE, 0x0E, 0x5B, 0x66, 0x0B, 0x92, 0x9F, 0x9E, 0x28, 0xEC,
107 | 	0x84, 0xCE, 0x0C, 0x59, 0x37, 0xA4, 0x56, 0xD5, 0x03, 0x43, 0x3A, 0xB5, 0x7A, 0x1E, 0x1B, 0xC5,
108 | 	0xE6, 0xEF, 0x18, 0x5F, 0x5E, 0xE9, 0xDD, 0xC7, 0x9C, 0x04, 0x26, 0xD4, 0x46, 0x29, 0xB9, 0xF3,
109 | 	0xB2, 0x53, 0x6A, 0x16, 0xC0, 0xDB, 0xAB, 0xDA, 0x08, 0x8B, 0x49, 0x24, 0x42, 0x2E, 0x27, 0x5C,
110 | 	0xE0, 0xE5, 0x51, 0x7B, 0x2F, 0x40, 0xA5, 0x77, 0xF0, 0xAF, 0xE3, 0x8E, 0x1F, 0xD7, 0x85, 0x48,
111 | 	0xB7, 0x1D, 0xDF, 0x12, 0x73, 0x2C, 0xBA, 0x64, 0xFB, 0xFE, 0x7D, 0xC9, 0x17, 0x31, 0xBB, 0xD0,
112 | 
113 | 
114 | 
115 | 	/*
116 | 	* Nitro+ CHiRAL, the BL branch
117 | 	* Zoku Satsuriku no Django Retail
118 | 	*/
119 | 	0xDF, 0x5F, 0x6E, 0xF7, 0xF5, 0xEF, 0x52, 0x5B, 0x7E, 0x25, 0xD7, 0x46, 0xBC, 0x92, 0x02, 0x2E,
120 | 	0x51, 0x7C, 0x39, 0x16, 0x2A, 0x18, 0x08, 0xEB, 0x0C, 0x97, 0x3A, 0xC7, 0xAC, 0xC6, 0xB0, 0x17,
121 | 	0x80, 0xD6, 0x86, 0x3C, 0xFB, 0xF9, 0xB1, 0x01, 0xA9, 0x79, 0x9E, 0xB3, 0x37, 0xDE, 0x19, 0xE7,
122 | 	0x2B, 0xC2, 0x28, 0x1E, 0x5D, 0x67, 0x22, 0x8E, 0x58, 0x1A, 0xCC, 0xEC, 0x44, 0x9D, 0xA7, 0x24,
123 | 	0x55, 0x0F, 0x64, 0x56, 0x4C, 0x6C, 0xC4, 0x77, 0x11, 0x09, 0xEA, 0xC8, 0x20, 0x63, 0x1C, 0x6D,
124 | 	0x3D, 0x72, 0xB8, 0x8A, 0x54, 0x95, 0x3F, 0x98, 0xE9, 0xB2, 0x7F, 0x06, 0x50, 0x8C, 0xC5, 0xB4,
125 | 	0x9B, 0x31, 0x81, 0x2D, 0x7B, 0xA3, 0x42, 0x3B, 0xF6, 0x74, 0xE0, 0x83, 0xA0, 0x41, 0xD2, 0xEE,
126 | 	0x49, 0xC9, 0x57, 0x73, 0x61, 0x85, 0x6A, 0x78, 0x89, 0x68, 0x2C, 0xB5, 0xB9, 0xA8, 0x40, 0x05,
127 | 	0xE8, 0xBF, 0xBB, 0x26, 0xA4, 0x66, 0x94, 0x87, 0x2F, 0xFE, 0xDC, 0x33, 0xCE, 0xB7, 0xE4, 0x07,
128 | 	0x43, 0x48, 0xCB, 0xC3, 0x76, 0x30, 0xDD, 0x6B, 0x21, 0xD4, 0x82, 0xAD, 0x84, 0xD0, 0x75, 0xF1,
129 | 	0xF0, 0xE2, 0xDB, 0x03, 0x6F, 0x65, 0xCD, 0x0D, 0x4A, 0x62, 0x0A, 0x88, 0x8F, 0x8D, 0x14, 0xAB,
130 | 	0x70, 0xED, 0x0B, 0x45, 0x23, 0xC0, 0xAA, 0x91, 0x0E, 0x3E, 0x29, 0xD1, 0x59, 0xFD, 0xFA, 0xE1,
131 | 	0xA2, 0xAF, 0xF4, 0x4F, 0x4D, 0xA5, 0x9C, 0xE3, 0x8B, 0x00, 0x12, 0x90, 0x32, 0x15, 0xD5, 0xBE,
132 | 	0xD8, 0x4E, 0x69, 0xF2, 0xE6, 0x9A, 0xCA, 0x99, 0x04, 0x7A, 0x35, 0x10, 0x38, 0x1D, 0x13, 0x4B,
133 | 	0xA6, 0xA1, 0x47, 0x5A, 0x1F, 0x36, 0xC1, 0x53, 0xB6, 0xCF, 0xAE, 0x7D, 0xFF, 0x93, 0x71, 0x34,
134 | 	0xD3, 0xFC, 0x9F, 0xF8, 0x5E, 0x1B, 0xD9, 0x60, 0xBA, 0xBD, 0x5C, 0xE5, 0xF3, 0x27, 0xDA, 0x96,
135 | 
136 | 	/* Zoku Satsuriku no Django Trial */
137 | 	0xEF, 0x5F, 0x6E, 0xF6, 0xF5, 0xDF, 0x52, 0x5B, 0x7E, 0x15, 0xE6, 0x47, 0xBD, 0xA2, 0x02, 0x1E,
138 | 	0x51, 0x7D, 0x39, 0x27, 0x1A, 0x28, 0x08, 0xDB, 0x0D, 0xA6, 0x3A, 0xC6, 0x9D, 0xC7, 0xB0, 0x26,
139 | 	0x80, 0xE7, 0x87, 0x3D, 0xFB, 0xF9, 0xB1, 0x01, 0x99, 0x79, 0xAE, 0xB3, 0x36, 0xEE, 0x29, 0xD6,
140 | 	0x1B, 0xC2, 0x18, 0x2E, 0x5C, 0x66, 0x12, 0x8E, 0x58, 0x2A, 0xCD, 0xDD, 0x44, 0xAC, 0x96, 0x14,
141 | 	0x55, 0x0F, 0x64, 0x57, 0x4D, 0x6D, 0xC4, 0x76, 0x21, 0x09, 0xDA, 0xC8, 0x10, 0x63, 0x2D, 0x6C,
142 | 	0x3C, 0x72, 0xB8, 0x8A, 0x54, 0xA5, 0x3F, 0xA8, 0xD9, 0xB2, 0x7F, 0x07, 0x50, 0x8D, 0xC5, 0xB4,
143 | 	0xAB, 0x31, 0x81, 0x1C, 0x7B, 0x93, 0x42, 0x3B, 0xF7, 0x74, 0xD0, 0x83, 0x90, 0x41, 0xE2, 0xDE,
144 | 	0x49, 0xC9, 0x56, 0x73, 0x61, 0x85, 0x6A, 0x78, 0x89, 0x68, 0x1D, 0xB5, 0xB9, 0x98, 0x40, 0x05,
145 | 	0xD8, 0xBF, 0xBB, 0x17, 0x94, 0x67, 0xA4, 0x86, 0x1F, 0xFE, 0xED, 0x33, 0xCE, 0xB6, 0xD4, 0x06,
146 | 	0x43, 0x48, 0xCB, 0xC3, 0x77, 0x30, 0xEC, 0x6B, 0x11, 0xE4, 0x82, 0x9C, 0x84, 0xE0, 0x75, 0xF1,
147 | 	0xF0, 0xD2, 0xEB, 0x03, 0x6F, 0x65, 0xCC, 0x0C, 0x4A, 0x62, 0x0A, 0x88, 0x8F, 0x8C, 0x24, 0x9B,
148 | 	0x70, 0xDC, 0x0B, 0x45, 0x13, 0xC0, 0x9A, 0xA1, 0x0E, 0x3E, 0x19, 0xE1, 0x59, 0xFC, 0xFA, 0xD1,
149 | 	0x92, 0x9F, 0xF4, 0x4F, 0x4C, 0x95, 0xAD, 0xD3, 0x8B, 0x00, 0x22, 0xA0, 0x32, 0x25, 0xE5, 0xBE,
150 | 	0xE8, 0x4E, 0x69, 0xF2, 0xD7, 0xAA, 0xCA, 0xA9, 0x04, 0x7A, 0x35, 0x20, 0x38, 0x2C, 0x23, 0x4B,
151 | 	0x97, 0x91, 0x46, 0x5A, 0x2F, 0x37, 0xC1, 0x53, 0xB7, 0xCF, 0x9E, 0x7C, 0xFF, 0xA3, 0x71, 0x34,
152 | 	0xE3, 0xFD, 0xAF, 0xF8, 0x5E, 0x2B, 0xE9, 0x60, 0xBA, 0xBC, 0x5D, 0xD5, 0xF3, 0x16, 0xEA, 0xA7,
153 | 
154 | 	/* Lamento -Beyond the Void- Retail */
155 | 	0xDF, 0x5F, 0x6E, 0xF7, 0xF5, 0xEF, 0x52, 0x5B, 0x7E, 0x25, 0xD7, 0x46, 0xBC, 0x92, 0x02, 0x2E,
156 | 	0x51, 0x7C, 0x39, 0x16, 0x2A, 0x18, 0x08, 0xEB, 0x0C, 0x97, 0x3A, 0xC7, 0xAC, 0xC6, 0xB0, 0x17,
157 | 	0x80, 0xD6, 0x86, 0x3C, 0xFB, 0xF9, 0xB1, 0x01, 0xA9, 0x79, 0x9E, 0xB3, 0x37, 0xDE, 0x19, 0xE7,
158 | 	0x2B, 0xC2, 0x28, 0x1E, 0x5D, 0x67, 0x22, 0x8E, 0x58, 0x1A, 0xCC, 0xEC, 0x44, 0x9D, 0xA7, 0x24,
159 | 	0x55, 0x0F, 0x64, 0x56, 0x4C, 0x6C, 0xC4, 0x77, 0x11, 0x09, 0xEA, 0xC8, 0x20, 0x63, 0x1C, 0x6D,
160 | 	0x3D, 0x72, 0xB8, 0x8A, 0x54, 0x95, 0x3F, 0x98, 0xE9, 0xB2, 0x7F, 0x06, 0x50, 0x8C, 0xC5, 0xB4,
161 | 	0x9B, 0x31, 0x81, 0x2D, 0x7B, 0xA3, 0x42, 0x3B, 0xF6, 0x74, 0xE0, 0x83, 0xA0, 0x41, 0xD2, 0xEE,
162 | 	0x49, 0xC9, 0x57, 0x73, 0x61, 0x85, 0x6A, 0x78, 0x89, 0x68, 0x2C, 0xB5, 0xB9, 0xA8, 0x40, 0x05,
163 | 	0xE8, 0xBF, 0xBB, 0x26, 0xA4, 0x66, 0x94, 0x87, 0x2F, 0xFE, 0xDC, 0x33, 0xCE, 0xB7, 0xE4, 0x07,
164 | 	0x43, 0x48, 0xCB, 0xC3, 0x76, 0x30, 0xDD, 0x6B, 0x21, 0xD4, 0x82, 0xAD, 0x84, 0xD0, 0x75, 0xF1,
165 | 	0xF0, 0xE2, 0xDB, 0x03, 0x6F, 0x65, 0xCD, 0x0D, 0x4A, 0x62, 0x0A, 0x88, 0x8F, 0x8D, 0x14, 0xAB,
166 | 	0x70, 0xED, 0x0B, 0x45, 0x23, 0xC0, 0xAA, 0x91, 0x0E, 0x3E, 0x29, 0xD1, 0x59, 0xFD, 0xFA, 0xE1,
167 | 	0xA2, 0xAF, 0xF4, 0x4F, 0x4D, 0xA5, 0x9C, 0xE3, 0x8B, 0x00, 0x12, 0x90, 0x32, 0x15, 0xD5, 0xBE,
168 | 	0xD8, 0x4E, 0x69, 0xF2, 0xE6, 0x9A, 0xCA, 0x99, 0x04, 0x7A, 0x35, 0x10, 0x38, 0x1D, 0x13, 0x4B,
169 | 	0xA6, 0xA1, 0x47, 0x5A, 0x1F, 0x36, 0xC1, 0x53, 0xB6, 0xCF, 0xAE, 0x7D, 0xFF, 0x93, 0x71, 0x34,
170 | 	0xD3, 0xFC, 0x9F, 0xF8, 0x5E, 0x1B, 0xD9, 0x60, 0xBA, 0xBD, 0x5C, 0xE5, 0xF3, 0x27, 0xDA, 0x96,
171 | 
172 | 	/* Lamento -Beyond the Void- Trial */
173 | 	0xDF, 0x5F, 0x6E, 0xF7, 0xF5, 0xEF, 0x52, 0x5B, 0x7E, 0x25, 0xD7, 0x46, 0xBC, 0x92, 0x02, 0x2E,
174 | 	0x51, 0x7C, 0x39, 0x16, 0x2A, 0x18, 0x08, 0xEB, 0x0C, 0x97, 0x3A, 0xC7, 0xAC, 0xC6, 0xB0, 0x17,
175 | 	0x80, 0xD6, 0x86, 0x3C, 0xFB, 0xF9, 0xB1, 0x01, 0xA9, 0x79, 0x9E, 0xB3, 0x37, 0xDE, 0x19, 0xE7,
176 | 	0x2B, 0xC2, 0x28, 0x1E, 0x5D, 0x67, 0x22, 0x8E, 0x58, 0x1A, 0xCC, 0xEC, 0x44, 0x9D, 0xA7, 0x24,
177 | 	0x55, 0x0F, 0x64, 0x56, 0x4C, 0x6C, 0xC4, 0x77, 0x11, 0x09, 0xEA, 0xC8, 0x20, 0x63, 0x1C, 0x6D,
178 | 	0x3D, 0x72, 0xB8, 0x8A, 0x54, 0x95, 0x3F, 0x98, 0xE9, 0xB2, 0x7F, 0x06, 0x50, 0x8C, 0xC5, 0xB4,
179 | 	0x9B, 0x31, 0x81, 0x2D, 0x7B, 0xA3, 0x42, 0x3B, 0xF6, 0x74, 0xE0, 0x83, 0xA0, 0x41, 0xD2, 0xEE,
180 | 	0x49, 0xC9, 0x57, 0x73, 0x61, 0x85, 0x6A, 0x78, 0x89, 0x68, 0x2C, 0xB5, 0xB9, 0xA8, 0x40, 0x05,
181 | 	0xE8, 0xBF, 0xBB, 0x26, 0xA4, 0x66, 0x94, 0x87, 0x2F, 0xFE, 0xDC, 0x33, 0xCE, 0xB7, 0xE4, 0x07,
182 | 	0x43, 0x48, 0xCB, 0xC3, 0x76, 0x30, 0xDD, 0x6B, 0x21, 0xD4, 0x82, 0xAD, 0x84, 0xD0, 0x75, 0xF1,
183 | 	0xF0, 0xE2, 0xDB, 0x03, 0x6F, 0x65, 0xCD, 0x0D, 0x4A, 0x62, 0x0A, 0x88, 0x8F, 0x8D, 0x14, 0xAB,
184 | 	0x70, 0xED, 0x0B, 0x45, 0x23, 0xC0, 0xAA, 0x91, 0x0E, 0x3E, 0x29, 0xD1, 0x59, 0xFD, 0xFA, 0xE1,
185 | 	0xA2, 0xAF, 0xF4, 0x4F, 0x4D, 0xA5, 0x9C, 0xE3, 0x8B, 0x00, 0x12, 0x90, 0x32, 0x15, 0xD5, 0xBE,
186 | 	0xD8, 0x4E, 0x69, 0xF2, 0xE6, 0x9A, 0xCA, 0x99, 0x04, 0x7A, 0x35, 0x10, 0x38, 0x1D, 0x13, 0x4B,
187 | 	0xA6, 0xA1, 0x47, 0x5A, 0x1F, 0x36, 0xC1, 0x53, 0xB6, 0xCF, 0xAE, 0x7D, 0xFF, 0x93, 0x71, 0x34,
188 | 	0xD3, 0xFC, 0x9F, 0xF8, 0x5E, 0x1B, 0xD9, 0x60, 0xBA, 0xBD, 0x5C, 0xE5, 0xF3, 0x27, 0xDA, 0x96,
189 | 
190 | 	/* sweet pool Retail */
191 | 	0x7A, 0x3A, 0x23, 0xD1, 0xDF, 0x8A, 0x3C, 0x37, 0x43, 0xFF, 0x71, 0x10, 0xB8, 0x9C, 0xCC, 0xF3,
192 | 	0x3B, 0x48, 0x05, 0xE0, 0xF6, 0xE2, 0xC2, 0x87, 0xC8, 0x91, 0x06, 0x61, 0xA8, 0x60, 0xE8, 0xE1,
193 | 	0x54, 0x70, 0x50, 0x08, 0xD7, 0xD5, 0xBB, 0xCB, 0xA5, 0x45, 0x93, 0xBD, 0x01, 0x73, 0xE5, 0x81,
194 | 	0xF7, 0x6C, 0xF2, 0xE3, 0x39, 0x21, 0xFC, 0x53, 0x32, 0xE6, 0x68, 0x88, 0x1E, 0x99, 0xA1, 0xFE,
195 | 	0x3F, 0xCA, 0x2E, 0x30, 0x18, 0x28, 0x6E, 0x41, 0xEB, 0xC5, 0x86, 0x62, 0xF4, 0x2D, 0xB4, 0x29,
196 | 	0x09, 0x4C, 0xB2, 0x56, 0x3E, 0x9F, 0x0A, 0x92, 0x85, 0xBC, 0x4A, 0xC0, 0x34, 0x58, 0x6F, 0xBE,
197 | 	0x97, 0x0B, 0x5B, 0xF9, 0x47, 0xAD, 0xA6, 0x07, 0xD0, 0x4E, 0x84, 0x5D, 0xA4, 0x1B, 0x7C, 0x83,
198 | 	0x15, 0x65, 0x31, 0x4D, 0x2B, 0x5F, 0x26, 0x42, 0x55, 0x22, 0xF8, 0xBF, 0xB5, 0xA2, 0x14, 0xCF,
199 | 	0x82, 0xBA, 0xB7, 0xF0, 0xAE, 0x20, 0x9E, 0x51, 0xFA, 0xD3, 0x78, 0x0D, 0x63, 0xB1, 0x8E, 0xC1,
200 | 	0x1D, 0x12, 0x67, 0x6D, 0x40, 0x04, 0x79, 0x27, 0xFB, 0x7E, 0x5C, 0xA9, 0x5E, 0x74, 0x4F, 0xDB,
201 | 	0xD4, 0x8C, 0x77, 0xCD, 0x2A, 0x2F, 0x69, 0xC9, 0x16, 0x2C, 0xC6, 0x52, 0x5A, 0x59, 0xEE, 0xA7,
202 | 	0x44, 0x89, 0xC7, 0x1F, 0xFD, 0x64, 0x1C, 0x9B, 0xC3, 0x03, 0xF5, 0x7B, 0x35, 0xD9, 0xD6, 0x8B,
203 | 	0xAC, 0xAA, 0xDE, 0x1A, 0x19, 0xAF, 0x98, 0x8D, 0x57, 0xC4, 0xEC, 0x94, 0x0C, 0xEF, 0x7F, 0xB3,
204 | 	0x72, 0x13, 0x25, 0xDC, 0x80, 0x96, 0x66, 0x95, 0xCE, 0x46, 0x0F, 0xE4, 0x02, 0xE9, 0xED, 0x17,
205 | 	0xA0, 0xAB, 0x11, 0x36, 0xEA, 0x00, 0x6B, 0x3D, 0xB0, 0x6A, 0xA3, 0x49, 0xDA, 0x9D, 0x4B, 0x0E,
206 | 	0x7D, 0xD8, 0x9A, 0xD2, 0x33, 0xE7, 0x75, 0x24, 0xB6, 0xB9, 0x38, 0x8F, 0xDD, 0xF1, 0x76, 0x90,
207 | 
208 | 	/* Added after table was made */
209 | 	/* Sumaga Special Retail */
210 | 	0xA7, 0x67, 0x5A, 0x08, 0x01, 0xB7, 0x6D, 0x64, 0x8A, 0x31, 0xA8, 0x40, 0xE5, 0xCD, 0xFD, 0x3A,
211 | 	0x6C, 0x85, 0x22, 0x10, 0x33, 0x19, 0xF9, 0xB4, 0xF5, 0xC8, 0x23, 0x78, 0xD5, 0x70, 0x15, 0x18,
212 | 	0x9B, 0xA0, 0x90, 0x25, 0x04, 0x02, 0xEC, 0xFC, 0xD2, 0x82, 0xCA, 0xEE, 0x28, 0xAA, 0x12, 0xB8,
213 | 	0x34, 0x7D, 0x39, 0x1A, 0x66, 0x58, 0x3D, 0x9A, 0x69, 0x13, 0x75, 0xB5, 0x4F, 0xC6, 0xD8, 0x3F,
214 | 	0x61, 0xF7, 0x5F, 0x60, 0x45, 0x55, 0x7F, 0x88, 0x1C, 0xF2, 0xB3, 0x79, 0x3B, 0x5E, 0xEB, 0x56,
215 | 	0x26, 0x8D, 0xE9, 0x93, 0x6F, 0xC1, 0x27, 0xC9, 0xB2, 0xED, 0x87, 0xF0, 0x6B, 0x95, 0x71, 0xEF,
216 | 	0xC4, 0x2C, 0x9C, 0x36, 0x84, 0xDE, 0xD3, 0x24, 0x00, 0x8F, 0xBB, 0x9E, 0xDB, 0x4C, 0xAD, 0xBA,
217 | 	0x42, 0x72, 0x68, 0x8E, 0x5C, 0x91, 0x53, 0x89, 0x92, 0x59, 0x35, 0xE1, 0xE2, 0xD9, 0x4B, 0xF1,
218 | 	0xB9, 0xE7, 0xE4, 0x30, 0xDF, 0x50, 0xCF, 0x98, 0x37, 0x0A, 0xA5, 0x2E, 0x7A, 0xE8, 0xBF, 0xF8,
219 | 	0x4E, 0x49, 0x74, 0x7E, 0x80, 0x2B, 0xA6, 0x54, 0x3C, 0xAF, 0x9D, 0xD6, 0x9F, 0xAB, 0x81, 0x0C,
220 | 	0x0B, 0xBD, 0xA4, 0xFE, 0x57, 0x51, 0x76, 0xF6, 0x43, 0x5D, 0xF3, 0x99, 0x97, 0x96, 0x1F, 0xD4,
221 | 	0x8B, 0xB6, 0xF4, 0x41, 0x3E, 0x7B, 0x4D, 0xCC, 0xFA, 0x2A, 0x32, 0xAC, 0x62, 0x06, 0x03, 0xBC,
222 | 	0xDD, 0xD7, 0x0F, 0x47, 0x46, 0xD1, 0xC5, 0xBE, 0x94, 0xFB, 0x1D, 0xCB, 0x2D, 0x11, 0xA1, 0xEA,
223 | 	0xA9, 0x4A, 0x52, 0x0D, 0xB0, 0xC3, 0x73, 0xC2, 0xFF, 0x83, 0x21, 0x1B, 0x29, 0x16, 0x1E, 0x44,
224 | 	0xD0, 0xDC, 0x48, 0x63, 0x17, 0x20, 0x7C, 0x6E, 0xE0, 0x77, 0xDA, 0x86, 0x07, 0xCE, 0x8C, 0x2F,
225 | 	0xAE, 0x05, 0xC7, 0x09, 0x6A, 0x14, 0xA2, 0x5B, 0xE3, 0xE6, 0x65, 0xB1, 0x0E, 0x38, 0xA3, 0xC0,
226 | 
227 | 	/* Demonbane The Best */
228 | 	0x5C, 0x1C, 0x09, 0xA5, 0xA1, 0x6C, 0x1D, 0x14, 0x39, 0xD1, 0x55, 0x20, 0x8A, 0xED, 0x9D, 0xD9,
229 | 	0x17, 0x3A, 0xC2, 0xB0, 0xD3, 0xB8, 0x98, 0x64, 0x9A, 0xE5, 0xC3, 0x75, 0xFA, 0x70, 0xBA, 0xB5,
230 | 	0x46, 0x50, 0x40, 0xCA, 0xA4, 0xA2, 0x87, 0x97, 0xF2, 0x32, 0xE9, 0x8E, 0xC5, 0x59, 0xB2, 0x65,
231 | 	0xD4, 0x7D, 0xD8, 0xB9, 0x1B, 0x05, 0xDD, 0x49, 0x18, 0xB3, 0x7A, 0x6A, 0x2F, 0xEB, 0xF5, 0xDF,
232 | 	0x11, 0x9C, 0x0F, 0x10, 0x2A, 0x0A, 0x7F, 0x35, 0xB7, 0x92, 0x63, 0x78, 0xD6, 0x0E, 0x86, 0x0B,
233 | 	0xCB, 0x3D, 0x88, 0x43, 0x1F, 0xE1, 0xCC, 0xE8, 0x62, 0x8D, 0x3C, 0x90, 0x16, 0x4A, 0x71, 0x8F,
234 | 	0xE4, 0xC7, 0x47, 0xDB, 0x34, 0xFE, 0xF3, 0xC4, 0xA0, 0x3F, 0x66, 0x4E, 0xF6, 0x27, 0x5D, 0x69,
235 | 	0x22, 0x72, 0x15, 0x3E, 0x07, 0x41, 0x03, 0x38, 0x42, 0x08, 0xDA, 0x81, 0x82, 0xF8, 0x26, 0x91,
236 | 	0x68, 0x8C, 0x84, 0xD0, 0xFF, 0x00, 0xEF, 0x45, 0xDC, 0xA9, 0x5A, 0xCE, 0x79, 0x85, 0x6F, 0x95,
237 | 	0x2E, 0x28, 0x74, 0x7E, 0x30, 0xC6, 0x5B, 0x04, 0xD7, 0x5F, 0x4D, 0xFB, 0x4F, 0x56, 0x31, 0xA7,
238 | 	0xA6, 0x6D, 0x54, 0x9E, 0x0C, 0x01, 0x7B, 0x9B, 0x23, 0x0D, 0x93, 0x48, 0x4C, 0x4B, 0xBF, 0xF4,
239 | 	0x36, 0x6B, 0x94, 0x21, 0xDE, 0x76, 0x2D, 0xE7, 0x99, 0xC9, 0xD2, 0x57, 0x12, 0xAB, 0xA3, 0x67,
240 | 	0xFD, 0xFC, 0xAF, 0x2C, 0x2B, 0xF1, 0xEA, 0x6E, 0x44, 0x96, 0xBD, 0xE6, 0xCD, 0xB1, 0x51, 0x89,
241 | 	0x58, 0x29, 0x02, 0xAD, 0x60, 0xE3, 0x73, 0xE2, 0x9F, 0x33, 0xC1, 0xB6, 0xC8, 0xBB, 0xBE, 0x24,
242 | 	0xF0, 0xF7, 0x25, 0x13, 0xBC, 0xC0, 0x77, 0x1E, 0x80, 0x7C, 0xF9, 0x3B, 0xAC, 0xEE, 0x37, 0xCF,
243 | 	0x5E, 0xAA, 0xEC, 0xA8, 0x19, 0xB4, 0x52, 0x06, 0x83, 0x8B, 0x1A, 0x61, 0xAE, 0xD5, 0x53, 0xE0,
244 | 
245 | 	/* MuramasaAD */
246 | 	0xA1, 0xF1, 0x70, 0x5F, 0x5D, 0x01, 0xFA, 0xF6, 0x80, 0xCD, 0xAF, 0xEE, 0x37, 0x1A, 0x6A, 0xC0,
247 | 	0xF9, 0x87, 0xD4, 0xBE, 0xC5, 0xB3, 0x63, 0x06, 0x67, 0x1F, 0xD5, 0x4F, 0x27, 0x4E, 0xB7, 0xBF,
248 | 	0x92, 0xAE, 0x9E, 0xD7, 0x56, 0x54, 0x39, 0x69, 0x24, 0x84, 0x10, 0x3B, 0xDF, 0xA0, 0xB4, 0x0F,
249 | 	0xC6, 0x4A, 0xC3, 0xB0, 0xF8, 0x7F, 0xCA, 0x90, 0xF3, 0xB5, 0x47, 0x07, 0xEC, 0x18, 0x2F, 0xCC,
250 | 	0xFD, 0x61, 0x7C, 0xFE, 0xE7, 0x77, 0x4C, 0x8F, 0xB9, 0x64, 0x05, 0x43, 0xC2, 0x7B, 0x32, 0x78,
251 | 	0xD8, 0x8A, 0x33, 0x95, 0xFC, 0x1D, 0xD1, 0x13, 0x04, 0x3A, 0x81, 0x6E, 0xF2, 0x97, 0x4D, 0x3C,
252 | 	0x16, 0xD9, 0x99, 0xC8, 0x86, 0x2B, 0x25, 0xD6, 0x5E, 0x8C, 0x02, 0x9B, 0x22, 0xE9, 0xAA, 0x00,
253 | 	0xE4, 0x44, 0xFF, 0x8B, 0x79, 0x9D, 0x75, 0x83, 0x94, 0x73, 0xC7, 0x3D, 0x34, 0x23, 0xE2, 0x6D,
254 | 	0x03, 0x31, 0x36, 0xCE, 0x2C, 0x7E, 0x1C, 0x9F, 0xC1, 0x50, 0xA7, 0xDB, 0x40, 0x3F, 0x0C, 0x6F,
255 | 	0xEB, 0xE3, 0x46, 0x4B, 0x8E, 0xD2, 0xA8, 0x76, 0xC9, 0xAC, 0x9A, 0x28, 0x9C, 0xA2, 0x8D, 0x59,
256 | 	0x52, 0x0A, 0xA6, 0x6B, 0x71, 0x7D, 0x48, 0x68, 0xE5, 0x7A, 0x65, 0x93, 0x91, 0x98, 0xBC, 0x26,
257 | 	0x82, 0x08, 0x66, 0xED, 0xCB, 0x42, 0xEA, 0x19, 0x60, 0xD0, 0xC4, 0xA9, 0xF4, 0x58, 0x55, 0x09,
258 | 	0x2A, 0x21, 0x5C, 0xE1, 0xE8, 0x2D, 0x17, 0x0B, 0x96, 0x62, 0xBA, 0x12, 0xDA, 0xBD, 0xAD, 0x30,
259 | 	0xA3, 0xE0, 0x74, 0x5A, 0x0E, 0x15, 0x45, 0x14, 0x6C, 0x85, 0xDD, 0xB2, 0xD3, 0xB8, 0xBB, 0xE6,
260 | 	0x2E, 0x29, 0xEF, 0xF5, 0xB1, 0xDE, 0x49, 0xFB, 0x3E, 0x41, 0x20, 0x88, 0x51, 0x1B, 0x89, 0xDC,
261 | 	0xAB, 0x57, 0x11, 0x53, 0xF0, 0xB6, 0xA4, 0x72, 0x35, 0x38, 0xF7, 0x0D, 0x5B, 0xCF, 0xA5, 0x1E,
262 | 
263 | 	/* Axanael + Trial */
264 | 	0x21, 0x71, 0xF0, 0xD8, 0xD6, 0x81, 0x73, 0x7C, 0x00, 0x46, 0x28, 0x67, 0xBD, 0x93, 0xE3, 0x40,
265 | 	0x7F, 0x0D, 0x5A, 0x37, 0x4B, 0x39, 0xE9, 0x8C, 0xED, 0x98, 0x5B, 0xC8, 0xAD, 0xC7, 0x3D, 0x38,
266 | 	0x12, 0x27, 0x17, 0x5D, 0xDC, 0xDA, 0xBF, 0xEF, 0xAA, 0x0A, 0x90, 0xB4, 0x58, 0x20, 0x3A, 0x88,
267 | 	0x4C, 0xC3, 0x49, 0x30, 0x7E, 0xF8, 0x43, 0x10, 0x79, 0x3B, 0xCD, 0x8D, 0x65, 0x9E, 0xA8, 0x45,
268 | 	0x76, 0xE1, 0xF5, 0x77, 0x6D, 0xFD, 0xC5, 0x08, 0x3F, 0xEA, 0x8B, 0xC9, 0x42, 0xF4, 0xB2, 0xFE,
269 | 	0x5E, 0x03, 0xB9, 0x1B, 0x75, 0x96, 0x51, 0x99, 0x8A, 0xB3, 0x01, 0xE7, 0x72, 0x1D, 0xC6, 0xB5,
270 | 	0x9C, 0x5F, 0x1F, 0x4E, 0x0C, 0xA4, 0xAB, 0x5C, 0xD7, 0x05, 0x82, 0x14, 0xA2, 0x6F, 0x23, 0x80,
271 | 	0x6A, 0xCA, 0x78, 0x04, 0xFF, 0x16, 0xFB, 0x09, 0x1A, 0xF9, 0x4D, 0xB6, 0xBA, 0xA9, 0x62, 0xE6,
272 | 	0x89, 0xB1, 0xBC, 0x47, 0xA5, 0xF7, 0x95, 0x18, 0x41, 0xD0, 0x2D, 0x54, 0xC0, 0xB8, 0x85, 0xE8,
273 | 	0x64, 0x69, 0xCC, 0xC4, 0x07, 0x52, 0x2E, 0xFC, 0x4F, 0x25, 0x13, 0xAE, 0x15, 0x22, 0x06, 0xDF,
274 | 	0xD2, 0x83, 0x2C, 0xE4, 0xF1, 0xF6, 0xCE, 0xEE, 0x6B, 0xF3, 0xEB, 0x19, 0x11, 0x1E, 0x35, 0xAC,
275 | 	0x02, 0x8E, 0xEC, 0x66, 0x44, 0xC2, 0x63, 0x9F, 0xE0, 0x50, 0x4A, 0x2F, 0x7A, 0xDE, 0xDB, 0x8F,
276 | 	0xA3, 0xA1, 0xD5, 0x61, 0x6E, 0xA6, 0x9D, 0x84, 0x1C, 0xE2, 0x33, 0x92, 0x53, 0x36, 0x26, 0xB0,
277 | 	0x29, 0x60, 0xFA, 0xD3, 0x87, 0x9B, 0xCB, 0x9A, 0xE5, 0x0B, 0x56, 0x32, 0x59, 0x3E, 0x34, 0x6C,
278 | 	0xA7, 0xAF, 0x68, 0x7B, 0x31, 0x57, 0xCF, 0x74, 0xB7, 0xC1, 0xA0, 0x0E, 0xD1, 0x94, 0x0F, 0x55,
279 | 	0x24, 0xDD, 0x91, 0xD9, 0x70, 0x3C, 0x2A, 0xF2, 0xBB, 0xBE, 0x7D, 0x86, 0xD4, 0x48, 0x2B, 0x97,
280 | 
281 | 	/* Updated Kikokugai on N2System */
282 | 	0x21, 0xE1, 0xA0, 0x8D, 0x86, 0xF1, 0xE3, 0xE9, 0x00, 0xB6, 0x2D, 0xD7, 0x6A, 0x43, 0x93, 0xB0,
283 | 	0xEC, 0x0A, 0xCF, 0x37, 0xB8, 0x3E, 0x9E, 0xF9, 0x9A, 0x4D, 0xC8, 0x7D, 0x5A, 0x77, 0x3A, 0x3D,
284 | 	0x12, 0x27, 0x17, 0xCA, 0x89, 0x8F, 0x6C, 0x9C, 0x5F, 0x0F, 0x40, 0x64, 0xCD, 0x20, 0x3F, 0xFD,
285 | 	0xB9, 0x73, 0xBE, 0x30, 0xEB, 0xAD, 0xB3, 0x10, 0xEE, 0x38, 0x7A, 0xFA, 0xD5, 0x4B, 0x5D, 0xB5,
286 | 	0xE6, 0x91, 0xA5, 0xE7, 0xDA, 0xAA, 0x75, 0x0D, 0x3C, 0x9F, 0xF8, 0x7E, 0xB2, 0xA4, 0x62, 0xAB,
287 | 	0xCB, 0x03, 0x6E, 0x18, 0xE5, 0x46, 0xC1, 0x4E, 0xFF, 0x63, 0x01, 0x97, 0xE2, 0x1A, 0x76, 0x65,
288 | 	0x49, 0xCC, 0x1C, 0xBB, 0x09, 0x54, 0x58, 0xC9, 0x87, 0x05, 0xF2, 0x14, 0x52, 0xDC, 0x23, 0xF0,
289 | 	0xDF, 0x7F, 0xED, 0x04, 0xAC, 0x16, 0xA8, 0x0E, 0x1F, 0xAE, 0xBA, 0x66, 0x6F, 0x5E, 0xD2, 0x96,
290 | 	0xFE, 0x61, 0x69, 0xB7, 0x55, 0xA7, 0x45, 0x1D, 0xB1, 0x80, 0x2A, 0xC4, 0x70, 0x6D, 0xF5, 0x9D,
291 | 	0xD4, 0xDE, 0x79, 0x74, 0x07, 0xC2, 0x2B, 0xA9, 0xBC, 0x25, 0x13, 0x5B, 0x15, 0x22, 0x06, 0x8C,
292 | 	0x82, 0xF3, 0x29, 0x94, 0xA1, 0xA6, 0x7B, 0x9B, 0xD8, 0xA3, 0x98, 0x1E, 0x11, 0x1B, 0x35, 0x59,
293 | 	0x02, 0xFB, 0x99, 0xD6, 0xB4, 0x72, 0xD3, 0x4C, 0x90, 0xC0, 0xBF, 0x2C, 0xEF, 0x8B, 0x88, 0xFC,
294 | 	0x53, 0x51, 0x85, 0xD1, 0xDB, 0x56, 0x4A, 0xF4, 0x19, 0x92, 0x33, 0x42, 0xC3, 0x36, 0x26, 0x60,
295 | 	0x2E, 0xD0, 0xAF, 0x83, 0xF7, 0x48, 0x78, 0x4F, 0x95, 0x08, 0xC6, 0x32, 0xCE, 0x3B, 0x34, 0xD9,
296 | 	0x57, 0x5C, 0xDD, 0xE8, 0x31, 0xC7, 0x7C, 0xE4, 0x67, 0x71, 0x50, 0x0B, 0x81, 0x44, 0x0C, 0xC5,
297 | 	0x24, 0x8A, 0x41, 0x8E, 0xE0, 0x39, 0x2F, 0xA2, 0x68, 0x6B, 0xEA, 0xF6, 0x84, 0xBD, 0x28, 0x47,
298 | 
299 | 	/* Sonicomi Trial 2 */
300 | 	0x21, 0x71, 0xD0, 0xB8, 0xBC, 0x81, 0x73, 0x7F, 0x00, 0xEC, 0x28, 0x6D, 0x95, 0x43, 0xC3, 0xE0,
301 | 	0x77, 0x05, 0xFA, 0x3D, 0xEE, 0x39, 0xC9, 0x8F, 0xC5, 0x48, 0xFE, 0xA8, 0x55, 0xAD, 0x35, 0x38,
302 | 	0x12, 0x2D, 0x1D, 0xF5, 0xBF, 0xBA, 0x97, 0xC7, 0x5A, 0x0A, 0x40, 0x94, 0xF8, 0x20, 0x3A, 0x88,
303 | 	0xEF, 0xA3, 0xE9, 0x30, 0x76, 0xD8, 0xE3, 0x10, 0x79, 0x3E, 0xA5, 0x85, 0x6B, 0x46, 0x58, 0xEB,
304 | 	0x7C, 0xC1, 0xDB, 0x7D, 0x65, 0xD5, 0xAB, 0x08, 0x37, 0xCA, 0x8E, 0xA9, 0xE2, 0xD4, 0x92, 0xD6,
305 | 	0xF6, 0x03, 0x99, 0x1E, 0x7B, 0x4C, 0xF1, 0x49, 0x8A, 0x93, 0x01, 0xCD, 0x72, 0x15, 0xAC, 0x9B,
306 | 	0x4F, 0xF7, 0x17, 0xE6, 0x0F, 0x54, 0x5E, 0xFF, 0xBD, 0x0B, 0x82, 0x14, 0x52, 0x67, 0x23, 0x80,
307 | 	0x6A, 0xAA, 0x78, 0x04, 0xD7, 0x1C, 0xDE, 0x09, 0x1A, 0xD9, 0xE5, 0x9C, 0x9A, 0x59, 0x62, 0xCC,
308 | 	0x89, 0x91, 0x9F, 0xED, 0x5B, 0xDD, 0x4B, 0x18, 0xE1, 0xB0, 0x25, 0xF4, 0xA0, 0x98, 0x8B, 0xC8,
309 | 	0x64, 0x69, 0xAF, 0xA4, 0x0D, 0xF2, 0x26, 0xDF, 0xE7, 0x2B, 0x13, 0x56, 0x1B, 0x22, 0x0C, 0xB7,
310 | 	0xB2, 0x83, 0x2F, 0xC4, 0xD1, 0xDC, 0xA6, 0xC6, 0x6E, 0xD3, 0xCE, 0x19, 0x11, 0x16, 0x3B, 0x5F,
311 | 	0x02, 0x86, 0xCF, 0x6C, 0xE4, 0xA2, 0x63, 0x47, 0xC0, 0xF0, 0xEA, 0x27, 0x7A, 0xB6, 0xBE, 0x87,
312 | 	0x53, 0x51, 0xBB, 0x61, 0x66, 0x5C, 0x45, 0x84, 0x1F, 0xC2, 0x33, 0x42, 0xF3, 0x3C, 0x2C, 0x90,
313 | 	0x29, 0x60, 0xDA, 0xB3, 0x8D, 0x4E, 0xAE, 0x4A, 0xCB, 0x0E, 0xFC, 0x32, 0xF9, 0x36, 0x34, 0x6F,
314 | 	0x5D, 0x57, 0x68, 0x7E, 0x31, 0xFD, 0xA7, 0x74, 0x9D, 0xA1, 0x50, 0x06, 0xB1, 0x44, 0x07, 0xFB,
315 | 	0x24, 0xB5, 0x41, 0xB9, 0x70, 0x3F, 0x2A, 0xD2, 0x9E, 0x96, 0x75, 0x8C, 0xB4, 0xE8, 0x2E, 0x4D,
316 | 
317 | 	/* Sumaga 3% Trial */	
318 | 	0xEF, 0x6F, 0x70, 0x08, 0x06, 0xFF, 0x63, 0x6C, 0x80, 0x36, 0xE8, 0x57, 0xCD, 0xA3, 0x13, 0x30,
319 | 	0x62, 0x8D, 0x4A, 0x27, 0x3B, 0x29, 0x19, 0xFC, 0x1D, 0xA8, 0x4B, 0xD8, 0xBD, 0xD7, 0x2D, 0x28,
320 | 	0x91, 0xE7, 0x97, 0x4D, 0x0C, 0x0A, 0xC2, 0x12, 0xBA, 0x8A, 0xA0, 0xC4, 0x48, 0xE0, 0x2A, 0xF8,
321 | 	0x3C, 0xD3, 0x39, 0x20, 0x6E, 0x78, 0x33, 0x90, 0x69, 0x2B, 0xDD, 0xFD, 0x55, 0xAE, 0xB8, 0x35,
322 | 	0x66, 0x1F, 0x75, 0x67, 0x5D, 0x7D, 0xD5, 0x88, 0x22, 0x1A, 0xFB, 0xD9, 0x31, 0x74, 0xC1, 0x7E,
323 | 	0x4E, 0x83, 0xC9, 0x9B, 0x65, 0xA6, 0x4F, 0xA9, 0xFA, 0xC3, 0x8F, 0x17, 0x61, 0x9D, 0xD6, 0xC5,
324 | 	0xAC, 0x42, 0x92, 0x3E, 0x8C, 0xB4, 0xBB, 0x4C, 0x07, 0x85, 0xF1, 0x94, 0xB1, 0x52, 0xE3, 0xF0,
325 | 	0x5A, 0xDA, 0x68, 0x84, 0x72, 0x96, 0x7B, 0x89, 0x9A, 0x79, 0x3D, 0xC6, 0xCA, 0xB9, 0x51, 0x16,
326 | 	0xF9, 0xCF, 0xCC, 0x37, 0xB5, 0x77, 0xA5, 0x98, 0x3F, 0x00, 0xED, 0x44, 0xD0, 0xC8, 0xF5, 0x18,
327 | 	0x54, 0x59, 0xDC, 0xD4, 0x87, 0x41, 0xEE, 0x7C, 0x32, 0xE5, 0x93, 0xBE, 0x95, 0xE1, 0x86, 0x02,
328 | 	0x01, 0xF3, 0xEC, 0x14, 0x7F, 0x76, 0xDE, 0x1E, 0x5B, 0x73, 0x1B, 0x99, 0x9F, 0x9E, 0x25, 0xBC,
329 | 	0x81, 0xFE, 0x1C, 0x56, 0x34, 0xD1, 0x53, 0xA2, 0x10, 0x40, 0x3A, 0xE2, 0x6A, 0x0E, 0x0B, 0xF2,
330 | 	0xB3, 0xBF, 0x05, 0x5F, 0x5E, 0xB6, 0xAD, 0xF4, 0x9C, 0x11, 0x23, 0xA1, 0x43, 0x26, 0xE6, 0xC0,
331 | 	0xE9, 0x50, 0x7A, 0x03, 0xF7, 0xAB, 0xDB, 0xAA, 0x15, 0x8B, 0x46, 0x21, 0x49, 0x2E, 0x24, 0x5C,
332 | 	0xB7, 0xB2, 0x58, 0x6B, 0x2F, 0x47, 0xD2, 0x64, 0xC7, 0xDF, 0xB0, 0x8E, 0x0F, 0xA4, 0x82, 0x45,
333 | 	0xE4, 0x0D, 0xAF, 0x09, 0x60, 0x2C, 0xEA, 0x71, 0xCB, 0xCE, 0x6D, 0xF6, 0x04, 0x38, 0xEB, 0xA7,	
334 | 	
335 | 	/* Sonicomi Version 1.0 */
336 | 	0x91, 0xD1, 0x10, 0xCB, 0xCF, 0xE1, 0xD6, 0xD5, 0x70, 0x2F, 0x9B, 0x63, 0xF8, 0x46, 0x06, 0x20,
337 | 	0xDA, 0x78, 0x3D, 0xA3, 0x24, 0xAC, 0x0C, 0xE5, 0x08, 0x4B, 0x34, 0xBB, 0x58, 0xB3, 0xA8, 0xAB,
338 | 	0x82, 0x93, 0x83, 0x38, 0xC5, 0xCD, 0xFA, 0x0A, 0x5D, 0x7D, 0x40, 0xF7, 0x3B, 0x90, 0xAD, 0xEB,
339 | 	0x25, 0xB6, 0x2C, 0xA0, 0xD9, 0x1B, 0x26, 0x80, 0xDC, 0xA4, 0xB8, 0xE8, 0x6E, 0x49, 0x5B, 0x2E,
340 | 	0xDF, 0x01, 0x1E, 0xD3, 0x68, 0x18, 0xBE, 0x7B, 0xAA, 0x0D, 0xE4, 0xBC, 0x22, 0x17, 0xF2, 0x19,
341 | 	0x39, 0x76, 0xFC, 0x84, 0xDE, 0x4F, 0x31, 0x4C, 0xED, 0xF6, 0x71, 0x03, 0xD2, 0x88, 0xBF, 0xFE,
342 | 	0x45, 0x3A, 0x8A, 0x29, 0x75, 0x57, 0x54, 0x35, 0xC3, 0x7E, 0xE2, 0x87, 0x52, 0x6A, 0x96, 0xE0,
343 | 	0x6D, 0xBD, 0xDB, 0x77, 0x1A, 0x8F, 0x14, 0x7C, 0x8D, 0x1C, 0x28, 0xFF, 0xFD, 0x5C, 0x62, 0x0F,
344 | 	0xEC, 0xF1, 0xF5, 0x23, 0x5E, 0x13, 0x4E, 0x8B, 0x21, 0xC0, 0x98, 0x37, 0xB0, 0xFB, 0xEE, 0x0B,
345 | 	0x67, 0x6C, 0xB5, 0xB7, 0x73, 0x32, 0x99, 0x15, 0x2A, 0x9E, 0x86, 0x59, 0x8E, 0x92, 0x7F, 0xCA,
346 | 	0xC2, 0xE6, 0x95, 0x07, 0x11, 0x1F, 0xB9, 0x09, 0x64, 0x16, 0x04, 0x8C, 0x81, 0x89, 0xAE, 0x55,
347 | 	0x72, 0xE9, 0x05, 0x6F, 0x27, 0xB2, 0x66, 0x4A, 0x00, 0x30, 0x2D, 0x9A, 0xDD, 0xC9, 0xC4, 0xEA,
348 | 	0x56, 0x51, 0xCE, 0x61, 0x69, 0x5F, 0x48, 0xE7, 0x85, 0x02, 0xA6, 0x42, 0x36, 0xAF, 0x9F, 0xF0,
349 | 	0x9C, 0x60, 0x1D, 0xC6, 0xE3, 0x44, 0xB4, 0x4D, 0x0E, 0x74, 0x3F, 0xA2, 0x3C, 0xA9, 0xA7, 0x65,
350 | 	0x53, 0x5A, 0x6B, 0xD4, 0xA1, 0x33, 0xBA, 0xD7, 0xF3, 0xB1, 0x50, 0x79, 0xC1, 0x47, 0x7A, 0x3E,
351 | 	0x97, 0xC8, 0x41, 0xCC, 0xD0, 0xA5, 0x9D, 0x12, 0xF4, 0xF9, 0xD8, 0xEF, 0xC7, 0x2B, 0x94, 0x43,
352 | 	
353 | 	/* Guilty Crown Lost Xmas */
354 | 	0xCC, 0x7C, 0xF3, 0xBD, 0xB5, 0x8C, 0x79, 0x70, 0x13, 0x95, 0xCD, 0x4E, 0xA1, 0x59, 0xD9, 0x93,
355 | 	0x78, 0x11, 0x3B, 0xEE, 0x92, 0xEA, 0xDA, 0x80, 0xD1, 0x5D, 0x32, 0x0D, 0x61, 0x0E, 0xE1, 0xED,
356 | 	0x26, 0xCE, 0x2E, 0x31, 0xB0, 0xBB, 0xA8, 0xD8, 0x6B, 0x1B, 0x53, 0xAF, 0x3D, 0xC3, 0xEB, 0x8D,
357 | 	0x90, 0x09, 0x9A, 0xE3, 0x77, 0xFD, 0x99, 0x23, 0x7A, 0xE2, 0x01, 0x81, 0x44, 0x57, 0x6D, 0x94,
358 | 	0x75, 0xDC, 0xF4, 0x7E, 0x41, 0xF1, 0x04, 0x1D, 0xE8, 0xDB, 0x82, 0x0A, 0x96, 0xFF, 0xA6, 0xF7,
359 | 	0x37, 0x19, 0xAA, 0x22, 0x74, 0x55, 0x3C, 0x5A, 0x8B, 0xA9, 0x1C, 0xDE, 0x76, 0x21, 0x05, 0xA4,
360 | 	0x50, 0x38, 0x28, 0x97, 0x10, 0x6F, 0x62, 0x30, 0xBE, 0x14, 0x86, 0x2F, 0x66, 0x48, 0xC9, 0x83,
361 | 	0x4B, 0x0B, 0x7D, 0x1F, 0xF8, 0x25, 0xF2, 0x1A, 0x2B, 0xFA, 0x91, 0xA5, 0xAB, 0x6A, 0x46, 0xD5,
362 | 	0x8A, 0xAC, 0xA0, 0x9E, 0x64, 0xFE, 0x54, 0x2D, 0x9C, 0xB3, 0xC1, 0x3F, 0x03, 0xAD, 0x84, 0xDD,
363 | 	0x4F, 0x4A, 0x00, 0x0F, 0x1E, 0x36, 0xC7, 0xF0, 0x98, 0xC4, 0x29, 0x67, 0x24, 0xC6, 0x15, 0xB8,
364 | 	0xB6, 0x89, 0xC0, 0xDF, 0xFC, 0xF5, 0x07, 0xD7, 0x42, 0xF9, 0xD2, 0x2A, 0x2C, 0x27, 0xE4, 0x60,
365 | 	0x16, 0x87, 0xD0, 0x45, 0x9F, 0x06, 0x49, 0x58, 0xD3, 0x33, 0x9B, 0xC8, 0x7B, 0xB7, 0xB2, 0x88,
366 | 	0x69, 0x6C, 0xB4, 0x4C, 0x47, 0x65, 0x51, 0x8F, 0x20, 0xD6, 0xE9, 0x56, 0x39, 0xE5, 0xC5, 0xA3,
367 | 	0xCA, 0x43, 0xFB, 0xB9, 0x8E, 0x52, 0x02, 0x5B, 0xD4, 0x12, 0x35, 0xE6, 0x3A, 0xE7, 0xEF, 0x40,
368 | 	0x6E, 0x68, 0x4D, 0x72, 0xEC, 0x3E, 0x08, 0x7F, 0xAE, 0x0C, 0x63, 0x17, 0xBC, 0x5F, 0x18, 0x34,
369 | 	0xCF, 0xB1, 0x5C, 0xBA, 0x73, 0xE0, 0xCB, 0xF6, 0xA2, 0xA7, 0x71, 0x85, 0xBF, 0x9D, 0xC2, 0x5E,
370 | 	
371 | 	/* Guilty Crown Lost Xmas Trailer */
372 | 	0xC8, 0x38, 0xF3, 0xB9, 0xBC, 0x48, 0x35, 0x30, 0x83, 0x5C, 0xC9, 0x0A, 0x61, 0x15, 0xD5, 0x53,
373 | 	0x3F, 0x81, 0xA7, 0xEA, 0x52, 0xE6, 0xD6, 0x40, 0xD1, 0x19, 0xA2, 0x79, 0x21, 0x7A, 0xE1, 0xE9,
374 | 	0x9D, 0xCA, 0x9A, 0xA1, 0xB0, 0xB7, 0x6F, 0xDF, 0x27, 0x87, 0x13, 0x6B, 0xA9, 0xC3, 0xE7, 0x49,
375 | 	0x50, 0x75, 0x56, 0xE3, 0x3E, 0xF9, 0x55, 0x93, 0x36, 0xE2, 0x71, 0x41, 0x04, 0x1E, 0x29, 0x54,
376 | 	0x3C, 0xD8, 0xF4, 0x3A, 0x01, 0xF1, 0x74, 0x89, 0xEF, 0xD7, 0x42, 0x76, 0x5D, 0xFB, 0x6D, 0xFE,
377 | 	0xAE, 0x85, 0x66, 0x92, 0x34, 0x1C, 0xA8, 0x16, 0x47, 0x65, 0x88, 0xDA, 0x3D, 0x91, 0x7C, 0x64,
378 | 	0x10, 0xAF, 0x9F, 0x5E, 0x80, 0x2B, 0x22, 0xA0, 0xBA, 0x84, 0x4D, 0x9B, 0x2D, 0x0F, 0xC5, 0x43,
379 | 	0x07, 0x77, 0x39, 0x8B, 0xFF, 0x9C, 0xF2, 0x86, 0x97, 0xF6, 0x51, 0x6C, 0x67, 0x26, 0x0D, 0xDC,
380 | 	0x46, 0x68, 0x60, 0x5A, 0x24, 0xFA, 0x14, 0x99, 0x58, 0xB3, 0xC1, 0xAB, 0x73, 0x69, 0x44, 0xD9,
381 | 	0x0B, 0x06, 0x70, 0x7B, 0x8A, 0xAD, 0xCE, 0xF0, 0x5F, 0xC4, 0x95, 0x2E, 0x94, 0xCD, 0x8C, 0xBF,
382 | 	0xBD, 0x45, 0xC0, 0xDB, 0xF8, 0xFC, 0x7E, 0xDE, 0x02, 0xF5, 0xD2, 0x96, 0x98, 0x9E, 0xE4, 0x20,
383 | 	0x8D, 0x4E, 0xD0, 0x0C, 0x5B, 0x7D, 0x05, 0x1F, 0xD3, 0xA3, 0x57, 0xCF, 0x37, 0xBE, 0xB2, 0x4F,
384 | 	0x25, 0x28, 0xB4, 0x08, 0x0E, 0x2C, 0x11, 0x4B, 0x90, 0xDD, 0xE5, 0x1D, 0xA5, 0xEC, 0xCC, 0x63,
385 | 	0xC6, 0x03, 0xF7, 0xB5, 0x4A, 0x12, 0x72, 0x17, 0xD4, 0x82, 0xAC, 0xED, 0xA6, 0xEE, 0xEB, 0x00,
386 | 	0x2A, 0x2F, 0x09, 0x32, 0xE8, 0xAA, 0x7F, 0x3B, 0x6A, 0x78, 0x23, 0x8E, 0xB8, 0x1B, 0x8F, 0xA4,
387 | 	0xCB, 0xB1, 0x18, 0xB6, 0x33, 0xE0, 0xC7, 0xFD, 0x62, 0x6E, 0x31, 0x4C, 0xBB, 0x59, 0xC2, 0x1A,
388 | 
389 | 	/* DRAMAtical Murder */
390 | 	0x71, 0x41, 0x80, 0xE5, 0xE9, 0x51, 0x4F, 0x4B, 0x00, 0x99, 0x75, 0x3A, 0xCC, 0xAF, 0xFF, 0x90,
391 | 	0x44, 0x0C, 0x27, 0x6A, 0x9D, 0x66, 0xF6, 0x5B, 0xFC, 0xA5, 0x2D, 0xD5, 0xBC, 0xDA, 0x6C, 0x65,
392 | 	0x12, 0x7A, 0x1A, 0x2C, 0xEB, 0xE7, 0xC4, 0xF4, 0xB7, 0x07, 0xA0, 0xC8, 0x25, 0x70, 0x67, 0x55,
393 | 	0x9B, 0xDF, 0x96, 0x60, 0x43, 0x85, 0x9F, 0x10, 0x46, 0x6D, 0xDC, 0x5C, 0x3E, 0xA3, 0xB5, 0x9E,
394 | 	0x49, 0xF1, 0x8E, 0x4A, 0x3C, 0x8C, 0xDE, 0x05, 0x64, 0xF7, 0x5D, 0xD6, 0x92, 0x88, 0xC2, 0x83,
395 | 	0x23, 0x0F, 0xC6, 0x1D, 0x4E, 0xA9, 0x21, 0xA6, 0x57, 0xCF, 0x01, 0xFA, 0x42, 0x1C, 0xD9, 0xCE,
396 | 	0xAB, 0x24, 0x14, 0x93, 0x0B, 0xB8, 0xBD, 0x2B, 0xEA, 0x0E, 0x52, 0x18, 0xB2, 0x34, 0x7F, 0x50,
397 | 	0x37, 0xD7, 0x45, 0x08, 0x84, 0x19, 0x8D, 0x06, 0x17, 0x86, 0x9C, 0xC9, 0xC7, 0xB6, 0x32, 0xF9,
398 | 	0x56, 0xC1, 0xCB, 0x9A, 0xBE, 0x8A, 0xAE, 0x15, 0x91, 0xE0, 0x7C, 0x28, 0xD0, 0xC5, 0x5E, 0xF5,
399 | 	0x38, 0x36, 0xDB, 0xD8, 0x0A, 0x22, 0x73, 0x8B, 0x94, 0x7E, 0x1F, 0xB3, 0x1E, 0x72, 0x09, 0xE4,
400 | 	0xE2, 0x5F, 0x7B, 0xF8, 0x81, 0x89, 0xD3, 0xF3, 0x3D, 0x8F, 0xFD, 0x16, 0x11, 0x13, 0x6E, 0xBB,
401 | 	0x02, 0x53, 0xFB, 0x39, 0x98, 0xD2, 0x3F, 0xA4, 0xF0, 0x20, 0x97, 0x74, 0x47, 0xE3, 0xED, 0x54,
402 | 	0xBF, 0xB1, 0xEE, 0x31, 0x33, 0xB9, 0xAC, 0x58, 0x1B, 0xF2, 0x6F, 0xA2, 0x2F, 0x69, 0x79, 0xC0,
403 | 	0x76, 0x30, 0x87, 0xEF, 0x5A, 0xAD, 0xDD, 0xA7, 0xFE, 0x0D, 0x29, 0x62, 0x26, 0x63, 0x68, 0x3B,
404 | 	0xBA, 0xB4, 0x35, 0x4D, 0x61, 0x2A, 0xD4, 0x48, 0xCA, 0xD1, 0xB0, 0x03, 0xE1, 0xA8, 0x04, 0x2E,
405 | 	0x78, 0xEC, 0xA1, 0xE6, 0x40, 0x6B, 0x77, 0x82, 0xCD, 0xC3, 0x4C, 0x59, 0xE8, 0x95, 0x7D, 0xAA,
406 | 	
407 | 	/* Totono */
408 | 	0x57, 0xD7, 0x66, 0x10, 0x14, 0xE7, 0xDF, 0xD8, 0x36, 0x74, 0x50, 0x95, 0xC9, 0xAF, 0x2F, 0x76,
409 | 	0xDD, 0x39, 0x82, 0xF5, 0x7A, 0xF1, 0x21, 0xE8, 0x29, 0xA0, 0x8A, 0x00, 0xB9, 0x05, 0xF9, 0xF0,
410 | 	0x4B, 0x55, 0x45, 0x89, 0x18, 0x12, 0xCD, 0x2D, 0xB2, 0x32, 0xA6, 0xC3, 0x80, 0x56, 0xF2, 0xE0,
411 | 	0x78, 0x0F, 0x71, 0xF6, 0xDC, 0x60, 0x7F, 0x46, 0xD1, 0xFA, 0x09, 0xE9, 0x9E, 0xAC, 0xB0, 0x7E,
412 | 	0xD4, 0x27, 0x6E, 0xD5, 0x99, 0x69, 0x0E, 0x30, 0xFD, 0x22, 0xEA, 0x01, 0x7B, 0x63, 0xCB, 0x6C,
413 | 	0x8C, 0x3F, 0xC1, 0x4A, 0xDE, 0xA4, 0x87, 0xA1, 0xE2, 0xCF, 0x37, 0x25, 0xDB, 0x49, 0x04, 0xCE,
414 | 	0xA8, 0x8D, 0x4D, 0x7C, 0x38, 0xB3, 0xBA, 0x88, 0x15, 0x3E, 0xEB, 0x43, 0xBB, 0x9D, 0x5F, 0xE6,
415 | 	0x92, 0x02, 0xD0, 0x33, 0x6D, 0x44, 0x6A, 0x31, 0x42, 0x61, 0x79, 0xC4, 0xC2, 0xB1, 0x9B, 0x24,
416 | 	0xE1, 0xC7, 0xC8, 0x75, 0xBE, 0x65, 0xAE, 0x40, 0x77, 0x16, 0x59, 0x83, 0x06, 0xC0, 0xEE, 0x20,
417 | 	0x93, 0x91, 0x08, 0x03, 0x35, 0x8B, 0x5C, 0x68, 0x7D, 0x5E, 0x4F, 0xBC, 0x4E, 0x5B, 0x34, 0x1D,
418 | 	0x1B, 0xEF, 0x58, 0x23, 0x67, 0x64, 0x0C, 0x2C, 0x9A, 0x6F, 0x2A, 0x41, 0x47, 0x4C, 0xFE, 0xB8,
419 | 	0x3B, 0xEC, 0x28, 0x94, 0x73, 0x0B, 0x9F, 0xAD, 0x26, 0x86, 0x72, 0x5D, 0xD2, 0x1C, 0x1A, 0xED,
420 | 	0xBF, 0xB7, 0x1E, 0x97, 0x9C, 0xB4, 0xA9, 0xE3, 0x48, 0x2B, 0xFF, 0xAB, 0x8F, 0xF4, 0x54, 0xC6,
421 | 	0x51, 0x96, 0x62, 0x1F, 0xE5, 0xAA, 0x0A, 0xA2, 0x2E, 0x3A, 0x84, 0xFB, 0x81, 0xFC, 0xF3, 0x98,
422 | 	0xB5, 0xBD, 0x90, 0xDA, 0xF7, 0x85, 0x0D, 0xD3, 0xC5, 0x07, 0xB6, 0x3C, 0x17, 0xA3, 0x3D, 0x8E,
423 | 	0x53, 0x19, 0xA7, 0x11, 0xD6, 0xF8, 0x52, 0x6B, 0xCA, 0xCC, 0xD9, 0xE4, 0x13, 0x70, 0x5A, 0xA5,
424 | 
425 | 	0
426 | };
427 | 


--------------------------------------------------------------------------------