Add headers, clang-format, decompctx.py & more

Former-commit-id: 53f8d3cba7

.clang-format

@@ -0,0 +1,10 @@
+---
+BasedOnStyle: LLVM
+IndentWidth: 2
+ColumnLimit: 140
+---
+Language: Cpp
+DerivePointerAlignment: false
+PointerAlignment: Left
+AlwaysBreakTemplateDeclarations: Yes
+SpacesInAngles: Always # for C++98-compatible nested template arguments

include/Dolphin/OSCache.h

@@ -0,0 +1,16 @@
+#ifndef _DOLPHIN_OSCACHE
+#define _DOLPHIN_OSCACHE
+
+#include "types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void LCEnable();
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

include/Dolphin/PPCArch.h

@@ -1,3 +1,6 @@
+#ifndef _DOLPHIN_PPCARCH_H
+#define _DOLPHIN_PPCARCH_H
+
 #include "types.h"
 
 #ifdef __cplusplus
@@ -28,3 +31,5 @@ void PPCSetFpNonIEEEMode();
 #ifdef __cplusplus
 }
 #endif
+
+#endif

include/Dolphin/__ppc_eabi_init.h

@@ -1,6 +1,5 @@
 #include "types.h"
 
-
 __declspec(section ".init") extern void __init_hardware(void);
 __declspec(section ".init") extern void __flush_cache(register void* address, register unsigned int size);
 

include/Dolphin/__start.h

@@ -1,5 +1,5 @@
-#include "types.h"
 #include "Dolphin/db.h"
+#include "types.h"
 
 #define PAD3_BUTTON_ADDR 0x800030E4
 #define OS_RESET_RESTART 0
@@ -19,22 +19,22 @@ extern void InitMetroTRK();
 u16 Pad3Button : PAD3_BUTTON_ADDR;
 static u8 Debug_BBA = 0;
 
-extern void memset(void*,int,int);
+extern void memset(void*, int, int);
 extern int main(int argc, char* argv[]);
 extern void exit(int);
 extern void __init_user(void);
 extern void OSInit(void);
 extern void DBInit(void);
 extern void OSResetSystem(BOOL reset, u32 resetCode, BOOL forceMenu);
-extern void __OSCacheInit   ( void );
+extern void __OSCacheInit(void);
-extern void __OSPSInit      ( void );
+extern void __OSPSInit(void);
 
 __declspec(section ".init") extern void __check_pad3(void);
 __declspec(section ".init") extern void __start(void);
 __declspec(section ".init") extern void __init_registers(void);
 __declspec(section ".init") extern void __init_data(void);
 __declspec(section ".init") extern void __init_hardware(void);
-__declspec(section ".init") extern void __flush_cache(void *address, unsigned int size);
+__declspec(section ".init") extern void __flush_cache(void* address, unsigned int size);
 
 __declspec(section ".init") extern char _stack_addr[];
 __declspec(section ".init") extern char _SDA_BASE_[];

include/Dolphin/db.h

@@ -3,6 +3,10 @@
 
 #include "types.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 #define ExceptionHookDestination 0x80000048
 #define IsDebuggerPresent 0x80000040
 
@@ -20,4 +24,8 @@ void DBInit(void);
 void DBInitComm(int* inputFlagPtr, int* mtrCallback);
 static void __DBExceptionDestination(void);
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif

include/Dolphin/os.h

@@ -0,0 +1,31 @@
+#ifndef _DOLPHIN_OS_H
+#define _DOLPHIN_OS_H
+
+#include "types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// #ifndef ADDRESS
+// #define ADDRESS(v) __attribute__((address((v))))
+// #endif
+// const u32 __OSBusClock ADDRESS(0x800000f8);
+// const u32 __OSCoreClock ADDRESS(0x800000fc);
+// #define OS_BUS_CLOCK __OSBusClock
+// #define OS_CORE_CLOCK __OSCoreClock
+
+#define OS_BUS_CLOCK *((const u32*)0x800000f8)
+#define OS_CORE_CLOCK *((const u32*)0x800000fc)
+#define OS_TIMER_CLOCK (OS_BUS_CLOCK / 4)
+
+#define OSSecondsToTicks(v) ((v)*OS_TIMER_CLOCK)
+
+typedef s64 OSTime;
+OSTime OSGetTime();
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

include/Kyoto_CWD/CARAMManager.hpp

@@ -0,0 +1,12 @@
+#ifndef _CARAMMANAGER_HPP
+#define _CARAMMANAGER_HPP
+
+#include "types.h"
+
+class CARAMManager {
+public:
+  static void Shutdown();
+  static void CollectGarbage();
+};
+
+#endif

include/Kyoto_CWD/CARAMToken.hpp

@@ -0,0 +1,11 @@
+#ifndef _CARAMTOKEN_HPP
+#define _CARAMTOKEN_HPP
+
+#include "types.h"
+
+class CARAMToken {
+public:
+  static void UpdateAllDMAs();
+};
+
+#endif

include/Kyoto_CWD/CAiFuncMap.hpp

@@ -0,0 +1,14 @@
+#ifndef _CAIFUNCMAP_HPP
+#define _CAIFUNCMAP_HPP
+
+#include "types.h"
+
+class CAiFuncMap {
+public:
+  ~CAiFuncMap();
+
+private:
+  u8 pad[0x20];
+};
+
+#endif

include/Kyoto_CWD/CBasics.hpp

@@ -0,0 +1,10 @@
+#ifndef _CBASICS_HPP
+#define _CBASICS_HPP
+
+#include "types.h"
+
+namespace CBasics {
+char* Stringize(const char* fmt, ...);
+};
+
+#endif

include/Kyoto_CWD/CCharacterFactoryBuilder.hpp

@@ -0,0 +1,16 @@
+#ifndef _CCHARACTERFACTORYBUILDER_HPP
+#define _CCHARACTERFACTORYBUILDER_HPP
+
+#include "types.h"
+
+class CCharacterFactoryBuilder {
+public:
+  ~CCharacterFactoryBuilder();
+
+private:
+  u8 pad[0x24];
+};
+
+extern CCharacterFactoryBuilder* gpCharacterFactoryBuilder;
+
+#endif

include/Kyoto_CWD/CCubeRenderer.hpp

@@ -0,0 +1,14 @@
+#ifndef _CCUBERENDERER_HPP
+#define _CCUBERENDERER_HPP
+
+#include "types.h"
+
+class CCubeRenderer {
+public:
+  virtual void BeginScene();
+  virtual void EndScene();
+};
+
+extern CCubeRenderer* gpRender;
+
+#endif

include/Kyoto_CWD/CDvdFile.hpp

@@ -0,0 +1,14 @@
+#ifndef _CDVDFILE_HPP
+#define _CDVDFILE_HPP
+
+#include "types.h"
+
+class CDvdFile {
+public:
+  static bool FileExists(const char*);
+
+private:
+  u8 pad[0x28];
+};
+
+#endif

include/Kyoto_CWD/CFactoryMgr.hpp

@@ -0,0 +1,12 @@
+#ifndef _CFACTORYMGR_HPP
+#define _CFACTORYMGR_HPP
+
+#include "types.h"
+
+class CFactoryMgr {
+public:
+private:
+  u8 pad[0x38];
+};
+
+#endif

include/Kyoto_CWD/CGameArchitectureSupport.hpp

@@ -0,0 +1,33 @@
+#ifndef _CGAMEARCHITECTURESUPPORT_HPP
+#define _CGAMEARCHITECTURESUPPORT_HPP
+
+#include "types.h"
+
+#include "CIOWinManager.hpp"
+#include "COsContext.hpp"
+#include "CStopwatch.hpp"
+#include "TOneStatic.hpp"
+
+class CGameArchitectureSupport : public TOneStatic< CGameArchitectureSupport > {
+public:
+  CGameArchitectureSupport(COsContext&);
+  ~CGameArchitectureSupport();
+
+  void PreloadAudio();
+  bool UpdateTicks();
+  void Update();
+
+  inline CStopwatch& GetStopwatch1() { return x20_stopwatch1; }
+  inline CStopwatch& GetStopwatch2() { return x28_stopwatch2; }
+  // TODO
+  inline CIOWinManager& GetIOWinManager() { return *(CIOWinManager*)(((u8*)this) + 0x58); }
+  inline int& GetFramesDrawn() const { return *(int*)(((u8*)this) + 0x78); }
+
+private:
+  u8 pad[0x20];
+  CStopwatch x20_stopwatch1;
+  CStopwatch x28_stopwatch2;
+  u8 pad2[0xa0];
+};
+
+#endif

include/Kyoto_CWD/CGameGlobalObjects.hpp

@@ -0,0 +1,57 @@
+#ifndef _CGAMEGLOBALOBJECTS_HPP
+#define _CGAMEGLOBALOBJECTS_HPP
+
+#include "types.h"
+
+#include "rstl/optional_object.hpp"
+#include "rstl/single_ptr.hpp"
+
+#include "CAiFuncMap.hpp"
+#include "CCharacterFactoryBuilder.hpp"
+#include "CGameState.hpp"
+#include "CGraphicsSys.hpp"
+#include "CInGameTweakManager.hpp"
+#include "CMemoryCardSys.hpp"
+#include "CMemorySys.hpp"
+#include "COsContext.hpp"
+#include "CRasterFont.hpp"
+#include "CResFactory.hpp"
+#include "CSimplePool.hpp"
+#include "CToken.hpp"
+#include "TOneStatic.hpp"
+
+class CGameGlobalObjects : public TOneStatic< CGameGlobalObjects > {
+public:
+  CGameGlobalObjects(COsContext&, CMemorySys&);
+
+  void PostInitialize(COsContext&, CMemorySys&);
+
+  CGameState* GameState() { return x134_gameState.get(); }
+
+  void SetGameState(CGameState* gameState) {
+    x134_gameState = gameState;
+    gpGameState = x134_gameState.get();
+  }
+
+private:
+  rstl::single_ptr< CMemoryCardSys > x0_memoryCardSys;
+  CResFactory x4_resFactory;
+  CSimplePool xcc_simplePool;
+  CCharacterFactoryBuilder xec_characterFactoryBuilder;
+  CAiFuncMap x110_aiFuncMap;
+  CGraphicsSys x130_graphicsSys;
+  rstl::single_ptr< CGameState > x134_gameState;
+  u32 x138_;
+  rstl::optional_object< TCachedToken< unkptr > > x13c_;
+  u32 x14c_;
+  rstl::single_ptr< CInGameTweakManager > x150_inGameTweakManager;
+  TToken< CRasterFont > x154_defaultFont;
+};
+
+// TODO move to related headers
+extern unkptr gGuiSystem;
+extern unkptr gpStringTable;
+extern unkptr gpController;
+extern unkptr gpDefaultFont;
+
+#endif

include/Kyoto_CWD/CGameOptions.hpp

@@ -0,0 +1,41 @@
+#ifndef _CGAMEOPTIONS_HPP
+#define _CGAMEOPTIONS_HPP
+
+#include "types.h"
+
+#include "rstl/pair.hpp"
+#include "rstl/reserved_vector.hpp"
+#include "rstl/vector.hpp"
+
+#include "CInputStream.hpp"
+
+class CGameOptions {
+public:
+  CGameOptions();
+  CGameOptions(const CGameOptions&);
+  CGameOptions(CInputStream& in);
+  ~CGameOptions();
+  CGameOptions& operator=(const CGameOptions&);
+
+  void EnsureOptions();
+
+private:
+  rstl::reserved_vector< bool, 64 > x0_;
+  s32 x44_soundMode; // CAudioSys::ESurroundModes
+  u32 x48_screenBrightness;
+  s32 x4c_screenXOffset;
+  s32 x50_screenYOffset;
+  s32 x54_screenStretch;
+  u32 x58_sfxVol;
+  u32 x5c_musicVol;
+  u32 x60_hudAlpha;
+  u32 x64_helmetAlpha;
+  bool x68_24_hudLag : 1;
+  bool x68_25_invertY : 1;
+  bool x68_26_rumble : 1;
+  bool x68_27_swapBeamsControls : 1;
+  bool x68_28_hintSystem : 1;
+  rstl::vector< rstl::pair< int, int > > x6c_;
+};
+
+#endif

include/Kyoto_CWD/CGameState.hpp

@@ -0,0 +1,59 @@
+#ifndef _CGAMESTATE_HPP
+#define _CGAMESTATE_HPP
+
+#include "types.h"
+
+#include "rstl/rc_ptr.hpp"
+#include "rstl/reserved_vector.hpp"
+#include "rstl/vector.hpp"
+
+#include "CGameOptions.hpp"
+#include "CGameState.hpp"
+#include "CHintOptions.hpp"
+#include "CPlayerState.hpp"
+#include "CSystemOptions.hpp"
+#include "CWorldState.hpp"
+#include "CWorldTransManager.hpp"
+#include "TGameTypes.hpp"
+
+class CGameState {
+public:
+  CGameState();
+  CGameState(CInputStream& in, int saveIdx);
+  CGameState(const CGameState&);
+  ~CGameState();
+  CGameState& operator=(const CGameState&);
+
+  rstl::rc_ptr< CPlayerState >& PlayerState();
+  CSystemOptions& SystemOptions() { return xa8_systemOptions; }
+  CGameOptions& GameOptions() { return x17c_gameOptions; }
+  CHintOptions& HintOptions() { return x1f8_hintOptions; }
+  u32& SaveIdx() { return x20c_saveIdx; }
+  u64& CardSerial() { return x210_cardSerial; }
+  rstl::vector< u8 >& BackupBuf() { return x218_backupBuf; }
+
+  void SetGameOptions(CGameOptions options) {
+    x17c_gameOptions = options;
+    x17c_gameOptions.EnsureOptions();
+  }
+
+private:
+  rstl::reserved_vector< bool, 128 > x0_;
+  CAssetId x84_mlvlId;
+  rstl::vector< CWorldState > x88_worldStates;
+  rstl::rc_ptr< CPlayerState > x98_playerState;
+  rstl::rc_ptr< CWorldTransManager > x9c_transManager;
+  f64 xa0_playTime;
+  CSystemOptions xa8_systemOptions;
+  CGameOptions x17c_gameOptions;
+  CHintOptions x1f8_hintOptions;
+  u32 x20c_saveIdx;
+  u64 x210_cardSerial;
+  rstl::vector< u8 > x218_backupBuf;
+  bool x228_24_hardMode : 1;
+  bool x228_25_initPowerupsAtFirstSpawn : 1;
+};
+
+extern CGameState* gpGameState;
+
+#endif

include/Kyoto_CWD/CGraphics.hpp

@@ -0,0 +1,13 @@
+#ifndef _CGRAPHICS_HPP
+#define _CGRAPHICS_HPP
+
+#include "types.h"
+
+class CGraphics {
+public:
+  static void SetIsBeginSceneClearFb(bool);
+  static void BeginScene();
+  static void EndScene();
+};
+
+#endif

include/Kyoto_CWD/CGraphicsSys.hpp

@@ -0,0 +1,14 @@
+#ifndef _CGRAPHICSSYS_HPP
+#define _CGRAPHICSSYS_HPP
+
+#include "types.h"
+
+class CGraphicsSys {
+public:
+  ~CGraphicsSys();
+
+private:
+  u32 pad;
+};
+
+#endif

include/Kyoto_CWD/CHintOptions.hpp

@@ -0,0 +1,25 @@
+#ifndef _CHINTOPTIONS_HPP
+#define _CHINTOPTIONS_HPP
+
+#include "types.h"
+
+#include "rstl/vector.hpp"
+
+enum EHintState { kHS_Zero, kHS_Waiting, kHS_Displaying, kHS_Delayed };
+
+struct SHintState {
+  EHintState x0_state;
+  f32 x4_time;
+  bool x8_dismissed;
+};
+
+class CHintOptions {
+public:
+  void SetHintNextTime();
+
+private:
+  rstl::vector< SHintState > x0_hintStates;
+  int x10_nextHintIdx;
+};
+
+#endif

include/Kyoto_CWD/CIOWinManager.hpp

@@ -0,0 +1,20 @@
+#ifndef _CIOWINMANAGER_HPP
+#define _CIOWINMANAGER_HPP
+
+#include "types.h"
+
+#include "rstl/list.hpp"
+
+class CIOWinManager {
+public:
+  void Draw() const;
+
+  inline bool IsEmpty() const { return x4_ == 0 && x0_ == 0; }
+
+private:
+  u32 x0_;
+  u32 x4_;
+  rstl::list< unkptr > x8_;
+};
+
+#endif

include/Kyoto_CWD/CInGameTweakManager.hpp

@@ -0,0 +1,17 @@
+#ifndef _CINGAMETWEAKMANAGER_HPP
+#define _CINGAMETWEAKMANAGER_HPP
+
+#include "types.h"
+
+#include "rstl/string.hpp"
+
+class CInGameTweakManager {
+public:
+  bool ReadFromMemoryCard(const rstl::string&);
+
+private:
+};
+
+extern CInGameTweakManager* gpTweakManager;
+
+#endif

include/Kyoto_CWD/CInputStream.hpp

@@ -0,0 +1,62 @@
+#ifndef _CINPUTSTREAM_HPP
+#define _CINPUTSTREAM_HPP
+
+#include "types.h"
+
+class CInputStream;
+template < typename T >
+struct TType {};
+template < typename T >
+inline T cinput_stream_helper(TType< T > type, CInputStream& in);
+
+class CInputStream {
+public:
+  CInputStream(size_t len);
+  CInputStream(const void* ptr, size_t len, bool owned);
+  virtual ~CInputStream();
+
+  s32 ReadLong();
+  char ReadChar();
+  void ReadBytes(void* in, unsigned long len);
+  u32 ReadBits(int len);
+
+  template < typename T >
+  inline T Get() {
+    return cinput_stream_helper(TType< T >(), *this);
+  }
+
+private:
+  u32 x4_blockOffset;
+  u32 x8_blockLen;
+  u32 xc_len;
+  u8* x10_ptr;
+  bool x14_owned;
+  u32 x18_readPosition;
+  u32 x1c_bitWord;
+  u32 x20_bitOffset;
+};
+
+template <>
+inline s32 cinput_stream_helper(TType< s32 > type, CInputStream& in) {
+  return in.ReadLong();
+}
+template <>
+inline u32 cinput_stream_helper(TType< u32 > type, CInputStream& in) {
+  return in.ReadLong();
+}
+// template <>
+// inline unsigned long cinput_stream_helper(TType< unsigned long > type, CInputStream& in) {
+//   return in.ReadLong();
+// }
+
+// rstl
+#include "rstl/pair.hpp"
+template < typename L, typename R >
+inline rstl::pair< L, R > cinput_stream_helper(TType< rstl::pair< L, R > > type, CInputStream& in) {
+  rstl::pair< L, R > result;
+  result.first = in.Get< L >();
+  result.second = in.Get< R >();
+  return result;
+}
+
+#endif

include/Kyoto_CWD/CMain.hpp

@@ -0,0 +1,67 @@
+#ifndef _CMAIN_HPP
+#define _CMAIN_HPP
+
+#include "types.h"
+
+#include "rstl/reserved_vector.hpp"
+
+#include "CGameArchitectureSupport.hpp"
+#include "CGameGlobalObjects.hpp"
+#include "CInputStream.hpp"
+#include "CMemorySys.hpp"
+#include "COsContext.hpp"
+#include "CStopwatch.hpp"
+#include "CTweaks.hpp"
+#include "TReservedAverage.hpp"
+
+class CMain {
+public:
+  void UpdateStreamedAudio();
+  void RegisterResourceTweaks();
+  void ResetGameState();
+  void StreamNewGameState(CInputStream& in, int saveIdx);
+  void RefreshGameState();
+  void AddWorldPaks();
+  void EnsureWorldPaksReady();
+  void AsyncIdle(u32 time);
+  int RsMain(int argc, char** argv);
+  void InitializeSubsystems();
+  void FillInAssetIDs();
+  void ShutdownSubsystems();
+  void MemoryCardInitializePump();
+  void DoPredrawMetrics();
+  void DrawDebugMetrics(double dt, CStopwatch& stopWatch);
+  bool CheckTerminate();
+  bool CheckReset();
+
+private:
+  COsContext x0_osContext;
+  u8 x6c_unk;
+  CMemorySys x6d_memorySys;
+  CTweaks x70_tweaks;
+  u8 pad[0x7c];
+  TReservedAverage< f32, 4 > xf0_;
+  TReservedAverage< f32, 4 > x104_;
+  f32 x118_;
+  f32 x11c_;
+  f32 x120_;
+  f32 x124_;
+  CGameGlobalObjects* x128_gameGlobalObjects;
+  u32 x12c_flowState; // EFlowState
+  rstl::reserved_vector< u32, 10 > x130_frameTimes;
+  s32 x15c_frameTimeIdx;
+  bool x160_24_finished : 1;
+  bool x160_25_mfGameBuilt : 1;
+  bool x160_26_screenFading : 1;
+  bool x160_27_ : 1;
+  bool x160_28_manageCard : 1;
+  bool x160_29_ : 1;
+  bool x160_30_ : 1;
+  bool x160_31_cardBusy : 1;
+  bool x161_24_gameFrameDrawn : 1;
+  CGameArchitectureSupport* x164_;
+};
+
+extern CMain* gpMain;
+
+#endif

include/Kyoto_CWD/CMemory.hpp

@@ -0,0 +1,28 @@
+#ifndef _CMEMORY_HPP
+#define _CMEMORY_HPP
+
+#include "types.h"
+
+namespace CMemory {
+void* Alloc(unsigned long sz);
+void Free(const void* ptr);
+} // namespace CMemory
+
+void* operator new(unsigned long sz, const char*, const char*);
+void* operator new[](unsigned long sz, const char*, const char*);
+inline void* operator new(unsigned long sz) {
+  const char* fileAndLineNo = "??(??)";
+  const char* type = nullptr;
+  return operator new(sz, fileAndLineNo, type);
+}
+inline void* operator new[](unsigned long sz) {
+  const char* fileAndLineNo = "??(??)";
+  const char* type = nullptr;
+  return operator new[](sz, fileAndLineNo, type);
+}
+// placement new
+inline void* operator new(unsigned long n, void* ptr) { return ptr; };
+
+inline void operator delete(void* ptr) { CMemory::Free(ptr); }
+
+#endif

include/Kyoto_CWD/CMemoryCardSys.hpp

@@ -0,0 +1,16 @@
+#ifndef _CMEMORYCARDSYS_HPP
+#define _CMEMORYCARDSYS_HPP
+
+#include "types.h"
+
+class CMemoryCardSys {
+public:
+  ~CMemoryCardSys();
+
+private:
+  // TODO
+};
+
+extern CMemoryCardSys* gpMemoryCard;
+
+#endif

include/Kyoto_CWD/CMemoryInStream.hpp

@@ -0,0 +1,18 @@
+#ifndef _CMEMORYINSTREAM_HPP
+#define _CMEMORYINSTREAM_HPP
+
+#include "CInputStream.hpp"
+
+class CMemoryInStream : public CInputStream {
+public:
+  enum EOwnerShip {
+    NotOwned,
+    Owned,
+  };
+
+  CMemoryInStream(const void* ptr, unsigned long len);
+  CMemoryInStream(const void* ptr, unsigned long len, EOwnerShip ownership);
+  virtual ~CMemoryInStream() {}
+};
+
+#endif

include/Kyoto_CWD/CMemorySys.hpp

@@ -0,0 +1,12 @@
+#ifndef _CMEMORY_SYS_HPP
+#define _CMEMORY_SYS_HPP
+
+#include "types.h"
+
+class CMemorySys {
+public:
+private:
+  u8 x0_unk;
+};
+
+#endif

include/Kyoto_CWD/COsContext.hpp

@@ -0,0 +1,26 @@
+#ifndef _COSCONTEXT_HPP
+#define _COSCONTEXT_HPP
+
+#include "types.h"
+
+#include "gx_struct.h"
+
+class COsContext {
+public:
+private:
+  int x0_right;
+  int x4_bottom;
+  int x8_left;
+  int xc_top;
+  int x10_format;
+  int x14_consoleType;
+  void* x18_arenaLo1;
+  void* x1c_arenaHi;
+  void* x20_arenaLo2;
+  void* x24_frameBuffer1;
+  void* x28_frameBuffer2;
+  int x2c_frameBufferSize;
+  GXRenderModeObj x30_renderMode;
+};
+
+#endif

include/Kyoto_CWD/CPakFile.hpp

@@ -0,0 +1,21 @@
+#ifndef _CPAKFILE_HPP
+#define _CPAKFILE_HPP
+
+#include "types.h"
+
+#include "CDvdFile.hpp"
+
+class CPakFile : CDvdFile {
+public:
+  bool IsWorldPak() const { return x28_26_worldPak; }
+  void EnsureWorldPakReady();
+
+private:
+  bool x28_24_buildDepList : 1;
+  bool x28_25_aramFile : 1;
+  bool x28_26_worldPak : 1;
+  bool x28_27_stashedInARAM : 1;
+  // TODO
+};
+
+#endif

include/Kyoto_CWD/CPlayerState.hpp

@@ -0,0 +1,14 @@
+#ifndef _CPLAYERSTATE_HPP
+#define _CPLAYERSTATE_HPP
+
+#include "types.h"
+
+class CPlayerState {
+public:
+  void SetIsFusionEnabled(bool v);
+
+private:
+  u8 pad[0x198];
+};
+
+#endif

include/Kyoto_CWD/CRasterFont.hpp

@@ -0,0 +1,8 @@
+#ifndef _CRASTERFONT_HPP
+#define _CRASTERFONT_HPP
+
+#include "types.h"
+
+class CRasterFont;
+
+#endif

include/Kyoto_CWD/CResFactory.hpp

@@ -0,0 +1,34 @@
+#ifndef _CRESFACTORY_HPP
+#define _CRESFACTORY_HPP
+
+#include "types.h"
+
+#include "rstl/list.hpp"
+
+#include "CFactoryMgr.hpp"
+#include "CResLoader.hpp"
+
+class CResFactory {
+public:
+  virtual ~CResFactory() {}
+
+  void AsyncIdle(u32 time);
+
+  CResLoader& GetResLoader() { return x4_resLoader; }
+
+private:
+  CResLoader x4_resLoader;
+  CFactoryMgr x5c_factoryMgr;
+  u32 x94_;
+  u32 x98_;
+  u32 x9c_;
+  u32 xa0_;
+  u32 xa4_;
+  u32 xa8_;
+  u32 xac_;
+  rstl::list< void > xb0_;
+};
+
+extern CResFactory* gpResourceFactory;
+
+#endif

include/Kyoto_CWD/CResLoader.hpp

@@ -0,0 +1,38 @@
+#ifndef _CRESLOADER_HPP
+#define _CRESLOADER_HPP
+
+#include "types.h"
+
+#include "rstl/list.hpp"
+#include "rstl/string.hpp"
+
+#include "CPakFile.hpp"
+#include "TGameTypes.hpp"
+
+struct SResInfo {
+  CAssetId x0_id;
+  bool x4_compressed : 1;
+  int x4_typeIdx; // CFactoryMgr::ETypeTable
+  u32 x5_offsetDiv32 : 27;
+  u32 x7_sizeDiv32 : 27;
+};
+
+class CResLoader {
+public:
+  s32 GetPakCount();
+  CPakFile& GetPakFile(s32 idx);
+  void AddPakFileAsync(rstl::string&, bool, bool);
+  void AsyncIdlePakLoading();
+  bool AreAllPaksLoaded() const;
+
+private:
+  rstl::list< void > x0_aramList;
+  rstl::list< void > x18_pakLoadedList;
+  rstl::list< void > x30_pakLoadingList;
+  unkptr x48_curPak;
+  CAssetId x4c_cachedResId;
+  SResInfo* x50_cachedResInfo;
+  bool x54_forwardSeek;
+};
+
+#endif

include/Kyoto_CWD/CSfxManager.hpp

@@ -0,0 +1,11 @@
+#ifndef _CSFXMANAGER_HPP
+#define _CSFXMANAGER_HPP
+
+#include "types.h"
+
+class CSfxManager {
+public:
+  static void Update(float dt);
+};
+
+#endif

include/Kyoto_CWD/CSimplePool.hpp

@@ -0,0 +1,24 @@
+#ifndef _CSIMPLEPOOL_HPP
+#define _CSIMPLEPOOL_HPP
+
+#include "types.h"
+
+#include "rstl/map.hpp"
+
+#include "IObjectStore.hpp"
+
+class CSimplePool {
+public:
+  virtual ~CSimplePool() {}
+
+private:
+  u8 x4_;
+  u8 x5_;
+  rstl::map< unkptr, unkptr > x8_resources;
+  unkptr x18_factory;
+  CVParamTransfer x1c_paramXfr;
+};
+
+extern CSimplePool* gpSimplePool;
+
+#endif

include/Kyoto_CWD/CStopwatch.hpp

@@ -0,0 +1,44 @@
+#ifndef _CSTOPWATCH_HPP
+#define _CSTOPWATCH_HPP
+
+#include "types.h"
+
+#include "Dolphin/os.h"
+
+class CStopwatch {
+public:
+  class CSWData {
+  public:
+    bool Initialize();
+    void Wait(float);
+
+    s64 GetTimerFreq() const { return x0_timerFreq; }
+    s64 GetTimerFreqO1M() const { return x8_timerFreqO1M; }
+    f32 GetTimerPeriod() const { return x10_timerPeriod; }
+
+  private:
+    s64 x0_timerFreq;
+    s64 x8_timerFreqO1M;
+    f32 x10_timerPeriod;
+  };
+
+  CStopwatch() : x0_startTime(OSGetTime()) {}
+  // static inline void InitGlobalTimer() {}
+  // static inline CStopwatch& GetGlobalTimerObj() { return mGlobalTimer; }
+  inline void Reset() {
+    if (mData.GetTimerFreq() == 0) {
+      mData.Initialize();
+    }
+    x0_startTime = OSGetTime();
+  }
+  inline float GetElapsedTime() const { return (OSGetTime() - x0_startTime) * mData.GetTimerPeriod(); }
+  inline s64 GetElapsedMicros() const { return (OSGetTime() - x0_startTime) / mData.GetTimerFreqO1M(); }
+
+private:
+  static CSWData mData;
+  static CStopwatch mGlobalTimer;
+
+  s64 x0_startTime;
+};
+
+#endif

include/Kyoto_CWD/CStreamAudioManager.hpp

@@ -0,0 +1,14 @@
+#ifndef _CSTREAMAUDIOMANAGER_HPP
+#define _CSTREAMAUDIOMANAGER_HPP
+
+#include "types.h"
+
+class CStreamAudioManager {
+public:
+  static void Update(f32 dt);
+  static void StopAll();
+
+private:
+};
+
+#endif

include/Kyoto_CWD/CStringTable.hpp

@@ -0,0 +1,18 @@
+#ifndef _CSTRINGTABLE_HPP
+#define _CSTRINGTABLE_HPP
+
+#include "types.h"
+
+#include "rstl/single_ptr.hpp"
+
+#include "CInputStream.hpp"
+
+class CStringTable {
+  u32 x0_stringCount;
+  rstl::single_ptr< u8 > x4_data;
+
+public:
+  CStringTable(CInputStream& in);
+};
+
+#endif

include/Kyoto_CWD/CSystemOptions.hpp

@@ -0,0 +1,38 @@
+#ifndef _CSYSTEMOPTIONS_HPP
+#define _CSYSTEMOPTIONS_HPP
+
+#include "types.h"
+
+#include "TGameTypes.hpp"
+#include "rstl/pair.hpp"
+#include "rstl/reserved_vector.hpp"
+#include "rstl/vector.hpp"
+
+class CSystemOptions {
+public:
+  CSystemOptions();
+  CSystemOptions(const CSystemOptions&);
+  ~CSystemOptions();
+  CSystemOptions& operator=(const CSystemOptions&);
+
+  void SetHasFusion(bool v);
+  bool GetHasFusion() const { return xd0_27_fusionBeat; }
+
+private:
+  rstl::reserved_vector< u8, 98 > x0_nesState;
+  rstl::reserved_vector< bool, 64 > x68_;
+  rstl::vector< rstl::pair< CAssetId, TEditorId > > xac_cinematicStates;
+  int xbc_autoMapperKeyState;
+  int xc0_frozenFpsCount;
+  int xc4_frozenBallCount;
+  int xc8_powerBombAmmoCount;
+  int xcc_logScanPercent;
+  bool xd0_24_fusionLinked : 1;
+  bool xd0_25_normalModeBeat : 1;
+  bool xd0_26_hardModeBeat : 1;
+  bool xd0_27_fusionBeat : 1;
+  bool xd0_28_fusionSuitActive : 1;
+  bool xd0_29_allItemsCollected : 1;
+};
+
+#endif

include/Kyoto_CWD/CToken.hpp

@@ -0,0 +1,27 @@
+#ifndef _CTOKEN_HPP
+#define _CTOKEN_HPP
+
+#include "types.h"
+
+#include "IObjectStore.hpp"
+
+class CToken {
+public:
+  ~CToken();
+
+private:
+  CObjectReference* x0_objRef;
+  bool x4_lockHeld;
+};
+
+template < typename T >
+class TToken : public CToken {};
+template < typename T >
+class TCachedToken : public TToken< T > {
+private:
+  T* x8_item;
+};
+template < typename T >
+class TLockedToken : public TCachedToken< T > {};
+
+#endif

include/Kyoto_CWD/CTweakGame.hpp

@@ -0,0 +1,19 @@
+#ifndef _CTWEAKGAME_HPP
+#define _CTWEAKGAME_HPP
+
+#include "types.h"
+
+#include "rstl/string.hpp"
+
+class CTweakGame {
+public:
+  const rstl::string& GetWorldPrefix() { return x4_worldPrefix; }
+
+private:
+  u32 x0_;
+  rstl::string x4_worldPrefix;
+};
+
+extern CTweakGame* gpTweakGame;
+
+#endif

include/Kyoto_CWD/CTweaks.hpp

@@ -0,0 +1,15 @@
+#ifndef _CTWEAKS_HPP
+#define _CTWEAKS_HPP
+
+#include "types.h"
+
+class CTweaks {
+public:
+  void RegisterResourceTweaks();
+  void RegisterTweaks();
+
+private:
+  u32 x0_unk;
+};
+
+#endif

include/Kyoto_CWD/CWorldState.hpp

@@ -0,0 +1,12 @@
+#ifndef _CWORLDSTATE_HPP
+#define _CWORLDSTATE_HPP
+
+#include "types.h"
+
+class CWorldState {
+public:
+private:
+  u8 pad[0x18];
+};
+
+#endif

include/Kyoto_CWD/CWorldTransManager.hpp

@@ -0,0 +1,12 @@
+#ifndef _CWORLDTRANSMANAGER_HPP
+#define _CWORLDTRANSMANAGER_HPP
+
+#include "types.h"
+
+class CWorldTransManager {
+public:
+private:
+  u8 pad[0x48];
+};
+
+#endif

include/Kyoto_CWD/IObjectStore.hpp

@@ -0,0 +1,24 @@
+#ifndef _IOBJECTSTORE_HPP
+#define _IOBJECTSTORE_HPP
+
+#include "types.h"
+
+#include "rstl/rc_ptr.hpp"
+
+#include "TGameTypes.hpp"
+
+class IObjectStore;
+class IObj;
+class CVParamTransfer {
+  rstl::rc_ptr< void > x0_;
+};
+class CObjectReference {
+  u16 x0_refCount;
+  u16 x2_lockCount;
+  SObjectTag x4_objTag;
+  IObjectStore* xc_objectStore;
+  IObj* x10_object;
+  CVParamTransfer x14_params;
+};
+
+#endif

include/Kyoto_CWD/TGameTypes.hpp

@@ -0,0 +1,26 @@
+#ifndef _TGAMETYPES_HPP
+#define _TGAMETYPES_HPP
+
+#include "types.h"
+
+typedef s32 TAreaId;
+typedef u32 TEditorId;
+typedef u16 TUniqueId;
+
+extern TAreaId kInvalidAreaId;
+extern TEditorId kInvalidEditorId;
+extern TUniqueId kInvalidUniqueId;
+
+class CAssetId {
+public:
+  u32 id;
+};
+
+struct SObjectTag {
+  char type[4];
+  u32 id;
+};
+
+#define FourCC unsigned long
+
+#endif

include/Kyoto_CWD/TOneStatic.hpp

@@ -0,0 +1,27 @@
+#ifndef _TONESTATIC_HPP
+#define _TONESTATIC_HPP
+
+#include "types.h"
+
+template < typename T >
+class TOneStatic {
+public:
+  void* operator new(unsigned long sz, const char*, const char*); /* {
+   ReferenceCount()++;
+   return GetAllocSpace();
+ }*/
+  void* operator new(unsigned long sz) { return operator new(sz, "??(??)", nullptr); }
+  void operator delete(void* ptr) { ReferenceCount()--; }
+
+private:
+  static void* GetAllocSpace() {
+    static u8 sAllocSpace[sizeof(T)];
+    return &sAllocSpace;
+  }
+  static u32& ReferenceCount() {
+    static u32 sReferenceCount = 0;
+    return sReferenceCount;
+  }
+};
+
+#endif

include/Kyoto_CWD/TReservedAverage.hpp

@@ -0,0 +1,25 @@
+#ifndef _TRESERVEDAVERAGE_HPP
+#define _TRESERVEDAVERAGE_HPP
+
+#include "types.h"
+
+#include "rstl/optional_object.hpp"
+#include "rstl/reserved_vector.hpp"
+
+template < typename T, size_t N >
+class TReservedAverage : rstl::reserved_vector< T, N > {
+public:
+  TReservedAverage(const T& value) {
+    // resize(value, N); TODO
+  }
+  void AddValue(const T& value) {
+    push_back(value);
+    for (size_t i = size() - 1; i > 0; --i) {
+      operator[](i) = operator[](i - 1);
+    }
+    operator[](0) = value;
+  }
+  rstl::optional_object< T > GetAverage() const;
+};
+
+#endif

include/musyx/dsp_import.h

@@ -4,9 +4,12 @@
 #ifdef __cplusplus
 extern "C" {
 #endif
+
 char dspSlave[];
 short dspSlaveLength;
+
 #ifdef __cplusplus
 }
 #endif
+
 #endif

include/musyx/musyx.h

@@ -15,7 +15,6 @@ typedef struct _SynthInfo {
   u8 studios;
 } SynthInfo;
 
-
 #ifdef __cplusplus
 }
 #endif

include/rstl/construct.hpp

@@ -0,0 +1,46 @@
+#ifndef _RSTL_CONSTRUCT_HPP
+#define _RSTL_CONSTRUCT_HPP
+
+#include "types.h"
+
+namespace rstl {
+template < typename T >
+inline void construct(void* dest, const T& src) {
+  *static_cast< T* >(dest) = src;
+}
+
+template < typename T >
+inline void destroy(T* in) {
+  in->~T();
+}
+
+template < typename Iter >
+inline void destroy(Iter begin, Iter end) {
+  Iter current = begin;
+  while (current != end) {
+    current.destroy();
+    ++current;
+  }
+}
+
+template < typename Iter, typename T >
+inline void uninitialized_copy(Iter begin, Iter end, T* in) {
+  Iter current = begin;
+  while (current != end) {
+    current = *in;
+    ++current;
+  }
+}
+
+template < typename T >
+inline void uninitialized_copy_n(T* dest, size_t count, T* src) {
+  for (size_t i = 0; i < count; ++i) {
+    construct(dest, *src);
+    destroy(src);
+    ++dest;
+    ++src;
+  }
+}
+} // namespace rstl
+
+#endif

include/rstl/list.hpp

@@ -0,0 +1,37 @@
+#ifndef _RSTL_LIST_HPP
+#define _RSTL_LIST_HPP
+
+#include "types.h"
+
+#include "rmemory_allocator.hpp"
+
+namespace rstl {
+template < typename T, typename Alloc = rmemory_allocator >
+class list {
+public:
+  ~list() {
+    node* cur = x4_start;
+    while (cur != nullptr) {
+      delete cur->x8_item;
+      cur = cur->x4_next;
+    }
+  }
+
+private:
+  struct node {
+    node* x0_prev;
+    node* x4_next;
+    union {
+      T* x8_item;
+      u32 x8_count;
+    };
+  };
+
+  Alloc x0_allocator;
+  node* x4_start;
+  node* x8_end;
+  node xc_empty;
+};
+} // namespace rstl
+
+#endif

include/rstl/map.hpp

@@ -0,0 +1,15 @@
+#ifndef _RSTL_MAP_HPP
+#define _RSTL_MAP_HPP
+
+#include "types.h"
+
+#include "rmemory_allocator.hpp"
+
+namespace rstl {
+template < typename K, typename V, typename Alloc = rmemory_allocator >
+class map {
+  u8 pad[0x10];
+};
+} // namespace rstl
+
+#endif

include/rstl/optional_object.hpp

@@ -0,0 +1,29 @@
+#ifndef _RSTL_OPTIONAL_OBJECT_HPP
+#define _RSTL_OPTIONAL_OBJECT_HPP
+
+#include "types.h"
+
+#include "construct.hpp"
+
+namespace rstl {
+template < typename T >
+class optional_object {
+public:
+  optional_object() : x4_valid(false) {}
+  optional_object(const T& item) : x0_item(item), x4_valid(true) {}
+  ~optional_object() { clear(); }
+
+  T& data() { return x0_item; }
+  operator bool() const { return x4_valid; }
+  void clear() {
+    rstl::destroy(&x0_item);
+    x4_valid = false;
+  }
+
+private:
+  T x0_item;
+  bool x4_valid;
+};
+} // namespace rstl
+
+#endif

include/rstl/pair.hpp

@@ -0,0 +1,18 @@
+#ifndef _RSTL_PAIR_HPP
+#define _RSTL_PAIR_HPP
+
+#include "types.h"
+
+namespace rstl {
+template < typename L, typename R >
+class pair {
+public:
+  L first;
+  R second;
+
+  inline pair() {}
+  inline pair(const L& first, const R& second) : first(first), second(second) {}
+};
+} // namespace rstl
+
+#endif

include/rstl/pointer_iterator.hpp

@@ -0,0 +1,55 @@
+#ifndef _RSTL_POINTER_ITERATOR_HPP
+#define _RSTL_POINTER_ITERATOR_HPP
+
+#include "types.h"
+
+#include "construct.hpp"
+
+namespace rstl {
+template < typename T, typename Vec, typename Alloc >
+class const_pointer_iterator {
+protected:
+  const T* current;
+
+public:
+  const_pointer_iterator() : current(nullptr) {}
+  const_pointer_iterator(const T* begin) : current(begin) {}
+  void operator++() { ++current; }
+  void operator--() { --current; }
+  T* get_pointer() const { return const_cast< T* >(current); }
+  const T& operator*() const { return *get_pointer(); }
+  const T* operator->() const { return get_pointer(); }
+  bool CheckValid() const { return current != nullptr; }
+  bool operator==(const const_pointer_iterator& other) { return current == other.current; }
+  bool operator!=(const const_pointer_iterator& other) { return current != other.current; }
+
+  friend const_pointer_iterator operator+(const const_pointer_iterator& x, int v) { return const_pointer_iterator(x.current + v); }
+  friend const_pointer_iterator operator-(const const_pointer_iterator& x, int v) { return const_pointer_iterator(x.current - v); }
+};
+
+template < typename T, typename Vec, typename Alloc >
+class pointer_iterator : public const_pointer_iterator< T, Vec, Alloc > {
+public:
+  pointer_iterator() : const_pointer_iterator(nullptr) {}
+  pointer_iterator(T* begin) : const_pointer_iterator(begin) {}
+  void operator=(const T& other) {
+    if (CheckValid()) {
+      *get_pointer() = other;
+    }
+  }
+  T* get_pointer() const { return const_cast< T* >(current); }
+  // T* operator*() const { if (CheckValid()) return get_pointer(); else return
+  // nullptr; }
+  T* operator->() const { return get_pointer(); }
+  void destroy() const {
+    if (CheckValid()) {
+      rstl::destroy(get_pointer());
+    }
+  }
+
+  friend pointer_iterator operator+(const pointer_iterator& x, int v) { return pointer_iterator(x.get_pointer() + v); }
+  friend pointer_iterator operator-(const pointer_iterator& x, int v) { return pointer_iterator(x.get_pointer() - v); }
+};
+} // namespace rstl
+
+#endif

include/rstl/rc_ptr.hpp

@@ -0,0 +1,25 @@
+#ifndef _RSTL_RC_PTR_HPP
+#define _RSTL_RC_PTR_HPP
+
+#include "types.h"
+
+template < typename T >
+class CRefData {
+public:
+  T* x0_ptr;
+  unsigned int x4_refCount;
+};
+
+namespace rstl {
+template < typename T >
+class rc_ptr {
+  CRefData< T >* x0_refData;
+
+public:
+  ~rc_ptr();
+  T* get() { return x0_refData->x0_ptr; }
+  T* operator->() { return get(); }
+};
+} // namespace rstl
+
+#endif

include/rstl/reserved_vector.hpp

@@ -0,0 +1,51 @@
+#ifndef _RSTL_RESERVED_VECTOR_HPP
+#define _RSTL_RESERVED_VECTOR_HPP
+
+#include "types.h"
+
+#include "construct.hpp"
+#include "pointer_iterator.hpp"
+
+namespace rstl {
+template < typename T, size_t N >
+class reserved_vector {
+  size_t x0_count;
+  T x4_items[N];
+
+public:
+  typedef pointer_iterator< T, reserved_vector< T, N >, void > iterator;
+  typedef const_pointer_iterator< T, reserved_vector< T, N >, void > const_iterator;
+
+  inline iterator begin() { return iterator(x4_items); }
+  inline const_iterator begin() const { return const_iterator(x4_items); }
+  inline iterator end() { return iterator(x4_items + x0_count); }
+  inline const_iterator end() const { return const_iterator(x4_items + x0_count); }
+
+  ~reserved_vector() {
+    for (u32 i = x0_count; i > 0; --i) {
+      rstl::destroy(&x4_items[i]);
+    }
+  }
+
+  void push_back(const T& in) {
+    if (x0_count < N) {
+      iterator out = begin() + x0_count;
+      out = in;
+      ++x0_count;
+    }
+  }
+
+  inline T* data() { return x4_items; }
+  inline const T* data() const { return x4_items; }
+  inline size_t size() const { return x0_count; }
+  inline size_t capacity() const { return N; }
+  inline T& front() { return x4_items[0]; }
+  inline const T& front() const { return x4_items[0]; }
+  inline T& back() { return x4_items[x0_count - 1]; }
+  inline const T& back() const { return x4_items[x0_count - 1]; }
+  inline T& operator[](size_t idx) { return data()[idx]; }
+  inline const T& operator[](size_t idx) const { return data()[idx]; }
+};
+} // namespace rstl
+
+#endif

include/rstl/rmemory_allocator.hpp

@@ -0,0 +1,22 @@
+#ifndef _RSTL_RMEMORY_ALLOCATOR_HPP
+#define _RSTL_RMEMORY_ALLOCATOR_HPP
+
+#include "types.h"
+
+#include "../Kyoto_CWD/CMemory.hpp"
+
+namespace rstl {
+struct rmemory_allocator {
+  template < typename T >
+  static void allocate(T*& out, size_t count) {
+    out = new T[count];
+  }
+  template < typename T >
+  static void deallocate(T* ptr) {
+    if (ptr != nullptr)
+      delete ptr;
+  }
+};
+} // namespace rstl
+
+#endif

include/rstl/single_ptr.hpp

@@ -0,0 +1,24 @@
+#ifndef _RSTL_SINGLE_PTR_HPP
+#define _RSTL_SINGLE_PTR_HPP
+
+#include "types.h"
+
+namespace rstl {
+template < typename T >
+class single_ptr {
+  T* x0_ptr;
+
+public:
+  single_ptr() : x0_ptr(nullptr) {}
+  single_ptr(T* ptr) : x0_ptr(ptr) {}
+  ~single_ptr() { delete x0_ptr; }
+  T* get() { return x0_ptr; }
+  T* operator->() { return x0_ptr; }
+  void operator=(T* ptr) {
+    delete x0_ptr;
+    x0_ptr = ptr;
+  }
+};
+} // namespace rstl
+
+#endif

include/rstl/string.hpp

@@ -0,0 +1,120 @@
+#ifndef _RSTL_STRING_HPP
+#define _RSTL_STRING_HPP
+
+#include "types.h"
+
+#include "rmemory_allocator.hpp"
+
+namespace rstl {
+template < typename _CharTp >
+struct char_traits {};
+
+template < typename _CharTp, typename Traits = char_traits< _CharTp >, typename Alloc = rmemory_allocator >
+class basic_string {
+  struct COWData {
+    u32 x0_capacity;
+    u32 x4_refCount;
+    _CharTp* x8_data;
+  };
+
+  const _CharTp* x0_ptr;
+  COWData* x4_cow;
+  u32 x8_size;
+  u32 _pad; // Alloc?
+
+  // void internal_allocate(int size)
+  // {
+  //     x4_cow = reinterpret_cast<COWData*>(new u8[size * sizeof(_CharTp) +
+  //     8]); x0_ptr = x4_cow->x8_data; x4_cow->x0_capacity = u32(size);
+  //     x4_cow->x4_refCount = 1;
+  // }
+
+  void internal_dereference();
+  // {
+  //     if (x4_cow && --x4_cow->x4_refCount == 0)
+  //         delete[] x4_cow;
+  // }
+
+  static const _CharTp _EmptyString;
+
+public:
+  struct literal_t {};
+
+  basic_string() : x0_ptr(&_EmptyString), x4_cow(nullptr), x8_size(0) {}
+
+  basic_string(literal_t, const _CharTp* data);
+  // {
+  //     x0_ptr = data;
+  //     x4_cow = nullptr;
+
+  //     const _CharTp* it = data;
+  //     while (*it)
+  //         ++it;
+
+  //     x8_size = u32((it - data) / sizeof(_CharTp));
+  // }
+
+  basic_string(const basic_string& str);
+  // {
+  //     x0_ptr = str.x0_ptr;
+  //     x4_cow = str.x4_cow;
+  //     x8_size = str.x8_size;
+  //     if (x4_cow)
+  //         ++x4_cow->x4_refCount;
+  // }
+
+  basic_string(const _CharTp* data, int size, const Alloc&);
+  // {
+  //     if (size <= 0 && !data)
+  //     {
+  //         x0_ptr = &_EmptyString;
+  //         x4_cow = nullptr;
+  //         x8_size = 0;
+  //         return;
+  //     }
+
+  //     const _CharTp* it = data;
+  //     u32 len = 0;
+  //     while (*it)
+  //     {
+  //         if (size != -1 && len >= size)
+  //             break;
+  //         ++it;
+  //         ++len;
+  //     }
+
+  //     internal_allocate(len + 1);
+  //     x8_size = len;
+  //     for (int i = 0; i < len; ++i)
+  //         x4_cow->x8_data[i] = data[i];
+  //     x4_cow->x8_data[len] = 0;
+  // }
+
+  ~basic_string() { internal_dereference(); }
+
+  basic_string& operator=(const basic_string&);
+  basic_string operator+(const basic_string&);
+
+  const char* data() const { return x0_ptr; }
+};
+
+// template <>
+// const char basic_string<char>::_EmptyString = 0;
+// template <>
+// const wchar_t basic_string<wchar_t>::_EmptyString = 0;
+
+typedef basic_string< wchar_t > wstring;
+typedef basic_string< char > string;
+
+wstring wstring_l(const wchar_t* data);
+// {
+//     return wstring(wstring::literal_t(), data);
+// }
+
+string string_l(const char* data);
+// {
+//     return string(string::literal_t(), data);
+// }
+} // namespace rstl
+
+#endif

include/rstl/vector.hpp

@@ -0,0 +1,87 @@
+#ifndef _RSTL_VECTOR_HPP
+#define _RSTL_VECTOR_HPP
+
+#include "types.h"
+
+#include "pointer_iterator.hpp"
+#include "rmemory_allocator.hpp"
+
+namespace rstl {
+template < typename T, typename Alloc = rmemory_allocator >
+class vector {
+  Alloc x0_allocator;
+  size_t x4_count;
+  size_t x8_capacity;
+  T* xc_items;
+
+public:
+  typedef pointer_iterator< T, vector< T, Alloc >, Alloc > iterator;
+  typedef const_pointer_iterator< T, vector< T, Alloc >, Alloc > const_iterator;
+
+  inline iterator begin() { return iterator(xc_items); }
+  inline const_iterator begin() const { return const_iterator(xc_items); }
+  inline iterator end() { return iterator(xc_items + x4_count); }
+  inline const_iterator end() const { return const_iterator(xc_items + x4_count); }
+  inline vector() : x4_count(0), x8_capacity(0), xc_items(NULL) {}
+  inline vector(size_t count) : x4_count(0), x8_capacity(0), xc_items(0) { reserve(count); }
+  vector(const vector& other) {
+    x4_count = other.x4_count;
+    x8_capacity = other.x8_capacity;
+    if (x4_count == 0 && x8_capacity == 0) {
+      xc_items = NULL;
+    } else {
+      if (x8_capacity == 0) {
+        xc_items = NULL;
+      } else {
+        Alloc::allocate(xc_items, x8_capacity);
+      }
+      // what's going on here?
+      iterator iter;
+      const_iterator otherIter;
+      otherIter = other.begin();
+      iter = begin();
+      for (size_t i = 0; i < x4_count; ++i) {
+        iter = *otherIter;
+        ++iter;
+        ++otherIter;
+      }
+    }
+  }
+  ~vector() {
+    rstl::destroy(begin(), end());
+    Alloc::deallocate(xc_items);
+  }
+
+  void reserve(size_t size); /* {
+     if (x8_capacity >= size) return;
+     T* newData;
+     Alloc::allocate(newData, size);
+     uninitialized_copy_n(newData, x4_count, xc_items);
+     rstl::destroy(begin(), end());
+     Alloc::deallocate(xc_items);
+     xc_items = newData;
+     x8_capacity = size;
+   }*/
+  void push_back(const T& in) {
+    if (x4_count >= x8_capacity) {
+      reserve(x8_capacity != 0 ? x8_capacity * 2 : 4);
+    }
+    iterator out = begin() + x4_count;
+    out = in;
+    ++x4_count;
+  }
+
+  inline T* data() { return xc_items; }
+  inline const T* data() const { return xc_items; }
+  inline size_t size() const { return x4_count; }
+  inline size_t capacity() const { return x8_capacity; }
+  inline T& front() { return xc_items[0]; }
+  inline const T& front() const { return xc_items[0]; }
+  inline T& back() { return xc_items[x4_count - 1]; }
+  inline const T& back() const { return xc_items[x4_count - 1]; }
+  inline T& operator[](size_t idx) { return xc_items[idx]; }
+  inline const T& operator[](size_t idx) const { return xc_items[idx]; }
+};
+} // namespace rstl
+
+#endif

include/types.h

@@ -56,6 +56,9 @@ typedef void* unkptr;
 #endif
 #endif
 
+// where should these go?
+void srand(int);
+
 #ifdef __cplusplus
 }
 #endif

ldscript.ld

@@ -1,35 +0,0 @@
-ENTRY(__start)
-_SDA_BASE_ = 0x805AEBC0;
-_SDA2_BASE_ = 0x805B1D20;
-PHDRS
-{
-    init PT_LOAD;
-    text PT_LOAD;
-    extab PT_LOAD;
-    extabindex PT_LOAD;
-    ctors PT_LOAD;
-    dtors PT_LOAD;
-    rodata PT_LOAD;
-    data PT_LOAD;
-    bss PT_LOAD;
-    sdata PT_LOAD;
-    sbss PT_LOAD;
-    sdata2 PT_LOAD;
-    sbss2 PT_LOAD;
-}
-SECTIONS
-{
-    .init 0x80003100 : { *(.init) } : init
-    .text 0x80003640 : { *(.text) } : text
-    .extab 0x800035A0 : { *(.extab) } : extab
-    .extabindex 0x800035E0 : { *(.extabindex) } : extabindex
-    .ctors 0x803CB1C0 : { *(.ctors) } : ctors
-    .dtors 0x803CB380 : { *(.dtors) } : dtors
-    .rodata 0x803CB3A0 : { *(.rodata) } : rodata
-    .data 0x803D8D60 : { *(.data) } : data
-    .bss 0x803F7560c (NOLOAD) : { *(.bss) } : bss
-    .sdata 0x805A6BC0 : { *(.sdata) } : sdata
-    .sbss 0x805A8C20 (NOLOAD) : { *(.sbss) } : sbss
-    .sdata2 0x805A9D20 : { *(.sdata2) } : sdata2
-    .sbss2 0x805AF460 (NOLOAD) : { *(.sbss2) } : sbss2
-}

src/Kyoto_CWD/CSWDataDolphin.cpp

@@ -0,0 +1,21 @@
+#include "Kyoto_CWD/CStopwatch.hpp"
+
+#include "Dolphin/os.h"
+
+bool CStopwatch::CSWData::Initialize() {
+  x0_timerFreq = OS_TIMER_CLOCK;
+  x8_timerFreqO1M = x0_timerFreq / 1000000;
+  x10_timerPeriod = 1.f / x0_timerFreq;
+  return true;
+}
+
+void CStopwatch::CSWData::Wait(float v) {
+  OSTime duration = OSSecondsToTicks(v);
+  OSTime end = OSGetTime() + duration;
+  volatile OSTime current;
+  volatile s32 diff;
+  do {
+    current = OSGetTime();
+    diff = current - end;
+  } while (diff < 0);
+}

src/Kyoto_CWD/CStringTable.cpp

@@ -1,36 +1,21 @@
-#define FourCC unsigned long
+#include "Kyoto_CWD/CStringTable.hpp"
+
+#include "rstl/pair.hpp"
+#include "rstl/vector.hpp"
+
+#include "Kyoto_CWD/TGameTypes.hpp"
 
 static FourCC mCurrentLanguage = 'ENGL';
 
-class CStringTable {
+CStringTable::CStringTable(CInputStream& in)
-    u32 x0_stringCount;
+    : x0_stringCount(0), x4_data(NULL) {
-    rstl::single_ptr<u8> x4_data;
-public:
-    CStringTable(CInputStream& in);
-};
-
-template <>
-inline s32 cinput_stream_helper(TType<s32> type, CInputStream& in) { return in.ReadLong(); }
-template <>
-inline u32 cinput_stream_helper(TType<u32> type, CInputStream& in) { return in.ReadLong(); }
-template <>
-inline unsigned long cinput_stream_helper(TType<unsigned long> type, CInputStream& in) { return in.ReadLong(); }
-template <typename L, typename R>
-inline rstl::pair<L, R> cinput_stream_helper(TType<rstl::pair<L, R> > type, CInputStream& in) {
-    rstl::pair<L, R> result;
-    result.first = in.Get<L>();
-    result.second = in.Get<R>();
-    return result;
-}
-
-CStringTable::CStringTable(CInputStream& in) : x0_stringCount(0), x4_data(NULL) {
   in.ReadLong();
   in.ReadLong();
-    size_t langCount = in.Get<size_t>();
+  size_t langCount = in.Get< size_t >();
-    x0_stringCount = in.Get<u32>();
+  x0_stringCount = in.Get< u32 >();
-    rstl::vector<rstl::pair<FourCC, unsigned long> > langOffsets(langCount);
+  rstl::vector< rstl::pair< FourCC, unsigned long > > langOffsets(langCount);
   for (size_t i = 0; i < langCount; ++i) {
-        langOffsets.push_back(in.Get<rstl::pair<FourCC, unsigned long> >());
+    langOffsets.push_back(in.Get< rstl::pair< FourCC, unsigned long > >());
   }
 
   size_t offset = langOffsets.front().second;
@@ -44,7 +29,7 @@ CStringTable::CStringTable(CInputStream& in) : x0_stringCount(0), x4_data(NULL)
     in.ReadChar();
   }
 
-    u32 dataLen = in.Get<u32>();
+  u32 dataLen = in.Get< u32 >();
   x4_data = new u8[dataLen];
   in.ReadBytes(x4_data.get(), dataLen);
 }

src/musyx/dsp_import.c

@@ -3,218 +3,564 @@
 #ifdef __cplusplus
 extern "C" {
 #endif
-char dspSlave[0x19E0] =
+
-{
+char dspSlave[0x19E0] = {
-    0x00, 0x00, 0x00, 0x00, 0x02, 0x9F, 0x0C, 0x10, 0x02, 0x9F, 0x0C, 0x1F, 0x02, 0x9F, 0x0C, 0x3B, 0x02, 0x9F, 0x0C, 0x4A, 0x02, 0x9F, 0x0C, 0x50, 0x02, 0x9F, 0x0C, 0x82, 0x02, 0x9F, 0x0C, 0x88, 
+    0x00, 0x00, 0x00, 0x00, 0x02, 0x9F, 0x0C, 0x10, 0x02, 0x9F, 0x0C, 0x1F,
-    0x13, 0x02, 0x13, 0x03, 0x12, 0x04, 0x13, 0x05, 0x13, 0x06, 0x8E, 0x00, 0x8C, 0x00, 0x8B, 0x00, 0x00, 0x92, 0x00, 0xFF, 0x81, 0x00, 0x89, 0x00, 0x00, 0x9E, 0x0E, 0x80, 0x00, 0xFE, 0x0E, 0x1B, 
+    0x02, 0x9F, 0x0C, 0x3B, 0x02, 0x9F, 0x0C, 0x4A, 0x02, 0x9F, 0x0C, 0x50,
-    0x81, 0x00, 0x00, 0xFE, 0x0E, 0x31, 0x16, 0xFC, 0xDC, 0xD1, 0x16, 0xFD, 0x00, 0x00, 0x16, 0xFB, 0x00, 0x01, 0x26, 0xFC, 0x02, 0xA0, 0x80, 0x00, 0x02, 0x9C, 0x00, 0x29, 0x02, 0x9F, 0x00, 0x45, 
+    0x02, 0x9F, 0x0C, 0x82, 0x02, 0x9F, 0x0C, 0x88, 0x13, 0x02, 0x13, 0x03,
-    0x13, 0x02, 0x13, 0x03, 0x12, 0x04, 0x13, 0x05, 0x13, 0x06, 0x8E, 0x00, 0x8C, 0x00, 0x8B, 0x00, 0x00, 0x92, 0x00, 0xFF, 0x16, 0xFC, 0xDC, 0xD1, 0x16, 0xFD, 0x00, 0x01, 0x16, 0xFB, 0x00, 0x01, 
+    0x12, 0x04, 0x13, 0x05, 0x13, 0x06, 0x8E, 0x00, 0x8C, 0x00, 0x8B, 0x00,
-    0x26, 0xFC, 0x02, 0xA0, 0x80, 0x00, 0x02, 0x9C, 0x00, 0x40, 0x8E, 0x00, 0x81, 0x00, 0x89, 0x00, 0x00, 0x9F, 0xBA, 0xBE, 0x26, 0xFE, 0x02, 0xC0, 0x80, 0x00, 0x02, 0x9C, 0x00, 0x4A, 0x82, 0x00, 
+    0x00, 0x92, 0x00, 0xFF, 0x81, 0x00, 0x89, 0x00, 0x00, 0x9E, 0x0E, 0x80,
-    0x02, 0x94, 0x00, 0x4A, 0x23, 0xFF, 0x81, 0x00, 0x26, 0xFE, 0x02, 0xC0, 0x80, 0x00, 0x02, 0x9C, 0x00, 0x54, 0x27, 0xFF, 0x02, 0x40, 0x7F, 0xFF, 0x2E, 0xCE, 0x2F, 0xCF, 0x16, 0xCD, 0x0C, 0x00, 
+    0x00, 0xFE, 0x0E, 0x1B, 0x81, 0x00, 0x00, 0xFE, 0x0E, 0x31, 0x16, 0xFC,
-    0x81, 0x00, 0x2E, 0xC9, 0x1F, 0xFB, 0x2F, 0xCB, 0x02, 0xBF, 0x05, 0x5C, 0x00, 0x80, 0x0C, 0x00, 0x8E, 0x00, 0x81, 0x00, 0x89, 0x70, 0xB1, 0x00, 0x02, 0x91, 0x00, 0x7E, 0x0A, 0x12, 0xC1, 0x00, 
+    0xDC, 0xD1, 0x16, 0xFD, 0x00, 0x00, 0x16, 0xFB, 0x00, 0x01, 0x26, 0xFC,
-    0x02, 0x92, 0x00, 0x7E, 0x00, 0x9F, 0x0A, 0xFF, 0x4C, 0x00, 0x1C, 0x7E, 0x02, 0x13, 0x1C, 0x7E, 0x17, 0x6F, 0x16, 0xFC, 0xFB, 0xAD, 0x16, 0xFD, 0x80, 0x80, 0x00, 0x21, 0x16, 0xFC, 0xBA, 0xAD, 
+    0x02, 0xA0, 0x80, 0x00, 0x02, 0x9C, 0x00, 0x29, 0x02, 0x9F, 0x00, 0x45,
-    0x2E, 0xFD, 0x00, 0x21, 0x81, 0x00, 0x89, 0x70, 0x8E, 0x78, 0x2E, 0xCE, 0x2F, 0xCF, 0x00, 0x9E, 0x0E, 0x44, 0x2E, 0xCD, 0x0E, 0x00, 0x2E, 0xC9, 0x00, 0x9E, 0x00, 0x40, 0x2E, 0xCB, 0x00, 0x81, 
+    0x13, 0x02, 0x13, 0x03, 0x12, 0x04, 0x13, 0x05, 0x13, 0x06, 0x8E, 0x00,
-    0x0E, 0x44, 0x00, 0x82, 0x00, 0x00, 0x00, 0x9B, 0x00, 0x9F, 0x00, 0x9A, 0x01, 0x40, 0x81, 0x00, 0x89, 0x00, 0x8F, 0x00, 0x02, 0xBF, 0x05, 0x5C, 0x19, 0x3E, 0x19, 0x3C, 0xB1, 0x00, 0x19, 0x3F, 
+    0x8C, 0x00, 0x8B, 0x00, 0x00, 0x92, 0x00, 0xFF, 0x16, 0xFC, 0xDC, 0xD1,
-    0x02, 0x94, 0x00, 0xA6, 0x00, 0x5A, 0x1B, 0x5E, 0x02, 0x9F, 0x00, 0xAE, 0x99, 0x00, 0x1B, 0x5E, 0x1B, 0x5C, 0x00, 0x7B, 0x00, 0xAD, 0x4C, 0x00, 0x1B, 0x5E, 0x1B, 0x5C, 0x19, 0x3E, 0x19, 0x3C, 
+    0x16, 0xFD, 0x00, 0x01, 0x16, 0xFB, 0x00, 0x01, 0x26, 0xFC, 0x02, 0xA0,
-    0xB1, 0x00, 0x19, 0x3F, 0x02, 0x94, 0x00, 0xB8, 0x00, 0x5A, 0x1B, 0x5E, 0x02, 0x9F, 0x00, 0xC0, 0x99, 0x00, 0x1B, 0x5E, 0x1B, 0x5C, 0x00, 0x7B, 0x00, 0xBF, 0x4C, 0x00, 0x1B, 0x5E, 0x1B, 0x5C, 
+    0x80, 0x00, 0x02, 0x9C, 0x00, 0x40, 0x8E, 0x00, 0x81, 0x00, 0x89, 0x00,
-    0x19, 0x3E, 0x19, 0x3C, 0xB1, 0x00, 0x19, 0x3F, 0x02, 0x94, 0x00, 0xCA, 0x00, 0x5A, 0x1B, 0x5E, 0x02, 0x9F, 0x00, 0xD2, 0x99, 0x00, 0x1B, 0x5E, 0x1B, 0x5C, 0x00, 0x7B, 0x00, 0xD1, 0x4C, 0x00, 
+    0x00, 0x9F, 0xBA, 0xBE, 0x26, 0xFE, 0x02, 0xC0, 0x80, 0x00, 0x02, 0x9C,
-    0x1B, 0x5E, 0x1B, 0x5C, 0x00, 0x82, 0x04, 0x00, 0x19, 0x3E, 0x19, 0x3C, 0xB1, 0x79, 0x02, 0x94, 0x00, 0xDD, 0x00, 0x5A, 0x1B, 0x5E, 0x02, 0x9F, 0x00, 0xE5, 0x99, 0x00, 0x1B, 0x5E, 0x1B, 0x5C, 
+    0x00, 0x4A, 0x82, 0x00, 0x02, 0x94, 0x00, 0x4A, 0x23, 0xFF, 0x81, 0x00,
-    0x00, 0x7B, 0x00, 0xE4, 0x4C, 0x00, 0x1B, 0x5E, 0x1B, 0x5C, 0x19, 0x3E, 0x19, 0x3C, 0xB1, 0x79, 0x02, 0x94, 0x00, 0xEE, 0x00, 0x5A, 0x1B, 0x5E, 0x02, 0x9F, 0x00, 0xF6, 0x99, 0x00, 0x1B, 0x5E, 
+    0x26, 0xFE, 0x02, 0xC0, 0x80, 0x00, 0x02, 0x9C, 0x00, 0x54, 0x27, 0xFF,
-    0x1B, 0x5C, 0x00, 0x7B, 0x00, 0xF5, 0x4C, 0x00, 0x1B, 0x5E, 0x1B, 0x5C, 0x19, 0x3E, 0x19, 0x3C, 0xB1, 0x79, 0x02, 0x94, 0x00, 0xFF, 0x00, 0x5A, 0x1B, 0x5E, 0x02, 0x9F, 0x01, 0x07, 0x99, 0x00, 
+    0x02, 0x40, 0x7F, 0xFF, 0x2E, 0xCE, 0x2F, 0xCF, 0x16, 0xCD, 0x0C, 0x00,
-    0x1B, 0x5E, 0x1B, 0x5C, 0x00, 0x7B, 0x01, 0x06, 0x4C, 0x00, 0x1B, 0x5E, 0x1B, 0x5C, 0x00, 0x82, 0x07, 0xC0, 0x19, 0x3E, 0x19, 0x3C, 0xB1, 0x79, 0x02, 0x94, 0x01, 0x12, 0x00, 0x5A, 0x1B, 0x5E, 
+    0x81, 0x00, 0x2E, 0xC9, 0x1F, 0xFB, 0x2F, 0xCB, 0x02, 0xBF, 0x05, 0x5C,
-    0x02, 0x9F, 0x01, 0x1A, 0x99, 0x00, 0x1B, 0x5E, 0x1B, 0x5C, 0x00, 0x7B, 0x01, 0x19, 0x4C, 0x00, 0x1B, 0x5E, 0x1B, 0x5C, 0x19, 0x3E, 0x19, 0x3C, 0xB1, 0x79, 0x02, 0x94, 0x01, 0x23, 0x00, 0x5A, 
+    0x00, 0x80, 0x0C, 0x00, 0x8E, 0x00, 0x81, 0x00, 0x89, 0x70, 0xB1, 0x00,
-    0x1B, 0x5E, 0x02, 0x9F, 0x01, 0x2B, 0x99, 0x00, 0x1B, 0x5E, 0x1B, 0x5C, 0x00, 0x7B, 0x01, 0x2A, 0x4C, 0x00, 0x1B, 0x5E, 0x1B, 0x5C, 0x19, 0x3E, 0x19, 0x3C, 0xB1, 0x79, 0x02, 0x94, 0x01, 0x34, 
+    0x02, 0x91, 0x00, 0x7E, 0x0A, 0x12, 0xC1, 0x00, 0x02, 0x92, 0x00, 0x7E,
-    0x00, 0x5A, 0x1B, 0x5E, 0x02, 0x9F, 0x01, 0x3C, 0x99, 0x00, 0x1B, 0x5E, 0x1B, 0x5C, 0x00, 0x7B, 0x01, 0x3B, 0x4C, 0x00, 0x1B, 0x5E, 0x1B, 0x5C, 0x02, 0x9F, 0x00, 0x68, 0x00, 0x85, 0xFF, 0xFF, 
+    0x00, 0x9F, 0x0A, 0xFF, 0x4C, 0x00, 0x1C, 0x7E, 0x02, 0x13, 0x1C, 0x7E,
-    0x81, 0x50, 0x89, 0x40, 0x8E, 0x48, 0x00, 0xFA, 0x0E, 0x17, 0x00, 0xF8, 0x0E, 0x18, 0x00, 0x81, 0x00, 0x00, 0x02, 0xBF, 0x04, 0xF1, 0x00, 0xDA, 0x0E, 0x17, 0x00, 0xD8, 0x0E, 0x18, 0x89, 0x48, 
+    0x17, 0x6F, 0x16, 0xFC, 0xFB, 0xAD, 0x16, 0xFD, 0x80, 0x80, 0x00, 0x21,
-    0x00, 0x81, 0x04, 0x00, 0x02, 0xBF, 0x04, 0xF1, 0x00, 0xDA, 0x0E, 0x17, 0x00, 0xD8, 0x0E, 0x18, 0x89, 0x48, 0x00, 0x81, 0x07, 0xC0, 0x02, 0xBF, 0x04, 0xF1, 0x02, 0x9F, 0x00, 0x68, 0x00, 0x86, 
+    0x16, 0xFC, 0xBA, 0xAD, 0x2E, 0xFD, 0x00, 0x21, 0x81, 0x00, 0x89, 0x70,
-    0x07, 0xC0, 0x02, 0xBF, 0x04, 0x84, 0x02, 0x9F, 0x00, 0x68, 0x81, 0x00, 0x8E, 0x00, 0x19, 0x1E, 0x19, 0x1C, 0x2E, 0xCE, 0x2C, 0xCF, 0x16, 0xCD, 0x00, 0x00, 0x16, 0xC9, 0x00, 0x01, 0x16, 0xCB, 
+    0x8E, 0x78, 0x2E, 0xCE, 0x2F, 0xCF, 0x00, 0x9E, 0x0E, 0x44, 0x2E, 0xCD,
-    0x07, 0x80, 0x02, 0xBF, 0x05, 0x5C, 0x02, 0x9F, 0x00, 0x68, 0x81, 0x00, 0x89, 0x70, 0x8E, 0x60, 0x2E, 0xCE, 0x2C, 0xCF, 0x16, 0xCD, 0x0E, 0x44, 0x16, 0xC9, 0x00, 0x00, 0x89, 0x00, 0x0D, 0x20, 
+    0x0E, 0x00, 0x2E, 0xC9, 0x00, 0x9E, 0x00, 0x40, 0x2E, 0xCB, 0x00, 0x81,
-    0x2D, 0xCB, 0x4C, 0x00, 0x1C, 0x80, 0x00, 0x80, 0x02, 0x80, 0x00, 0x81, 0x00, 0x00, 0x00, 0x82, 0x01, 0x40, 0x00, 0x83, 0x0E, 0x44, 0x0A, 0x00, 0x27, 0xC9, 0x03, 0xA0, 0x00, 0x04, 0x02, 0x9C, 
+    0x0E, 0x44, 0x00, 0x82, 0x00, 0x00, 0x00, 0x9B, 0x00, 0x9F, 0x00, 0x9A,
-    0x01, 0x8C, 0x2E, 0xCE, 0x2C, 0xCF, 0x16, 0xCD, 0x0E, 0x54, 0x16, 0xC9, 0x00, 0x00, 0x16, 0xCB, 0x02, 0x60, 0x00, 0x9F, 0x00, 0xA0, 0x8F, 0x00, 0x00, 0x7F, 0x01, 0xA5, 0x19, 0x7E, 0x1B, 0x1A, 
+    0x01, 0x40, 0x81, 0x00, 0x89, 0x00, 0x8F, 0x00, 0x02, 0xBF, 0x05, 0x5C,
-    0x19, 0x7C, 0x1B, 0x1A, 0x1B, 0x5E, 0x7C, 0x22, 0x1B, 0x3E, 0x1B, 0x3C, 0x1C, 0x04, 0x02, 0x9F, 0x00, 0x68, 0x8E, 0x70, 0x89, 0x60, 0x19, 0x1F, 0x2E, 0xCE, 0x2C, 0xCF, 0x16, 0xCD, 0x0C, 0x00, 
+    0x19, 0x3E, 0x19, 0x3C, 0xB1, 0x00, 0x19, 0x3F, 0x02, 0x94, 0x00, 0xA6,
-    0x16, 0xC9, 0x00, 0x00, 0x05, 0x03, 0x03, 0x40, 0xFF, 0xF0, 0x2F, 0xCB, 0x02, 0xBF, 0x05, 0x5C, 0x00, 0x80, 0x0C, 0x00, 0x02, 0x9F, 0x00, 0x68, 0x81, 0x00, 0x89, 0x70, 0x8E, 0x78, 0x2E, 0xCE, 
+    0x00, 0x5A, 0x1B, 0x5E, 0x02, 0x9F, 0x00, 0xAE, 0x99, 0x00, 0x1B, 0x5E,
-    0x2F, 0xCF, 0x16, 0xCD, 0x0B, 0x80, 0x16, 0xC9, 0x00, 0x00, 0x16, 0xCB, 0x00, 0xC0, 0x00, 0x82, 0x0E, 0x08, 0x00, 0x9F, 0x00, 0x00, 0x1B, 0x5F, 0x00, 0x9F, 0x01, 0x40, 0x1B, 0x5F, 0x00, 0x9F, 
+    0x1B, 0x5C, 0x00, 0x7B, 0x00, 0xAD, 0x4C, 0x00, 0x1B, 0x5E, 0x1B, 0x5C,
-    0x02, 0x80, 0x1B, 0x5F, 0x00, 0x9F, 0x04, 0x00, 0x1B, 0x5F, 0x00, 0x9F, 0x05, 0x40, 0x1B, 0x5F, 0x00, 0x9F, 0x06, 0x80, 0x1B, 0x5F, 0x00, 0x9F, 0x07, 0xC0, 0x1B, 0x5F, 0x00, 0x9F, 0x09, 0x00, 
+    0x19, 0x3E, 0x19, 0x3C, 0xB1, 0x00, 0x19, 0x3F, 0x02, 0x94, 0x00, 0xB8,
-    0x1B, 0x5F, 0x00, 0x9F, 0x0A, 0x40, 0x1B, 0x5F, 0x02, 0xBF, 0x05, 0x5C, 0x00, 0xDE, 0x0B, 0xA7, 0x00, 0xDF, 0x0B, 0xA8, 0x2E, 0xCE, 0x2F, 0xCF, 0x16, 0xCD, 0x03, 0xC0, 0x16, 0xC9, 0x00, 0x00, 
+    0x00, 0x5A, 0x1B, 0x5E, 0x02, 0x9F, 0x00, 0xC0, 0x99, 0x00, 0x1B, 0x5E,
-    0x16, 0xCB, 0x00, 0x80, 0x81, 0x00, 0x89, 0x00, 0x00, 0xDE, 0x0B, 0x84, 0x00, 0x9F, 0x0B, 0x31, 0x4C, 0x00, 0x1C, 0x7E, 0x02, 0x13, 0x00, 0xFE, 0x0E, 0x15, 0x00, 0xDE, 0x0B, 0x85, 0x00, 0x9F, 
+    0x1B, 0x5C, 0x00, 0x7B, 0x00, 0xBF, 0x4C, 0x00, 0x1B, 0x5E, 0x1B, 0x5C,
-    0x0B, 0x34, 0x4C, 0x00, 0x1C, 0x7E, 0x02, 0x13, 0x00, 0xFE, 0x0E, 0x16, 0x00, 0xDE, 0x0B, 0x86, 0x00, 0x9F, 0x0B, 0x11, 0x4C, 0x00, 0x1C, 0x7E, 0x02, 0x13, 0x00, 0xFE, 0x0E, 0x14, 0x81, 0x00, 
+    0x19, 0x3E, 0x19, 0x3C, 0xB1, 0x00, 0x19, 0x3F, 0x02, 0x94, 0x00, 0xCA,
-    0x00, 0xDE, 0x0B, 0x9B, 0xB1, 0x00, 0x02, 0x95, 0x02, 0x3A, 0x89, 0x00, 0x00, 0xDF, 0x0B, 0x9E, 0x03, 0x00, 0x0C, 0xC0, 0x00, 0xFF, 0x0E, 0x40, 0x00, 0xDF, 0x0B, 0x9F, 0x03, 0x00, 0x0C, 0xC0, 
+    0x00, 0x5A, 0x1B, 0x5E, 0x02, 0x9F, 0x00, 0xD2, 0x99, 0x00, 0x1B, 0x5E,
-    0x00, 0xFF, 0x0E, 0x41, 0x00, 0x9F, 0x0C, 0xE0, 0x00, 0xFF, 0x0E, 0x42, 0x00, 0xFF, 0x0E, 0x43, 0x02, 0xBF, 0x05, 0x5C, 0x00, 0xDE, 0x0B, 0x9C, 0x2E, 0xCE, 0x00, 0xDE, 0x0B, 0x9D, 0x2E, 0xCF, 
+    0x1B, 0x5C, 0x00, 0x7B, 0x00, 0xD1, 0x4C, 0x00, 0x1B, 0x5E, 0x1B, 0x5C,
-    0x16, 0xCD, 0x0C, 0xC0, 0x16, 0xC9, 0x00, 0x00, 0x16, 0xCB, 0x00, 0x40, 0x02, 0xBF, 0x05, 0x5C, 0x02, 0x9F, 0x00, 0x68, 0x00, 0x9F, 0x0C, 0xE0, 0x00, 0xFF, 0x0E, 0x42, 0x00, 0xFF, 0x0E, 0x40, 
+    0x00, 0x82, 0x04, 0x00, 0x19, 0x3E, 0x19, 0x3C, 0xB1, 0x79, 0x02, 0x94,
-    0x00, 0xFF, 0x0E, 0x41, 0x00, 0xFF, 0x0E, 0x43, 0x02, 0xBF, 0x05, 0x5C, 0x02, 0x9F, 0x00, 0x68, 0x8E, 0x00, 0x00, 0xE0, 0x0E, 0x07, 0x00, 0x80, 0x0B, 0xA2, 0x00, 0x81, 0x03, 0xC0, 0x0E, 0x05, 
+    0x00, 0xDD, 0x00, 0x5A, 0x1B, 0x5E, 0x02, 0x9F, 0x00, 0xE5, 0x99, 0x00,
-    0x00, 0xFE, 0x0E, 0x04, 0x89, 0x00, 0x81, 0x50, 0x00, 0x9F, 0x0B, 0x80, 0x00, 0x7A, 0x02, 0x5B, 0x19, 0x3E, 0x4C, 0x49, 0x1C, 0x5E, 0x1A, 0x59, 0x00, 0x83, 0x0E, 0x05, 0x1B, 0x61, 0x1B, 0x60, 
+    0x1B, 0x5E, 0x1B, 0x5C, 0x00, 0x7B, 0x00, 0xE4, 0x4C, 0x00, 0x1B, 0x5E,
-    0x00, 0xDE, 0x0B, 0x87, 0x06, 0x01, 0x02, 0x95, 0x02, 0x67, 0x02, 0x9F, 0x03, 0x32, 0x00, 0xDE, 0x0E, 0x42, 0x00, 0xFE, 0x0E, 0x1C, 0x00, 0xC3, 0x0E, 0x15, 0x17, 0x7F, 0x8E, 0x00, 0x8A, 0x00, 
+    0x1B, 0x5C, 0x19, 0x3E, 0x19, 0x3C, 0xB1, 0x79, 0x02, 0x94, 0x00, 0xEE,
-    0x81, 0x00, 0x89, 0x00, 0x00, 0xDE, 0x0B, 0xB3, 0x00, 0xDF, 0x0B, 0xB2, 0x1F, 0x1F, 0x4D, 0x00, 0x14, 0x81, 0x8D, 0x1E, 0x1F, 0xD8, 0x00, 0x98, 0x80, 0x00, 0x00, 0x80, 0x0E, 0x44, 0xA8, 0x30, 
+    0x00, 0x5A, 0x1B, 0x5E, 0x02, 0x9F, 0x00, 0xF6, 0x99, 0x00, 0x1B, 0x5E,
-    0xAC, 0x38, 0xAD, 0x30, 0xAC, 0x38, 0xAD, 0x30, 0xAC, 0x38, 0xAD, 0x30, 0xAC, 0x38, 0xAD, 0x30, 0xAC, 0x38, 0xAD, 0x30, 0xAC, 0x38, 0xAD, 0x30, 0xAC, 0x38, 0xAD, 0x30, 0xAC, 0x38, 0xAD, 0x30, 
+    0x1B, 0x5C, 0x00, 0x7B, 0x00, 0xF5, 0x4C, 0x00, 0x1B, 0x5E, 0x1B, 0x5C,
-    0xAC, 0x38, 0xAD, 0x30, 0xAC, 0x38, 0xAD, 0x30, 0xAC, 0x38, 0xAD, 0x30, 0xAC, 0x38, 0xAD, 0x30, 0xAC, 0x38, 0xAD, 0x30, 0xAC, 0x38, 0xAD, 0x30, 0xAC, 0x38, 0xAD, 0x30, 0xAC, 0x38, 0x00, 0xFE, 
+    0x19, 0x3E, 0x19, 0x3C, 0xB1, 0x79, 0x02, 0x94, 0x00, 0xFF, 0x00, 0x5A,
-    0x0B, 0xB2, 0x8F, 0x00, 0x00, 0x80, 0x0E, 0x44, 0x00, 0xC1, 0x0E, 0x43, 0x1C, 0x61, 0x19, 0x3A, 0x19, 0x18, 0x90, 0x59, 0x19, 0x19, 0x9E, 0x51, 0x80, 0x80, 0x97, 0x59, 0x80, 0x91, 0x9E, 0x51, 
+    0x1B, 0x5E, 0x02, 0x9F, 0x01, 0x07, 0x99, 0x00, 0x1B, 0x5E, 0x1B, 0x5C,
-    0x80, 0x80, 0x97, 0x59, 0x80, 0x91, 0x9E, 0x51, 0x80, 0x80, 0x97, 0x59, 0x80, 0x91, 0x9E, 0x51, 0x80, 0x80, 0x97, 0x59, 0x80, 0x91, 0x9E, 0x51, 0x80, 0x80, 0x97, 0x59, 0x80, 0x91, 0x9E, 0x51, 
+    0x00, 0x7B, 0x01, 0x06, 0x4C, 0x00, 0x1B, 0x5E, 0x1B, 0x5C, 0x00, 0x82,
-    0x80, 0x80, 0x97, 0x59, 0x80, 0x91, 0x9E, 0x51, 0x80, 0x80, 0x97, 0x59, 0x80, 0x91, 0x9E, 0x51, 0x80, 0x80, 0x97, 0x59, 0x80, 0x91, 0x9E, 0x51, 0x80, 0x80, 0x97, 0x59, 0x80, 0x91, 0x9E, 0x51, 
+    0x07, 0xC0, 0x19, 0x3E, 0x19, 0x3C, 0xB1, 0x79, 0x02, 0x94, 0x01, 0x12,
-    0x80, 0x80, 0x97, 0x59, 0x80, 0x91, 0x9E, 0x51, 0x80, 0x80, 0x97, 0x59, 0x80, 0x91, 0x9E, 0x51, 0x80, 0x80, 0x97, 0x59, 0x80, 0x91, 0x9E, 0x51, 0x80, 0x80, 0x97, 0x59, 0x80, 0x91, 0x9E, 0x51, 
+    0x00, 0x5A, 0x1B, 0x5E, 0x02, 0x9F, 0x01, 0x1A, 0x99, 0x00, 0x1B, 0x5E,
-    0x80, 0x80, 0x97, 0x59, 0x80, 0x91, 0x9E, 0x51, 0x80, 0x80, 0x97, 0x59, 0x80, 0x91, 0x9E, 0x00, 0x6F, 0x33, 0x1B, 0x7F, 0x00, 0xC3, 0x0E, 0x14, 0x8F, 0x00, 0x8D, 0x00, 0x8A, 0x00, 0x17, 0x7F, 
+    0x1B, 0x5C, 0x00, 0x7B, 0x01, 0x19, 0x4C, 0x00, 0x1B, 0x5E, 0x1B, 0x5C,
-    0x81, 0x00, 0x00, 0xDE, 0x0B, 0x9B, 0xB1, 0x00, 0x02, 0x95, 0x03, 0x2A, 0x00, 0xDE, 0x0E, 0x42, 0x00, 0xFE, 0x0E, 0x43, 0x81, 0x00, 0x89, 0x00, 0x00, 0xDE, 0x0B, 0x9E, 0x00, 0xDF, 0x0B, 0xA0, 
+    0x19, 0x3E, 0x19, 0x3C, 0xB1, 0x79, 0x02, 0x94, 0x01, 0x23, 0x00, 0x5A,
-    0x82, 0x00, 0x02, 0x93, 0x03, 0x06, 0x78, 0x00, 0x02, 0x9F, 0x03, 0x09, 0x02, 0x95, 0x03, 0x09, 0x74, 0x00, 0x00, 0xFE, 0x0B, 0x9E, 0x00, 0xDF, 0x0E, 0x43, 0x05, 0xE0, 0x4C, 0x00, 0x00, 0xFE, 
+    0x1B, 0x5E, 0x02, 0x9F, 0x01, 0x2B, 0x99, 0x00, 0x1B, 0x5E, 0x1B, 0x5C,
-    0x0E, 0x40, 0x81, 0x00, 0x89, 0x00, 0x00, 0xDE, 0x0B, 0x9F, 0x00, 0xDF, 0x0B, 0xA1, 0x82, 0x00, 0x02, 0x93, 0x03, 0x1D, 0x78, 0x00, 0x02, 0x9F, 0x03, 0x20, 0x02, 0x95, 0x03, 0x20, 0x74, 0x00, 
+    0x00, 0x7B, 0x01, 0x2A, 0x4C, 0x00, 0x1B, 0x5E, 0x1B, 0x5C, 0x19, 0x3E,
-    0x00, 0xFE, 0x0B, 0x9F, 0x00, 0xDF, 0x0E, 0x43, 0x05, 0xE0, 0x4C, 0x00, 0x00, 0xFE, 0x0E, 0x41, 0x02, 0x9F, 0x03, 0x32, 0x00, 0xDE, 0x0E, 0x42, 0x00, 0xFE, 0x0E, 0x40, 0x00, 0xFE, 0x0E, 0x41, 
+    0x19, 0x3C, 0xB1, 0x79, 0x02, 0x94, 0x01, 0x34, 0x00, 0x5A, 0x1B, 0x5E,
-    0x00, 0xFE, 0x0E, 0x43, 0x81, 0x00, 0x8E, 0x00, 0x84, 0x00, 0x89, 0x00, 0x1E, 0xFE, 0x0E, 0x40, 0x1E, 0xBE, 0x00, 0x83, 0x0E, 0x08, 0x1C, 0x03, 0x1F, 0xF5, 0x19, 0x1A, 0xF8, 0x58, 0xFB, 0xA0, 
+    0x02, 0x9F, 0x01, 0x3C, 0x99, 0x00, 0x1B, 0x5E, 0x1B, 0x5C, 0x00, 0x7B,
-    0xF8, 0xB1, 0xFB, 0xA0, 0xF8, 0xB1, 0xFB, 0xA0, 0xF8, 0xB1, 0xFB, 0xA0, 0xF8, 0x3B, 0x1B, 0x7E, 0x00, 0x83, 0x0E, 0x04, 0x81, 0x00, 0x89, 0x73, 0x19, 0x61, 0x19, 0x60, 0x78, 0x00, 0x00, 0xFE, 
+    0x01, 0x3B, 0x4C, 0x00, 0x1B, 0x5E, 0x1B, 0x5C, 0x02, 0x9F, 0x00, 0x68,
-    0x0E, 0x04, 0x02, 0x94, 0x02, 0x53, 0x8E, 0x00, 0x81, 0x00, 0x00, 0xDE, 0x0B, 0x9B, 0xB1, 0x00, 0x02, 0x95, 0x03, 0x6A, 0x00, 0xDE, 0x0B, 0x9C, 0x00, 0xDC, 0x0B, 0x9D, 0x2E, 0xCE, 0x2C, 0xCF, 
+    0x00, 0x85, 0xFF, 0xFF, 0x81, 0x50, 0x89, 0x40, 0x8E, 0x48, 0x00, 0xFA,
-    0x81, 0x00, 0x00, 0xDE, 0x0E, 0x1C, 0x2E, 0xCD, 0x16, 0xC9, 0x00, 0x01, 0x16, 0xCB, 0x00, 0x40, 0x02, 0xBF, 0x05, 0x5C, 0x81, 0x00, 0x89, 0x00, 0x00, 0xDE, 0x0B, 0x82, 0x00, 0xDF, 0x0B, 0x83, 
+    0x0E, 0x17, 0x00, 0xF8, 0x0E, 0x18, 0x00, 0x81, 0x00, 0x00, 0x02, 0xBF,
-    0x2E, 0xCE, 0x2F, 0xCF, 0x16, 0xCD, 0x0B, 0x80, 0x16, 0xC9, 0x00, 0x01, 0x16, 0xCB, 0x00, 0xC0, 0x02, 0xBF, 0x05, 0x5C, 0x81, 0x00, 0x00, 0xDE, 0x0B, 0x80, 0x00, 0xDC, 0x0B, 0x81, 0xB1, 0x00, 
+    0x04, 0xF1, 0x00, 0xDA, 0x0E, 0x17, 0x00, 0xD8, 0x0E, 0x18, 0x89, 0x48,
-    0x02, 0x94, 0x03, 0x86, 0x00, 0xC0, 0x0E, 0x07, 0x02, 0x9F, 0x00, 0x68, 0x2E, 0xCE, 0x2C, 0xCF, 0x16, 0xCD, 0x0B, 0x80, 0x16, 0xC9, 0x00, 0x00, 0x16, 0xCB, 0x00, 0xC0, 0x00, 0x82, 0x0E, 0x08, 
+    0x00, 0x81, 0x04, 0x00, 0x02, 0xBF, 0x04, 0xF1, 0x00, 0xDA, 0x0E, 0x17,
-    0x00, 0x9F, 0x00, 0x00, 0x1B, 0x5F, 0x00, 0x9F, 0x01, 0x40, 0x1B, 0x5F, 0x00, 0x9F, 0x02, 0x80, 0x1B, 0x5F, 0x00, 0x9F, 0x04, 0x00, 0x1B, 0x5F, 0x00, 0x9F, 0x05, 0x40, 0x1B, 0x5F, 0x00, 0x9F, 
+    0x00, 0xD8, 0x0E, 0x18, 0x89, 0x48, 0x00, 0x81, 0x07, 0xC0, 0x02, 0xBF,
-    0x06, 0x80, 0x1B, 0x5F, 0x00, 0x9F, 0x07, 0xC0, 0x1B, 0x5F, 0x00, 0x9F, 0x09, 0x00, 0x1B, 0x5F, 0x00, 0x9F, 0x0A, 0x40, 0x1B, 0x5F, 0x02, 0xBF, 0x05, 0x5C, 0x00, 0xDE, 0x0B, 0xA7, 0x00, 0xDF, 
+    0x04, 0xF1, 0x02, 0x9F, 0x00, 0x68, 0x00, 0x86, 0x07, 0xC0, 0x02, 0xBF,
-    0x0B, 0xA8, 0x2E, 0xCE, 0x2F, 0xCF, 0x16, 0xCD, 0x03, 0xC0, 0x16, 0xC9, 0x00, 0x00, 0x16, 0xCB, 0x00, 0x80, 0x81, 0x00, 0x89, 0x00, 0x00, 0xDE, 0x0B, 0x84, 0x00, 0x9F, 0x0B, 0x31, 0x4C, 0x00, 
+    0x04, 0x84, 0x02, 0x9F, 0x00, 0x68, 0x81, 0x00, 0x8E, 0x00, 0x19, 0x1E,
-    0x1C, 0x7E, 0x02, 0x13, 0x00, 0xFE, 0x0E, 0x15, 0x00, 0xDE, 0x0B, 0x85, 0x00, 0x9F, 0x0B, 0x34, 0x4C, 0x00, 0x1C, 0x7E, 0x02, 0x13, 0x00, 0xFE, 0x0E, 0x16, 0x00, 0xDE, 0x0B, 0x86, 0x00, 0x9F, 
+    0x19, 0x1C, 0x2E, 0xCE, 0x2C, 0xCF, 0x16, 0xCD, 0x00, 0x00, 0x16, 0xC9,
-    0x0B, 0x11, 0x4C, 0x00, 0x1C, 0x7E, 0x02, 0x13, 0x00, 0xFE, 0x0E, 0x14, 0x81, 0x00, 0x00, 0xDE, 0x0B, 0x9B, 0xB1, 0x00, 0x02, 0x95, 0x04, 0x03, 0x89, 0x00, 0x00, 0xDF, 0x0B, 0x9E, 0x03, 0x00, 
+    0x00, 0x01, 0x16, 0xCB, 0x07, 0x80, 0x02, 0xBF, 0x05, 0x5C, 0x02, 0x9F,
-    0x0C, 0xC0, 0x00, 0xFF, 0x0E, 0x40, 0x00, 0xDF, 0x0B, 0x9F, 0x03, 0x00, 0x0C, 0xC0, 0x00, 0xFF, 0x0E, 0x41, 0x00, 0x9F, 0x0C, 0xE0, 0x00, 0xFF, 0x0E, 0x42, 0x00, 0xFF, 0x0E, 0x43, 0x02, 0xBF, 
+    0x00, 0x68, 0x81, 0x00, 0x89, 0x70, 0x8E, 0x60, 0x2E, 0xCE, 0x2C, 0xCF,
-    0x05, 0x5C, 0x00, 0xDE, 0x0B, 0x9C, 0x2E, 0xCE, 0x00, 0xDE, 0x0B, 0x9D, 0x2E, 0xCF, 0x16, 0xCD, 0x0C, 0xC0, 0x16, 0xC9, 0x00, 0x00, 0x16, 0xCB, 0x00, 0x40, 0x02, 0xBF, 0x05, 0x5C, 0x00, 0xC0, 
+    0x16, 0xCD, 0x0E, 0x44, 0x16, 0xC9, 0x00, 0x00, 0x89, 0x00, 0x0D, 0x20,
-    0x0E, 0x07, 0x02, 0x9F, 0x02, 0x48, 0x00, 0x9F, 0x0C, 0xE0, 0x00, 0xFF, 0x0E, 0x42, 0x00, 0xFF, 0x0E, 0x40, 0x00, 0xFF, 0x0E, 0x41, 0x00, 0xFF, 0x0E, 0x43, 0x02, 0xBF, 0x05, 0x5C, 0x00, 0xC0, 
+    0x2D, 0xCB, 0x4C, 0x00, 0x1C, 0x80, 0x00, 0x80, 0x02, 0x80, 0x00, 0x81,
-    0x0E, 0x07, 0x02, 0x9F, 0x02, 0x48, 0x8E, 0x00, 0x00, 0x86, 0x04, 0x00, 0x81, 0x00, 0x89, 0x70, 0x19, 0x1C, 0x2E, 0xCE, 0x2C, 0xCF, 0x1F, 0xC6, 0x2E, 0xCD, 0x16, 0xC9, 0x00, 0x01, 0x16, 0xCB, 
+    0x00, 0x00, 0x00, 0x82, 0x01, 0x40, 0x00, 0x83, 0x0E, 0x44, 0x0A, 0x00,
-    0x07, 0x80, 0x02, 0xBF, 0x05, 0x5C, 0x02, 0xBF, 0x04, 0x84, 0x02, 0x9F, 0x00, 0x68, 0x8E, 0x00, 0x00, 0x86, 0x07, 0xC0, 0x81, 0x00, 0x89, 0x70, 0x19, 0x1C, 0x2E, 0xCE, 0x2C, 0xCF, 0x1F, 0xC6, 
+    0x27, 0xC9, 0x03, 0xA0, 0x00, 0x04, 0x02, 0x9C, 0x01, 0x8C, 0x2E, 0xCE,
-    0x2E, 0xCD, 0x16, 0xC9, 0x00, 0x01, 0x16, 0xCB, 0x07, 0x80, 0x02, 0xBF, 0x05, 0x5C, 0x02, 0xBF, 0x04, 0x84, 0x02, 0x9F, 0x00, 0x68, 0x8C, 0x00, 0x8A, 0x00, 0x81, 0x00, 0x89, 0x70, 0x19, 0x1F, 
+    0x2C, 0xCF, 0x16, 0xCD, 0x0E, 0x54, 0x16, 0xC9, 0x00, 0x00, 0x16, 0xCB,
-    0x2E, 0xCE, 0x2F, 0xCF, 0x16, 0xCD, 0x02, 0x80, 0x16, 0xC9, 0x00, 0x01, 0x16, 0xCB, 0x02, 0x80, 0x8F, 0x50, 0x81, 0x40, 0x00, 0x81, 0x04, 0x00, 0x00, 0x83, 0x00, 0x00, 0x00, 0x82, 0x01, 0x40, 
+    0x02, 0x60, 0x00, 0x9F, 0x00, 0xA0, 0x8F, 0x00, 0x00, 0x7F, 0x01, 0xA5,
-    0x00, 0x99, 0x00, 0x80, 0x02, 0xBF, 0x05, 0x5C, 0x11, 0x05, 0x04, 0x6C, 0x1F, 0x61, 0x11, 0x20, 0x04, 0x5E, 0x89, 0x72, 0x19, 0x5C, 0xF0, 0x7B, 0x19, 0x7D, 0xF1, 0x31, 0x81, 0x39, 0x89, 0x00, 
+    0x19, 0x7E, 0x1B, 0x1A, 0x19, 0x7C, 0x1B, 0x1A, 0x1B, 0x5E, 0x7C, 0x22,
-    0x68, 0x00, 0x2E, 0xCE, 0x2C, 0xCF, 0x1F, 0xFB, 0x2F, 0xCD, 0x0F, 0x01, 0x2F, 0xC9, 0x1F, 0xF9, 0x2F, 0xCB, 0x72, 0x00, 0x1F, 0x5E, 0x1F, 0x1C, 0x81, 0x00, 0x26, 0xC9, 0x02, 0xA0, 0x00, 0x04, 
+    0x1B, 0x3E, 0x1B, 0x3C, 0x1C, 0x04, 0x02, 0x9F, 0x00, 0x68, 0x8E, 0x70,
-    0x02, 0x9C, 0x04, 0x6D, 0x02, 0x9F, 0x00, 0x68, 0x02, 0x9F, 0x00, 0x68, 0x02, 0x9F, 0x00, 0x68, 0x02, 0x9F, 0x00, 0x68, 0x16, 0xFC, 0xDC, 0xD1, 0x16, 0xFD, 0x00, 0x02, 0x16, 0xFB, 0x00, 0x01, 
+    0x89, 0x60, 0x19, 0x1F, 0x2E, 0xCE, 0x2C, 0xCF, 0x16, 0xCD, 0x0C, 0x00,
-    0x02, 0x9F, 0x0C, 0x91, 0x02, 0x9F, 0x00, 0x45, 0x8E, 0x00, 0x19, 0x1F, 0x19, 0x1D, 0x1F, 0x5F, 0x1F, 0x1D, 0x2F, 0xCE, 0x2D, 0xCF, 0x89, 0x00, 0x1F, 0xA6, 0x2D, 0xCD, 0x0E, 0x00, 0x2E, 0xC9, 
+    0x16, 0xC9, 0x00, 0x00, 0x05, 0x03, 0x03, 0x40, 0xFF, 0xF0, 0x2F, 0xCB,
-    0x81, 0x00, 0x00, 0x9C, 0x00, 0xC0, 0x2C, 0xCB, 0x1C, 0xA0, 0x00, 0x81, 0x0E, 0x44, 0x48, 0x00, 0x1B, 0x3E, 0x1B, 0x3C, 0x0B, 0x00, 0x00, 0x99, 0x00, 0x60, 0x4B, 0x00, 0x1B, 0x3D, 0x00, 0x81, 
+    0x02, 0xBF, 0x05, 0x5C, 0x00, 0x80, 0x0C, 0x00, 0x02, 0x9F, 0x00, 0x68,
-    0x0E, 0x44, 0x1C, 0x06, 0x00, 0x83, 0x00, 0x00, 0x1C, 0x43, 0x27, 0xC9, 0x03, 0xA0, 0x00, 0x04, 0x02, 0x9C, 0x04, 0xA5, 0x11, 0x09, 0x04, 0xDA, 0x8E, 0x00, 0x19, 0x3A, 0x19, 0x38, 0x69, 0x00, 
+    0x81, 0x00, 0x89, 0x70, 0x8E, 0x78, 0x2E, 0xCE, 0x2F, 0xCF, 0x16, 0xCD,
-    0x2F, 0xCE, 0x2D, 0xCF, 0x89, 0x00, 0x19, 0x3D, 0x2D, 0xCD, 0x16, 0xC9, 0x00, 0x00, 0x81, 0x00, 0x00, 0x9C, 0x00, 0xC0, 0x2C, 0xCB, 0x00, 0x81, 0x0E, 0x44, 0x48, 0x00, 0x1B, 0x3E, 0x1B, 0x3C, 
+    0x0B, 0x80, 0x16, 0xC9, 0x00, 0x00, 0x16, 0xCB, 0x00, 0xC0, 0x00, 0x82,
-    0x0B, 0x00, 0x09, 0x60, 0x4B, 0x00, 0x1B, 0x3D, 0x00, 0x81, 0x0E, 0x44, 0x8F, 0x00, 0x80, 0xF0, 0x80, 0xC0, 0x6A, 0x00, 0x48, 0x00, 0x11, 0x17, 0x04, 0xD4, 0x80, 0xF0, 0x80, 0xC0, 0x6B, 0x32, 
+    0x0E, 0x08, 0x00, 0x9F, 0x00, 0x00, 0x1B, 0x5F, 0x00, 0x9F, 0x01, 0x40,
-    0x49, 0x22, 0x80, 0xF0, 0x80, 0xC0, 0x6A, 0x3A, 0x48, 0x2A, 0x80, 0xF0, 0x80, 0xC0, 0x6B, 0x32, 0x49, 0x22, 0x1B, 0x5F, 0x1B, 0x5D, 0x80, 0xF0, 0x80, 0xC0, 0x6A, 0x00, 0x48, 0x00, 0x11, 0x17, 
+    0x1B, 0x5F, 0x00, 0x9F, 0x02, 0x80, 0x1B, 0x5F, 0x00, 0x9F, 0x04, 0x00,
-    0x04, 0xE8, 0x80, 0xF0, 0x80, 0xC0, 0x6B, 0x32, 0x49, 0x22, 0x80, 0xF0, 0x80, 0xC0, 0x6A, 0x3A, 0x48, 0x2A, 0x80, 0xF0, 0x80, 0xC0, 0x6B, 0x32, 0x49, 0x22, 0x1B, 0x5F, 0x1B, 0x5D, 0x1C, 0x05, 
+    0x1B, 0x5F, 0x00, 0x9F, 0x05, 0x40, 0x1B, 0x5F, 0x00, 0x9F, 0x06, 0x80,
-    0x02, 0xDF, 0x8E, 0x00, 0x00, 0x9B, 0x0E, 0x44, 0x00, 0x9D, 0x00, 0xC0, 0x02, 0xBF, 0x05, 0x41, 0x49, 0x00, 0x00, 0xFF, 0x0E, 0x1D, 0x00, 0xFD, 0x0E, 0x1E, 0x89, 0x00, 0x02, 0xBF, 0x05, 0x5C, 
+    0x1B, 0x5F, 0x00, 0x9F, 0x07, 0xC0, 0x1B, 0x5F, 0x00, 0x9F, 0x09, 0x00,
-    0x11, 0x04, 0x05, 0x2C, 0x00, 0xDA, 0x0E, 0x1D, 0x00, 0xD8, 0x0E, 0x1E, 0x00, 0x9B, 0x0E, 0xA4, 0x00, 0x9D, 0x00, 0xC0, 0x02, 0xBF, 0x05, 0x41, 0x49, 0x00, 0x00, 0xFF, 0x0E, 0x1D, 0x00, 0xFD, 
+    0x1B, 0x5F, 0x00, 0x9F, 0x0A, 0x40, 0x1B, 0x5F, 0x02, 0xBF, 0x05, 0x5C,
-    0x0E, 0x1E, 0x00, 0x83, 0x0E, 0x44, 0x02, 0xBF, 0x05, 0x4C, 0x89, 0x00, 0x00, 0xDA, 0x0E, 0x1D, 0x00, 0xD8, 0x0E, 0x1E, 0x00, 0x9B, 0x0E, 0x44, 0x00, 0x9D, 0x00, 0xC0, 0x02, 0xBF, 0x05, 0x41, 
+    0x00, 0xDE, 0x0B, 0xA7, 0x00, 0xDF, 0x0B, 0xA8, 0x2E, 0xCE, 0x2F, 0xCF,
-    0x49, 0x00, 0x00, 0xFF, 0x0E, 0x1D, 0x00, 0xFD, 0x0E, 0x1E, 0x00, 0x83, 0x0E, 0xA4, 0x02, 0xBF, 0x05, 0x4C, 0x00, 0x00, 0x00, 0x00, 0x8E, 0x00, 0x89, 0x00, 0x00, 0xDA, 0x0E, 0x1D, 0x00, 0xD8, 
+    0x16, 0xCD, 0x03, 0xC0, 0x16, 0xC9, 0x00, 0x00, 0x16, 0xCB, 0x00, 0x80,
-    0x0E, 0x1E, 0x00, 0x9B, 0x0E, 0xA4, 0x00, 0x9D, 0x00, 0xC0, 0x02, 0xBF, 0x05, 0x41, 0x49, 0x00, 0x00, 0x83, 0x0E, 0x44, 0x02, 0xBF, 0x05, 0x4C, 0x00, 0x83, 0x0E, 0xA4, 0x02, 0xBF, 0x05, 0x4C, 
+    0x81, 0x00, 0x89, 0x00, 0x00, 0xDE, 0x0B, 0x84, 0x00, 0x9F, 0x0B, 0x31,
-    0x02, 0xDF, 0x8E, 0x00, 0x00, 0xFA, 0xFF, 0xCE, 0x00, 0xF8, 0xFF, 0xCF, 0x00, 0xFB, 0xFF, 0xCD, 0x16, 0xC9, 0x00, 0x00, 0x2D, 0xCB, 0x02, 0xDF, 0x8F, 0x00, 0x8D, 0x00, 0x8A, 0x00, 0x19, 0x7A, 
+    0x4C, 0x00, 0x1C, 0x7E, 0x02, 0x13, 0x00, 0xFE, 0x0E, 0x15, 0x00, 0xDE,
-    0x19, 0x78, 0xA0, 0x00, 0xB6, 0x00, 0x11, 0x30, 0x05, 0x5A, 0x91, 0x79, 0x4E, 0x6D, 0x19, 0x7A, 0x4D, 0x43, 0xA0, 0x39, 0xB6, 0x29, 0x02, 0xDF, 0x26, 0xC9, 0x02, 0xA0, 0x00, 0x04, 0x02, 0x9C, 
+    0x0B, 0x85, 0x00, 0x9F, 0x0B, 0x34, 0x4C, 0x00, 0x1C, 0x7E, 0x02, 0x13,
-    0x05, 0x5C, 0x02, 0xDF, 0x26, 0xFE, 0x02, 0xC0, 0x80, 0x00, 0x02, 0x9C, 0x05, 0x62, 0x02, 0xDF, 0x26, 0xFC, 0x02, 0xA0, 0x80, 0x00, 0x02, 0x9C, 0x05, 0x68, 0x02, 0xDF, 0x26, 0xFC, 0x02, 0xA0, 
+    0x00, 0xFE, 0x0E, 0x16, 0x00, 0xDE, 0x0B, 0x86, 0x00, 0x9F, 0x0B, 0x11,
-    0x80, 0x00, 0x02, 0x9C, 0x05, 0x6E, 0x02, 0xDF, 0x81, 0x00, 0x89, 0x70, 0x8E, 0x60, 0x2E, 0xCE, 0x2C, 0xCF, 0x16, 0xCD, 0x0E, 0x44, 0x16, 0xC9, 0x00, 0x00, 0x89, 0x00, 0x0D, 0x20, 0x2D, 0xCB, 
+    0x4C, 0x00, 0x1C, 0x7E, 0x02, 0x13, 0x00, 0xFE, 0x0E, 0x14, 0x81, 0x00,
-    0x4C, 0x00, 0x1C, 0x80, 0x00, 0x80, 0x02, 0x80, 0x00, 0x81, 0x00, 0x00, 0x00, 0x82, 0x01, 0x40, 0x00, 0x83, 0x0E, 0x44, 0x0A, 0x00, 0x27, 0xC9, 0x03, 0xA0, 0x00, 0x04, 0x02, 0x9C, 0x05, 0x8B, 
+    0x00, 0xDE, 0x0B, 0x9B, 0xB1, 0x00, 0x02, 0x95, 0x02, 0x3A, 0x89, 0x00,
-    0x2E, 0xCE, 0x2C, 0xCF, 0x16, 0xCD, 0x0E, 0x54, 0x16, 0xC9, 0x00, 0x00, 0x16, 0xCB, 0x02, 0x60, 0x00, 0x9F, 0x00, 0xA0, 0x8F, 0x00, 0x00, 0x7F, 0x05, 0xA4, 0x19, 0x7E, 0x1B, 0x1A, 0x19, 0x7C, 
+    0x00, 0xDF, 0x0B, 0x9E, 0x03, 0x00, 0x0C, 0xC0, 0x00, 0xFF, 0x0E, 0x40,
-    0x1B, 0x1A, 0x1B, 0x5E, 0x1B, 0x5C, 0x1B, 0x3E, 0x1B, 0x3C, 0x1C, 0x04, 0x02, 0x9F, 0x00, 0x68, 0x00, 0x82, 0x0B, 0xB8, 0x19, 0x5E, 0x2E, 0xD1, 0x19, 0x5E, 0x2E, 0xD4, 0x19, 0x5E, 0x2E, 0xD5, 
+    0x00, 0xDF, 0x0B, 0x9F, 0x03, 0x00, 0x0C, 0xC0, 0x00, 0xFF, 0x0E, 0x41,
-    0x19, 0x5E, 0x2E, 0xD6, 0x19, 0x5E, 0x2E, 0xD7, 0x19, 0x5E, 0x2E, 0xD8, 0x19, 0x5E, 0x2E, 0xD9, 0x19, 0x5E, 0x2E, 0xA0, 0x19, 0x5E, 0x2E, 0xA1, 0x19, 0x5E, 0x2E, 0xA2, 0x19, 0x5E, 0x2E, 0xA3, 
+    0x00, 0x9F, 0x0C, 0xE0, 0x00, 0xFF, 0x0E, 0x42, 0x00, 0xFF, 0x0E, 0x43,
-    0x19, 0x5E, 0x2E, 0xA4, 0x19, 0x5E, 0x2E, 0xA5, 0x19, 0x5E, 0x2E, 0xA6, 0x19, 0x5E, 0x2E, 0xA7, 0x19, 0x5E, 0x2E, 0xA8, 0x19, 0x5E, 0x2E, 0xA9, 0x19, 0x5E, 0x2E, 0xAA, 0x19, 0x5E, 0x2E, 0xAB, 
+    0x02, 0xBF, 0x05, 0x5C, 0x00, 0xDE, 0x0B, 0x9C, 0x2E, 0xCE, 0x00, 0xDE,
-    0x19, 0x5E, 0x2E, 0xAC, 0x19, 0x5E, 0x2E, 0xAD, 0x19, 0x5E, 0x2E, 0xAE, 0x19, 0x5E, 0x2E, 0xAF, 0x19, 0x5E, 0x2E, 0xDE, 0x19, 0x5E, 0x2E, 0xDA, 0x19, 0x5E, 0x2E, 0xDB, 0x19, 0x5E, 0x2E, 0xDC, 
+    0x0B, 0x9D, 0x2E, 0xCF, 0x16, 0xCD, 0x0C, 0xC0, 0x16, 0xC9, 0x00, 0x00,
-    0x8C, 0x00, 0x8A, 0x00, 0x8E, 0x00, 0x00, 0xD8, 0x0E, 0x16, 0x19, 0x5B, 0x19, 0x59, 0x81, 0x00, 0x19, 0x5C, 0x00, 0x80, 0x0E, 0x44, 0x19, 0x5F, 0x1B, 0x1F, 0x19, 0x5F, 0x1B, 0x1F, 0x19, 0x5F, 
+    0x16, 0xCB, 0x00, 0x40, 0x02, 0xBF, 0x05, 0x5C, 0x02, 0x9F, 0x00, 0x68,
-    0x1B, 0x1F, 0x18, 0x5F, 0x1B, 0x1F, 0x6B, 0x00, 0x15, 0x05, 0x4D, 0x00, 0x15, 0x7E, 0x1C, 0x9F, 0x1C, 0xBD, 0x05, 0xE0, 0x99, 0x00, 0x7D, 0x00, 0x1C, 0xDD, 0x89, 0x00, 0x1F, 0xA5, 0x15, 0x02, 
+    0x00, 0x9F, 0x0C, 0xE0, 0x00, 0xFF, 0x0E, 0x42, 0x00, 0xFF, 0x0E, 0x40,
-    0x1C, 0xBF, 0x00, 0x9A, 0x01, 0xFC, 0x00, 0x9E, 0x0E, 0x44, 0x00, 0x81, 0xFF, 0xDD, 0x00, 0x83, 0x0D, 0x80, 0x00, 0x64, 0x06, 0x1A, 0x18, 0x27, 0x1B, 0x07, 0x4A, 0x00, 0x1F, 0xFC, 0x18, 0x27, 
+    0x00, 0xFF, 0x0E, 0x41, 0x00, 0xFF, 0x0E, 0x43, 0x02, 0xBF, 0x05, 0x5C,
-    0x1B, 0x07, 0x15, 0x79, 0x35, 0x00, 0x18, 0x27, 0x1B, 0x07, 0x41, 0x00, 0x1B, 0x7E, 0x18, 0x27, 0x1B, 0x07, 0x1B, 0x7F, 0x00, 0x00, 0x00, 0x65, 0x06, 0x20, 0x18, 0x27, 0x1B, 0x07, 0x00, 0x00, 
+    0x02, 0x9F, 0x00, 0x68, 0x8E, 0x00, 0x00, 0xE0, 0x0E, 0x07, 0x00, 0x80,
-    0x00, 0x00, 0x00, 0x07, 0x18, 0x7F, 0x00, 0x66, 0x06, 0x29, 0x4A, 0x3B, 0x1F, 0xFC, 0x15, 0x79, 0x35, 0x33, 0x41, 0x00, 0x1B, 0x7F, 0x00, 0x04, 0x18, 0x9F, 0x1A, 0xDF, 0x18, 0x9F, 0x1A, 0xDF, 
+    0x0B, 0xA2, 0x00, 0x81, 0x03, 0xC0, 0x0E, 0x05, 0x00, 0xFE, 0x0E, 0x04,
-    0x18, 0x9F, 0x1A, 0xDF, 0x18, 0x9F, 0x1A, 0xDF, 0x1A, 0xDC, 0x00, 0x82, 0x0B, 0xD2, 0x27, 0xDC, 0x1A, 0xDF, 0x27, 0xDB, 0x1A, 0xDF, 0x27, 0xDA, 0x1A, 0xDF, 0x00, 0x82, 0x0B, 0xBE, 0x27, 0xD9, 
+    0x89, 0x00, 0x81, 0x50, 0x00, 0x9F, 0x0B, 0x80, 0x00, 0x7A, 0x02, 0x5B,
-    0x1A, 0xDF, 0x27, 0xD8, 0x1A, 0xDF, 0x8F, 0x00, 0x00, 0xC1, 0x0E, 0x42, 0x00, 0x82, 0x0D, 0x80, 0x19, 0x40, 0x19, 0x43, 0x80, 0xF0, 0xB8, 0xC0, 0x11, 0x1F, 0x06, 0x54, 0xA6, 0xF0, 0xBC, 0xF0, 
+    0x19, 0x3E, 0x4C, 0x49, 0x1C, 0x5E, 0x1A, 0x59, 0x00, 0x83, 0x0E, 0x05,
-    0x19, 0x40, 0x19, 0x43, 0xBC, 0xF0, 0x4E, 0xC0, 0xB8, 0x31, 0xA6, 0xF0, 0xBC, 0xF0, 0xBC, 0x00, 0x4E, 0x00, 0x1B, 0x3E, 0x00, 0xE1, 0x0E, 0x42, 0x02, 0xDF, 0x00, 0x82, 0x0B, 0xB8, 0x19, 0x5E, 
+    0x1B, 0x61, 0x1B, 0x60, 0x00, 0xDE, 0x0B, 0x87, 0x06, 0x01, 0x02, 0x95,
-    0x2E, 0xD1, 0x19, 0x5E, 0x2E, 0xD4, 0x19, 0x5E, 0x2E, 0xD5, 0x19, 0x5E, 0x2E, 0xD6, 0x19, 0x5E, 0x2E, 0xD7, 0x19, 0x5E, 0x2E, 0xD8, 0x19, 0x5E, 0x2E, 0xD9, 0x19, 0x5E, 0x2E, 0xA0, 0x19, 0x5E, 
+    0x02, 0x67, 0x02, 0x9F, 0x03, 0x32, 0x00, 0xDE, 0x0E, 0x42, 0x00, 0xFE,
-    0x2E, 0xA1, 0x19, 0x5E, 0x2E, 0xA2, 0x19, 0x5E, 0x2E, 0xA3, 0x19, 0x5E, 0x2E, 0xA4, 0x19, 0x5E, 0x2E, 0xA5, 0x19, 0x5E, 0x2E, 0xA6, 0x19, 0x5E, 0x2E, 0xA7, 0x19, 0x5E, 0x2E, 0xA8, 0x19, 0x5E, 
+    0x0E, 0x1C, 0x00, 0xC3, 0x0E, 0x15, 0x17, 0x7F, 0x8E, 0x00, 0x8A, 0x00,
-    0x2E, 0xA9, 0x19, 0x5E, 0x2E, 0xAA, 0x19, 0x5E, 0x2E, 0xAB, 0x19, 0x5E, 0x2E, 0xAC, 0x19, 0x5E, 0x2E, 0xAD, 0x19, 0x5E, 0x2E, 0xAE, 0x19, 0x5E, 0x2E, 0xAF, 0x19, 0x5E, 0x2E, 0xDE, 0x19, 0x5E, 
+    0x81, 0x00, 0x89, 0x00, 0x00, 0xDE, 0x0B, 0xB3, 0x00, 0xDF, 0x0B, 0xB2,
-    0x2E, 0xDA, 0x19, 0x5E, 0x2E, 0xDB, 0x19, 0x5E, 0x2E, 0xDC, 0x8C, 0x00, 0x8A, 0x00, 0x8E, 0x00, 0x19, 0x5B, 0x19, 0x59, 0x81, 0x00, 0x19, 0x5C, 0x00, 0x80, 0x0E, 0x44, 0x19, 0x5F, 0x19, 0x5F, 
+    0x1F, 0x1F, 0x4D, 0x00, 0x14, 0x81, 0x8D, 0x1E, 0x1F, 0xD8, 0x00, 0x98,
-    0x19, 0x5F, 0x1B, 0x1F, 0x18, 0x5F, 0x1B, 0x1F, 0x6B, 0x00, 0x15, 0x05, 0x4D, 0x00, 0x15, 0x7E, 0x1C, 0x9F, 0x1C, 0xBD, 0x05, 0xE0, 0x99, 0x00, 0x7D, 0x00, 0x1C, 0xDD, 0x89, 0x00, 0x1F, 0xA5, 
+    0x80, 0x00, 0x00, 0x80, 0x0E, 0x44, 0xA8, 0x30, 0xAC, 0x38, 0xAD, 0x30,
-    0x15, 0x02, 0x1C, 0xBF, 0x00, 0x9A, 0x01, 0xFC, 0x00, 0x9E, 0x0E, 0x45, 0x00, 0x81, 0xFF, 0xDD, 0x00, 0x83, 0x0D, 0x80, 0x00, 0x64, 0x06, 0xCB, 0x18, 0x27, 0x1B, 0x07, 0x4A, 0x00, 0x1B, 0x7E, 
+    0xAC, 0x38, 0xAD, 0x30, 0xAC, 0x38, 0xAD, 0x30, 0xAC, 0x38, 0xAD, 0x30,
-    0x18, 0x27, 0x1B, 0x07, 0x1B, 0x7C, 0x00, 0x00, 0x18, 0x27, 0x1B, 0x07, 0x00, 0x00, 0x00, 0x00, 0x18, 0x27, 0x1B, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x65, 0x06, 0xD1, 0x18, 0x27, 0x1B, 0x07, 
+    0xAC, 0x38, 0xAD, 0x30, 0xAC, 0x38, 0xAD, 0x30, 0xAC, 0x38, 0xAD, 0x30,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x66, 0x06, 0xD6, 0x4A, 0x00, 0x1B, 0x7E, 0x1B, 0x7C, 0x00, 0x04, 0x18, 0x9F, 0x1A, 0xDF, 0x18, 0x9F, 0x1A, 0xDF, 0x18, 0x9F, 0x1A, 0xDF, 0x18, 0x9F, 0x1A, 0xDF, 
+    0xAC, 0x38, 0xAD, 0x30, 0xAC, 0x38, 0xAD, 0x30, 0xAC, 0x38, 0xAD, 0x30,
-    0x1A, 0xDC, 0x00, 0x82, 0x0B, 0xD2, 0x27, 0xDC, 0x1A, 0xDF, 0x27, 0xDB, 0x1A, 0xDF, 0x27, 0xDA, 0x1A, 0xDF, 0x00, 0x82, 0x0B, 0xBE, 0x27, 0xD9, 0x1A, 0xDF, 0x27, 0xD8, 0x1A, 0xDF, 0x8D, 0x00, 
+    0xAC, 0x38, 0xAD, 0x30, 0xAC, 0x38, 0xAD, 0x30, 0xAC, 0x38, 0xAD, 0x30,
-    0x8B, 0x00, 0x8F, 0x00, 0x00, 0xC1, 0x0E, 0x42, 0x00, 0x82, 0x0D, 0x80, 0x81, 0x00, 0x11, 0x20, 0x07, 0x03, 0x89, 0x00, 0x19, 0x40, 0x18, 0x9E, 0x18, 0x1B, 0x19, 0x9A, 0x54, 0x00, 0x1F, 0x5E, 
+    0xAC, 0x38, 0xAD, 0x30, 0xAC, 0x38, 0xAD, 0x30, 0xAC, 0x38, 0x00, 0xFE,
-    0x19, 0x59, 0xB0, 0x00, 0xFB, 0x00, 0x81, 0x39, 0x00, 0xE1, 0x0E, 0x42, 0x02, 0xDF, 0x00, 0x82, 0x0B, 0xB8, 0x19, 0x5E, 0x2E, 0xD1, 0x19, 0x5E, 0x2E, 0xD4, 0x19, 0x5E, 0x2E, 0xD5, 0x19, 0x5E, 
+    0x0B, 0xB2, 0x8F, 0x00, 0x00, 0x80, 0x0E, 0x44, 0x00, 0xC1, 0x0E, 0x43,
-    0x2E, 0xD6, 0x19, 0x5E, 0x2E, 0xD7, 0x19, 0x5E, 0x2E, 0xD8, 0x19, 0x5E, 0x2E, 0xD9, 0x19, 0x5E, 0x2E, 0xA0, 0x19, 0x5E, 0x2E, 0xA1, 0x19, 0x5E, 0x2E, 0xA2, 0x19, 0x5E, 0x2E, 0xA3, 0x19, 0x5E, 
+    0x1C, 0x61, 0x19, 0x3A, 0x19, 0x18, 0x90, 0x59, 0x19, 0x19, 0x9E, 0x51,
-    0x2E, 0xA4, 0x19, 0x5E, 0x2E, 0xA5, 0x19, 0x5E, 0x2E, 0xA6, 0x19, 0x5E, 0x2E, 0xA7, 0x19, 0x5E, 0x2E, 0xA8, 0x19, 0x5E, 0x2E, 0xA9, 0x19, 0x5E, 0x2E, 0xAA, 0x19, 0x5E, 0x2E, 0xAB, 0x19, 0x5E, 
+    0x80, 0x80, 0x97, 0x59, 0x80, 0x91, 0x9E, 0x51, 0x80, 0x80, 0x97, 0x59,
-    0x2E, 0xAC, 0x19, 0x5E, 0x2E, 0xAD, 0x19, 0x5E, 0x2E, 0xAE, 0x19, 0x5E, 0x2E, 0xAF, 0x19, 0x5E, 0x2E, 0xDE, 0x19, 0x5E, 0x2E, 0xDA, 0x19, 0x5E, 0x2E, 0xDB, 0x19, 0x5E, 0x2E, 0xDC, 0x00, 0xC0, 
+    0x80, 0x91, 0x9E, 0x51, 0x80, 0x80, 0x97, 0x59, 0x80, 0x91, 0x9E, 0x51,
-    0x0E, 0x42, 0x00, 0x81, 0xFF, 0xDD, 0x11, 0x20, 0x07, 0x48, 0x18, 0x24, 0x1B, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, 0x0E, 0x42, 0x00, 0x82, 0x0B, 0xD9, 0x00, 0x04, 0x18, 0x9F, 0x1A, 0xDF, 
+    0x80, 0x80, 0x97, 0x59, 0x80, 0x91, 0x9E, 0x51, 0x80, 0x80, 0x97, 0x59,
-    0x18, 0x9F, 0x1A, 0xDF, 0x18, 0x9F, 0x1A, 0xDF, 0x18, 0x9F, 0x1A, 0xDF, 0x89, 0x00, 0x1A, 0xDC, 0x27, 0xDC, 0x00, 0xFF, 0x0B, 0xD2, 0x27, 0xDB, 0x00, 0xFF, 0x0B, 0xD1, 0x27, 0xDA, 0x00, 0xFF, 
+    0x80, 0x91, 0x9E, 0x51, 0x80, 0x80, 0x97, 0x59, 0x80, 0x91, 0x9E, 0x51,
-    0x0B, 0xD0, 0x27, 0xD9, 0x00, 0xFF, 0x0B, 0xBE, 0x27, 0xD8, 0x00, 0xFF, 0x0B, 0xBD, 0x02, 0xDF, 0x00, 0xC0, 0x0E, 0x40, 0x00, 0x81, 0x0B, 0x89, 0x00, 0xC2, 0x0E, 0x08, 0x1C, 0x62, 0x00, 0xC4, 
+    0x80, 0x80, 0x97, 0x59, 0x80, 0x91, 0x9E, 0x51, 0x80, 0x80, 0x97, 0x59,
-    0x0E, 0x41, 0x00, 0xC5, 0x0E, 0x09, 0x02, 0xBF, 0x80, 0xE7, 0x00, 0xF8, 0x0B, 0xA9, 0x00, 0xFB, 0x0B, 0xAC, 0x02, 0xDF, 0x00, 0xC0, 0x0E, 0x40, 0x00, 0x81, 0x0B, 0x89, 0x00, 0xC2, 0x0E, 0x08, 
+    0x80, 0x91, 0x9E, 0x51, 0x80, 0x80, 0x97, 0x59, 0x80, 0x91, 0x9E, 0x51,
-    0x1C, 0x62, 0x00, 0xC4, 0x0E, 0x41, 0x00, 0xC5, 0x0E, 0x09, 0x02, 0xBF, 0x80, 0xE7, 0x00, 0xF8, 0x0B, 0xA9, 0x00, 0xFB, 0x0B, 0xAC, 0x00, 0xC0, 0x0E, 0x40, 0x00, 0x81, 0x0B, 0x8D, 0x00, 0xC2, 
+    0x80, 0x80, 0x97, 0x59, 0x80, 0x91, 0x9E, 0x51, 0x80, 0x80, 0x97, 0x59,
-    0x0E, 0x0B, 0x1C, 0x62, 0x00, 0xC4, 0x0E, 0x41, 0x00, 0xC5, 0x0E, 0x0C, 0x02, 0xBF, 0x80, 0xE7, 0x00, 0xF8, 0x0B, 0xAA, 0x00, 0xFB, 0x0B, 0xAD, 0x02, 0xDF, 0x00, 0xC0, 0x0E, 0x40, 0x00, 0x81, 
+    0x80, 0x91, 0x9E, 0x51, 0x80, 0x80, 0x97, 0x59, 0x80, 0x91, 0x9E, 0x51,
-    0x0B, 0x89, 0x00, 0xC2, 0x0E, 0x08, 0x1C, 0x62, 0x00, 0xC4, 0x0E, 0x41, 0x00, 0xC5, 0x0E, 0x09, 0x02, 0xBF, 0x80, 0xE7, 0x00, 0xF8, 0x0B, 0xA9, 0x00, 0xFB, 0x0B, 0xAC, 0x00, 0xC0, 0x0E, 0x40, 
+    0x80, 0x80, 0x97, 0x59, 0x80, 0x91, 0x9E, 0x51, 0x80, 0x80, 0x97, 0x59,
-    0x00, 0x81, 0x0B, 0x91, 0x00, 0xC2, 0x0E, 0x0E, 0x1C, 0x62, 0x00, 0xC4, 0x0E, 0x41, 0x00, 0xC5, 0x0E, 0x0F, 0x02, 0xBF, 0x80, 0xE7, 0x00, 0xF8, 0x0B, 0xAB, 0x00, 0xFB, 0x0B, 0xAE, 0x02, 0xDF, 
+    0x80, 0x91, 0x9E, 0x51, 0x80, 0x80, 0x97, 0x59, 0x80, 0x91, 0x9E, 0x00,
-    0x00, 0xC0, 0x0E, 0x40, 0x00, 0x81, 0x0B, 0x89, 0x00, 0xC2, 0x0E, 0x08, 0x1C, 0x62, 0x00, 0xC4, 0x0E, 0x41, 0x00, 0xC5, 0x0E, 0x09, 0x02, 0xBF, 0x80, 0xE7, 0x00, 0xF8, 0x0B, 0xA9, 0x00, 0xFB, 
+    0x6F, 0x33, 0x1B, 0x7F, 0x00, 0xC3, 0x0E, 0x14, 0x8F, 0x00, 0x8D, 0x00,
-    0x0B, 0xAC, 0x00, 0xC0, 0x0E, 0x40, 0x00, 0x81, 0x0B, 0x8D, 0x00, 0xC2, 0x0E, 0x0B, 0x1C, 0x62, 0x00, 0xC4, 0x0E, 0x41, 0x00, 0xC5, 0x0E, 0x0C, 0x02, 0xBF, 0x80, 0xE7, 0x00, 0xF8, 0x0B, 0xAA, 
+    0x8A, 0x00, 0x17, 0x7F, 0x81, 0x00, 0x00, 0xDE, 0x0B, 0x9B, 0xB1, 0x00,
-    0x00, 0xFB, 0x0B, 0xAD, 0x00, 0xC0, 0x0E, 0x40, 0x00, 0x81, 0x0B, 0x91, 0x00, 0xC2, 0x0E, 0x0E, 0x1C, 0x62, 0x00, 0xC4, 0x0E, 0x41, 0x00, 0xC5, 0x0E, 0x0F, 0x02, 0xBF, 0x80, 0xE7, 0x00, 0xF8, 
+    0x02, 0x95, 0x03, 0x2A, 0x00, 0xDE, 0x0E, 0x42, 0x00, 0xFE, 0x0E, 0x43,
-    0x0B, 0xAB, 0x00, 0xFB, 0x0B, 0xAE, 0x02, 0xDF, 0x00, 0xC0, 0x0E, 0x40, 0x00, 0x81, 0x0B, 0x89, 0x00, 0xC2, 0x0E, 0x08, 0x1C, 0x62, 0x00, 0xC4, 0x0E, 0x41, 0x00, 0xC5, 0x0E, 0x09, 0x02, 0xBF, 
+    0x81, 0x00, 0x89, 0x00, 0x00, 0xDE, 0x0B, 0x9E, 0x00, 0xDF, 0x0B, 0xA0,
-    0x80, 0xE7, 0x00, 0xF8, 0x0B, 0xA9, 0x00, 0xFB, 0x0B, 0xAC, 0x00, 0xC0, 0x0E, 0x43, 0x00, 0x81, 0x0B, 0x97, 0x00, 0xC2, 0x0E, 0x0A, 0x1C, 0x62, 0x02, 0xBF, 0x81, 0xF9, 0x00, 0xF8, 0x0B, 0xAF, 
+    0x82, 0x00, 0x02, 0x93, 0x03, 0x06, 0x78, 0x00, 0x02, 0x9F, 0x03, 0x09,
-    0x02, 0xDF, 0x00, 0xC0, 0x0E, 0x40, 0x00, 0x81, 0x0B, 0x89, 0x00, 0xC2, 0x0E, 0x08, 0x1C, 0x62, 0x00, 0xC4, 0x0E, 0x41, 0x00, 0xC5, 0x0E, 0x09, 0x02, 0xBF, 0x80, 0xE7, 0x00, 0xF8, 0x0B, 0xA9, 
+    0x02, 0x95, 0x03, 0x09, 0x74, 0x00, 0x00, 0xFE, 0x0B, 0x9E, 0x00, 0xDF,
-    0x00, 0xFB, 0x0B, 0xAC, 0x00, 0xC0, 0x0E, 0x40, 0x00, 0x81, 0x0B, 0x8D, 0x00, 0xC2, 0x0E, 0x0B, 0x1C, 0x62, 0x00, 0xC4, 0x0E, 0x41, 0x00, 0xC5, 0x0E, 0x0C, 0x02, 0xBF, 0x80, 0xE7, 0x00, 0xF8, 
+    0x0E, 0x43, 0x05, 0xE0, 0x4C, 0x00, 0x00, 0xFE, 0x0E, 0x40, 0x81, 0x00,
-    0x0B, 0xAA, 0x00, 0xFB, 0x0B, 0xAD, 0x00, 0xC0, 0x0E, 0x43, 0x00, 0x81, 0x0B, 0x97, 0x00, 0xC2, 0x0E, 0x0A, 0x1C, 0x62, 0x1C, 0x80, 0x00, 0xC5, 0x0E, 0x0D, 0x02, 0xBF, 0x80, 0xE7, 0x00, 0xF8, 
+    0x89, 0x00, 0x00, 0xDE, 0x0B, 0x9F, 0x00, 0xDF, 0x0B, 0xA1, 0x82, 0x00,
-    0x0B, 0xAF, 0x00, 0xFB, 0x0B, 0xB0, 0x02, 0xDF, 0x00, 0xC0, 0x0E, 0x40, 0x00, 0x81, 0x0B, 0x89, 0x00, 0xC2, 0x0E, 0x08, 0x1C, 0x62, 0x00, 0xC4, 0x0E, 0x41, 0x00, 0xC5, 0x0E, 0x09, 0x02, 0xBF, 
+    0x02, 0x93, 0x03, 0x1D, 0x78, 0x00, 0x02, 0x9F, 0x03, 0x20, 0x02, 0x95,
-    0x80, 0xE7, 0x00, 0xF8, 0x0B, 0xA9, 0x00, 0xFB, 0x0B, 0xAC, 0x00, 0xC0, 0x0E, 0x40, 0x00, 0x81, 0x0B, 0x91, 0x00, 0xC2, 0x0E, 0x0E, 0x1C, 0x62, 0x00, 0xC4, 0x0E, 0x41, 0x00, 0xC5, 0x0E, 0x0F, 
+    0x03, 0x20, 0x74, 0x00, 0x00, 0xFE, 0x0B, 0x9F, 0x00, 0xDF, 0x0E, 0x43,
-    0x02, 0xBF, 0x80, 0xE7, 0x00, 0xF8, 0x0B, 0xAB, 0x00, 0xFB, 0x0B, 0xAE, 0x00, 0xC0, 0x0E, 0x43, 0x00, 0x81, 0x0B, 0x95, 0x00, 0xC2, 0x0E, 0x10, 0x1C, 0x62, 0x1C, 0x80, 0x00, 0xC5, 0x0E, 0x0A, 
+    0x05, 0xE0, 0x4C, 0x00, 0x00, 0xFE, 0x0E, 0x41, 0x02, 0x9F, 0x03, 0x32,
-    0x02, 0xBF, 0x80, 0xE7, 0x00, 0xF8, 0x0B, 0xB1, 0x00, 0xFB, 0x0B, 0xAF, 0x02, 0xDF, 0x00, 0xC0, 0x0E, 0x40, 0x00, 0x81, 0x0B, 0x89, 0x00, 0xC2, 0x0E, 0x08, 0x1C, 0x62, 0x00, 0xC4, 0x0E, 0x41, 
+    0x00, 0xDE, 0x0E, 0x42, 0x00, 0xFE, 0x0E, 0x40, 0x00, 0xFE, 0x0E, 0x41,
-    0x00, 0xC5, 0x0E, 0x09, 0x02, 0xBF, 0x80, 0xE7, 0x00, 0xF8, 0x0B, 0xA9, 0x00, 0xFB, 0x0B, 0xAC, 0x00, 0xC0, 0x0E, 0x40, 0x00, 0x81, 0x0B, 0x8D, 0x00, 0xC2, 0x0E, 0x0B, 0x1C, 0x62, 0x00, 0xC4, 
+    0x00, 0xFE, 0x0E, 0x43, 0x81, 0x00, 0x8E, 0x00, 0x84, 0x00, 0x89, 0x00,
-    0x0E, 0x41, 0x00, 0xC5, 0x0E, 0x0C, 0x02, 0xBF, 0x80, 0xE7, 0x00, 0xF8, 0x0B, 0xAA, 0x00, 0xFB, 0x0B, 0xAD, 0x00, 0xC0, 0x0E, 0x40, 0x00, 0x81, 0x0B, 0x91, 0x00, 0xC2, 0x0E, 0x0E, 0x1C, 0x62, 
+    0x1E, 0xFE, 0x0E, 0x40, 0x1E, 0xBE, 0x00, 0x83, 0x0E, 0x08, 0x1C, 0x03,
-    0x00, 0xC4, 0x0E, 0x41, 0x00, 0xC5, 0x0E, 0x0F, 0x02, 0xBF, 0x80, 0xE7, 0x00, 0xF8, 0x0B, 0xAB, 0x00, 0xFB, 0x0B, 0xAE, 0x00, 0xC0, 0x0E, 0x43, 0x00, 0x81, 0x0B, 0x97, 0x00, 0xC2, 0x0E, 0x0A, 
+    0x1F, 0xF5, 0x19, 0x1A, 0xF8, 0x58, 0xFB, 0xA0, 0xF8, 0xB1, 0xFB, 0xA0,
-    0x1C, 0x62, 0x1C, 0x80, 0x00, 0xC5, 0x0E, 0x0D, 0x02, 0xBF, 0x80, 0xE7, 0x00, 0xF8, 0x0B, 0xAF, 0x00, 0xFB, 0x0B, 0xB0, 0x00, 0xC0, 0x0E, 0x43, 0x00, 0x81, 0x0B, 0x95, 0x00, 0xC2, 0x0E, 0x10, 
+    0xF8, 0xB1, 0xFB, 0xA0, 0xF8, 0xB1, 0xFB, 0xA0, 0xF8, 0x3B, 0x1B, 0x7E,
-    0x1C, 0x62, 0x02, 0xBF, 0x81, 0xF9, 0x00, 0xF8, 0x0B, 0xB1, 0x02, 0xDF, 0x00, 0xC0, 0x0E, 0x40, 0x00, 0x81, 0x0B, 0x89, 0x00, 0xC2, 0x0E, 0x08, 0x00, 0x83, 0x0E, 0x44, 0x00, 0xC4, 0x0E, 0x41, 
+    0x00, 0x83, 0x0E, 0x04, 0x81, 0x00, 0x89, 0x73, 0x19, 0x61, 0x19, 0x60,
-    0x00, 0xC5, 0x0E, 0x09, 0x02, 0xBF, 0x82, 0x82, 0x00, 0xF8, 0x0B, 0xA9, 0x00, 0xFB, 0x0B, 0xAC, 0x02, 0xDF, 0x00, 0xC0, 0x0E, 0x40, 0x00, 0x81, 0x0B, 0x89, 0x00, 0xC2, 0x0E, 0x08, 0x00, 0x83, 
+    0x78, 0x00, 0x00, 0xFE, 0x0E, 0x04, 0x02, 0x94, 0x02, 0x53, 0x8E, 0x00,
-    0x0E, 0x44, 0x00, 0xC4, 0x0E, 0x41, 0x00, 0xC5, 0x0E, 0x09, 0x02, 0xBF, 0x82, 0x82, 0x00, 0xF8, 0x0B, 0xA9, 0x00, 0xFB, 0x0B, 0xAC, 0x00, 0xC0, 0x0E, 0x40, 0x00, 0x81, 0x0B, 0x8D, 0x00, 0xC2, 
+    0x81, 0x00, 0x00, 0xDE, 0x0B, 0x9B, 0xB1, 0x00, 0x02, 0x95, 0x03, 0x6A,
-    0x0E, 0x0B, 0x00, 0x83, 0x0E, 0x44, 0x00, 0xC4, 0x0E, 0x41, 0x00, 0xC5, 0x0E, 0x0C, 0x02, 0xBF, 0x82, 0x82, 0x00, 0xF8, 0x0B, 0xAA, 0x00, 0xFB, 0x0B, 0xAD, 0x02, 0xDF, 0x00, 0xC0, 0x0E, 0x40, 
+    0x00, 0xDE, 0x0B, 0x9C, 0x00, 0xDC, 0x0B, 0x9D, 0x2E, 0xCE, 0x2C, 0xCF,
-    0x00, 0x81, 0x0B, 0x89, 0x00, 0xC2, 0x0E, 0x08, 0x00, 0x83, 0x0E, 0x44, 0x00, 0xC4, 0x0E, 0x41, 0x00, 0xC5, 0x0E, 0x09, 0x02, 0xBF, 0x82, 0x82, 0x00, 0xF8, 0x0B, 0xA9, 0x00, 0xFB, 0x0B, 0xAC, 
+    0x81, 0x00, 0x00, 0xDE, 0x0E, 0x1C, 0x2E, 0xCD, 0x16, 0xC9, 0x00, 0x01,
-    0x00, 0xC0, 0x0E, 0x40, 0x00, 0x81, 0x0B, 0x91, 0x00, 0xC2, 0x0E, 0x0E, 0x00, 0x83, 0x0E, 0x44, 0x00, 0xC4, 0x0E, 0x41, 0x00, 0xC5, 0x0E, 0x0F, 0x02, 0xBF, 0x82, 0x82, 0x00, 0xF8, 0x0B, 0xAB, 
+    0x16, 0xCB, 0x00, 0x40, 0x02, 0xBF, 0x05, 0x5C, 0x81, 0x00, 0x89, 0x00,
-    0x00, 0xFB, 0x0B, 0xAE, 0x02, 0xDF, 0x00, 0xC0, 0x0E, 0x40, 0x00, 0x81, 0x0B, 0x89, 0x00, 0xC2, 0x0E, 0x08, 0x00, 0x83, 0x0E, 0x44, 0x00, 0xC4, 0x0E, 0x41, 0x00, 0xC5, 0x0E, 0x09, 0x02, 0xBF, 
+    0x00, 0xDE, 0x0B, 0x82, 0x00, 0xDF, 0x0B, 0x83, 0x2E, 0xCE, 0x2F, 0xCF,
-    0x82, 0x82, 0x00, 0xF8, 0x0B, 0xA9, 0x00, 0xFB, 0x0B, 0xAC, 0x00, 0xC0, 0x0E, 0x40, 0x00, 0x81, 0x0B, 0x8D, 0x00, 0xC2, 0x0E, 0x0B, 0x00, 0x83, 0x0E, 0x44, 0x00, 0xC4, 0x0E, 0x41, 0x00, 0xC5, 
+    0x16, 0xCD, 0x0B, 0x80, 0x16, 0xC9, 0x00, 0x01, 0x16, 0xCB, 0x00, 0xC0,
-    0x0E, 0x0C, 0x02, 0xBF, 0x82, 0x82, 0x00, 0xF8, 0x0B, 0xAA, 0x00, 0xFB, 0x0B, 0xAD, 0x00, 0xC0, 0x0E, 0x40, 0x00, 0x81, 0x0B, 0x91, 0x00, 0xC2, 0x0E, 0x0E, 0x00, 0x83, 0x0E, 0x44, 0x00, 0xC4, 
+    0x02, 0xBF, 0x05, 0x5C, 0x81, 0x00, 0x00, 0xDE, 0x0B, 0x80, 0x00, 0xDC,
-    0x0E, 0x41, 0x00, 0xC5, 0x0E, 0x0F, 0x02, 0xBF, 0x82, 0x82, 0x00, 0xF8, 0x0B, 0xAB, 0x00, 0xFB, 0x0B, 0xAE, 0x02, 0xDF, 0x00, 0xC0, 0x0E, 0x40, 0x00, 0x81, 0x0B, 0x89, 0x00, 0xC2, 0x0E, 0x08, 
+    0x0B, 0x81, 0xB1, 0x00, 0x02, 0x94, 0x03, 0x86, 0x00, 0xC0, 0x0E, 0x07,
-    0x00, 0x83, 0x0E, 0x44, 0x00, 0xC4, 0x0E, 0x41, 0x00, 0xC5, 0x0E, 0x09, 0x02, 0xBF, 0x82, 0x82, 0x00, 0xF8, 0x0B, 0xA9, 0x00, 0xFB, 0x0B, 0xAC, 0x00, 0xC0, 0x0E, 0x43, 0x00, 0x81, 0x0B, 0x97, 
+    0x02, 0x9F, 0x00, 0x68, 0x2E, 0xCE, 0x2C, 0xCF, 0x16, 0xCD, 0x0B, 0x80,
-    0x00, 0xC2, 0x0E, 0x0A, 0x00, 0x83, 0x0E, 0x44, 0x02, 0xBF, 0x84, 0x5D, 0x00, 0xF8, 0x0B, 0xAF, 0x02, 0xDF, 0x00, 0xC0, 0x0E, 0x40, 0x00, 0x81, 0x0B, 0x89, 0x00, 0xC2, 0x0E, 0x08, 0x00, 0x83, 
+    0x16, 0xC9, 0x00, 0x00, 0x16, 0xCB, 0x00, 0xC0, 0x00, 0x82, 0x0E, 0x08,
-    0x0E, 0x44, 0x00, 0xC4, 0x0E, 0x41, 0x00, 0xC5, 0x0E, 0x09, 0x02, 0xBF, 0x82, 0x82, 0x00, 0xF8, 0x0B, 0xA9, 0x00, 0xFB, 0x0B, 0xAC, 0x00, 0xC0, 0x0E, 0x40, 0x00, 0x81, 0x0B, 0x8D, 0x00, 0xC2, 
+    0x00, 0x9F, 0x00, 0x00, 0x1B, 0x5F, 0x00, 0x9F, 0x01, 0x40, 0x1B, 0x5F,
-    0x0E, 0x0B, 0x00, 0x83, 0x0E, 0x44, 0x00, 0xC4, 0x0E, 0x41, 0x00, 0xC5, 0x0E, 0x0C, 0x02, 0xBF, 0x82, 0x82, 0x00, 0xF8, 0x0B, 0xAA, 0x00, 0xFB, 0x0B, 0xAD, 0x00, 0xC0, 0x0E, 0x43, 0x00, 0x81, 
+    0x00, 0x9F, 0x02, 0x80, 0x1B, 0x5F, 0x00, 0x9F, 0x04, 0x00, 0x1B, 0x5F,
-    0x0B, 0x97, 0x00, 0xC2, 0x0E, 0x0A, 0x00, 0x83, 0x0E, 0x44, 0x1C, 0x80, 0x00, 0xC5, 0x0E, 0x0D, 0x02, 0xBF, 0x82, 0x82, 0x00, 0xF8, 0x0B, 0xAF, 0x00, 0xFB, 0x0B, 0xB0, 0x02, 0xDF, 0x00, 0xC0, 
+    0x00, 0x9F, 0x05, 0x40, 0x1B, 0x5F, 0x00, 0x9F, 0x06, 0x80, 0x1B, 0x5F,
-    0x0E, 0x40, 0x00, 0x81, 0x0B, 0x89, 0x00, 0xC2, 0x0E, 0x08, 0x00, 0x83, 0x0E, 0x44, 0x00, 0xC4, 0x0E, 0x41, 0x00, 0xC5, 0x0E, 0x09, 0x02, 0xBF, 0x82, 0x82, 0x00, 0xF8, 0x0B, 0xA9, 0x00, 0xFB, 
+    0x00, 0x9F, 0x07, 0xC0, 0x1B, 0x5F, 0x00, 0x9F, 0x09, 0x00, 0x1B, 0x5F,
-    0x0B, 0xAC, 0x00, 0xC0, 0x0E, 0x40, 0x00, 0x81, 0x0B, 0x91, 0x00, 0xC2, 0x0E, 0x0E, 0x00, 0x83, 0x0E, 0x44, 0x00, 0xC4, 0x0E, 0x41, 0x00, 0xC5, 0x0E, 0x0F, 0x02, 0xBF, 0x82, 0x82, 0x00, 0xF8, 
+    0x00, 0x9F, 0x0A, 0x40, 0x1B, 0x5F, 0x02, 0xBF, 0x05, 0x5C, 0x00, 0xDE,
-    0x0B, 0xAB, 0x00, 0xFB, 0x0B, 0xAE, 0x00, 0xC0, 0x0E, 0x43, 0x00, 0x81, 0x0B, 0x95, 0x00, 0xC2, 0x0E, 0x10, 0x00, 0x83, 0x0E, 0x44, 0x1C, 0x80, 0x00, 0xC5, 0x0E, 0x0A, 0x02, 0xBF, 0x82, 0x82, 
+    0x0B, 0xA7, 0x00, 0xDF, 0x0B, 0xA8, 0x2E, 0xCE, 0x2F, 0xCF, 0x16, 0xCD,
-    0x00, 0xF8, 0x0B, 0xB1, 0x00, 0xFB, 0x0B, 0xAF, 0x02, 0xDF, 0x00, 0xC0, 0x0E, 0x40, 0x00, 0x81, 0x0B, 0x89, 0x00, 0xC2, 0x0E, 0x08, 0x00, 0x83, 0x0E, 0x44, 0x00, 0xC4, 0x0E, 0x41, 0x00, 0xC5, 
+    0x03, 0xC0, 0x16, 0xC9, 0x00, 0x00, 0x16, 0xCB, 0x00, 0x80, 0x81, 0x00,
-    0x0E, 0x09, 0x02, 0xBF, 0x82, 0x82, 0x00, 0xF8, 0x0B, 0xA9, 0x00, 0xFB, 0x0B, 0xAC, 0x00, 0xC0, 0x0E, 0x40, 0x00, 0x81, 0x0B, 0x8D, 0x00, 0xC2, 0x0E, 0x0B, 0x00, 0x83, 0x0E, 0x44, 0x00, 0xC0, 
+    0x89, 0x00, 0x00, 0xDE, 0x0B, 0x84, 0x00, 0x9F, 0x0B, 0x31, 0x4C, 0x00,
-    0x0E, 0x41, 0x00, 0xC5, 0x0E, 0x0C, 0x02, 0xBF, 0x82, 0x82, 0x00, 0xF8, 0x0B, 0xAA, 0x00, 0xFB, 0x0B, 0xAD, 0x00, 0xC0, 0x0E, 0x40, 0x00, 0x81, 0x0B, 0x91, 0x00, 0xC2, 0x0E, 0x0E, 0x00, 0x83, 
+    0x1C, 0x7E, 0x02, 0x13, 0x00, 0xFE, 0x0E, 0x15, 0x00, 0xDE, 0x0B, 0x85,
-    0x0E, 0x44, 0x00, 0xC4, 0x0E, 0x41, 0x00, 0xC5, 0x0E, 0x0F, 0x02, 0xBF, 0x82, 0x82, 0x00, 0xF8, 0x0B, 0xAB, 0x00, 0xFB, 0x0B, 0xAE, 0x00, 0xC0, 0x0E, 0x43, 0x00, 0x81, 0x0B, 0x97, 0x00, 0xC2, 
+    0x00, 0x9F, 0x0B, 0x34, 0x4C, 0x00, 0x1C, 0x7E, 0x02, 0x13, 0x00, 0xFE,
-    0x0E, 0x0A, 0x00, 0x83, 0x0E, 0x44, 0x1C, 0x80, 0x00, 0xC5, 0x0E, 0x0D, 0x02, 0xBF, 0x82, 0x82, 0x00, 0xF8, 0x0B, 0xAF, 0x00, 0xFB, 0x0B, 0xB0, 0x00, 0xC0, 0x0E, 0x43, 0x00, 0x81, 0x0B, 0x95, 
+    0x0E, 0x16, 0x00, 0xDE, 0x0B, 0x86, 0x00, 0x9F, 0x0B, 0x11, 0x4C, 0x00,
-    0x00, 0xC2, 0x0E, 0x10, 0x00, 0x83, 0x0E, 0x44, 0x02, 0xBF, 0x84, 0x5D, 0x00, 0xF8, 0x0B, 0xB1, 0x02, 0xDF, 0x00, 0xC0, 0x0E, 0x40, 0x00, 0x81, 0x0B, 0x89, 0x00, 0xC2, 0x0E, 0x08, 0x1C, 0x62, 
+    0x1C, 0x7E, 0x02, 0x13, 0x00, 0xFE, 0x0E, 0x14, 0x81, 0x00, 0x00, 0xDE,
-    0x00, 0xC4, 0x0E, 0x41, 0x00, 0xC5, 0x0E, 0x09, 0x02, 0xBF, 0x80, 0xE7, 0x00, 0xF8, 0x0B, 0xA9, 0x00, 0xFB, 0x0B, 0xAC, 0x00, 0xC0, 0x0E, 0x43, 0x00, 0x81, 0x0B, 0x91, 0x00, 0xC2, 0x0E, 0x0E, 
+    0x0B, 0x9B, 0xB1, 0x00, 0x02, 0x95, 0x04, 0x03, 0x89, 0x00, 0x00, 0xDF,
-    0x1C, 0x62, 0x1C, 0x80, 0x00, 0xC5, 0x0E, 0x0F, 0x02, 0xBF, 0x80, 0xE7, 0x00, 0xF8, 0x0B, 0xAB, 0x00, 0xFB, 0x0B, 0xAE, 0x02, 0xDF, 0x00, 0xC0, 0x0E, 0x40, 0x00, 0x81, 0x0B, 0x89, 0x00, 0xC2, 
+    0x0B, 0x9E, 0x03, 0x00, 0x0C, 0xC0, 0x00, 0xFF, 0x0E, 0x40, 0x00, 0xDF,
-    0x0E, 0x08, 0x1C, 0x62, 0x00, 0xC4, 0x0E, 0x41, 0x00, 0xC5, 0x0E, 0x09, 0x02, 0xBF, 0x80, 0xE7, 0x00, 0xF8, 0x0B, 0xA9, 0x00, 0xFB, 0x0B, 0xAC, 0x00, 0xC0, 0x0E, 0x43, 0x00, 0x81, 0x0B, 0x91, 
+    0x0B, 0x9F, 0x03, 0x00, 0x0C, 0xC0, 0x00, 0xFF, 0x0E, 0x41, 0x00, 0x9F,
-    0x00, 0xC2, 0x0E, 0x0E, 0x1C, 0x62, 0x1C, 0x80, 0x00, 0xC5, 0x0E, 0x0F, 0x02, 0xBF, 0x80, 0xE7, 0x00, 0xF8, 0x0B, 0xAB, 0x00, 0xFB, 0x0B, 0xAE, 0x00, 0xC0, 0x0E, 0x40, 0x00, 0x81, 0x0B, 0x8D, 
+    0x0C, 0xE0, 0x00, 0xFF, 0x0E, 0x42, 0x00, 0xFF, 0x0E, 0x43, 0x02, 0xBF,
-    0x00, 0xC2, 0x0E, 0x0B, 0x1C, 0x62, 0x00, 0xC4, 0x0E, 0x41, 0x00, 0xC5, 0x0E, 0x0C, 0x02, 0xBF, 0x80, 0xE7, 0x00, 0xF8, 0x0B, 0xAA, 0x00, 0xFB, 0x0B, 0xAD, 0x00, 0xC0, 0x0E, 0x43, 0x00, 0x81, 
+    0x05, 0x5C, 0x00, 0xDE, 0x0B, 0x9C, 0x2E, 0xCE, 0x00, 0xDE, 0x0B, 0x9D,
-    0x0B, 0x99, 0x00, 0xC2, 0x0E, 0x0D, 0x1C, 0x62, 0x02, 0xBF, 0x81, 0xF9, 0x00, 0xF8, 0x0B, 0xB0, 0x02, 0xDF, 0x00, 0xC0, 0x0E, 0x40, 0x00, 0x81, 0x0B, 0x89, 0x00, 0xC2, 0x0E, 0x08, 0x00, 0x83, 
+    0x2E, 0xCF, 0x16, 0xCD, 0x0C, 0xC0, 0x16, 0xC9, 0x00, 0x00, 0x16, 0xCB,
-    0x0E, 0x44, 0x00, 0xC4, 0x0E, 0x41, 0x00, 0xC5, 0x0E, 0x09, 0x02, 0xBF, 0x82, 0x82, 0x00, 0xF8, 0x0B, 0xA9, 0x00, 0xFB, 0x0B, 0xAC, 0x00, 0xC0, 0x0E, 0x43, 0x00, 0x81, 0x0B, 0x91, 0x00, 0xC2, 
+    0x00, 0x40, 0x02, 0xBF, 0x05, 0x5C, 0x00, 0xC0, 0x0E, 0x07, 0x02, 0x9F,
-    0x0E, 0x0E, 0x00, 0x83, 0x0E, 0x44, 0x1C, 0x80, 0x00, 0xC5, 0x0E, 0x0F, 0x02, 0xBF, 0x82, 0x82, 0x00, 0xF8, 0x0B, 0xAB, 0x00, 0xFB, 0x0B, 0xAE, 0x02, 0xDF, 0x00, 0xC0, 0x0E, 0x40, 0x00, 0x81, 
+    0x02, 0x48, 0x00, 0x9F, 0x0C, 0xE0, 0x00, 0xFF, 0x0E, 0x42, 0x00, 0xFF,
-    0x0B, 0x89, 0x00, 0xC2, 0x0E, 0x08, 0x00, 0x83, 0x0E, 0x44, 0x00, 0xC4, 0x0E, 0x41, 0x00, 0xC5, 0x0E, 0x09, 0x02, 0xBF, 0x82, 0x82, 0x00, 0xF8, 0x0B, 0xA9, 0x00, 0xFB, 0x0B, 0xAC, 0x00, 0xC0, 
+    0x0E, 0x40, 0x00, 0xFF, 0x0E, 0x41, 0x00, 0xFF, 0x0E, 0x43, 0x02, 0xBF,
-    0x0E, 0x43, 0x00, 0x81, 0x0B, 0x91, 0x00, 0xC2, 0x0E, 0x0E, 0x00, 0x83, 0x0E, 0x44, 0x1C, 0x80, 0x00, 0xC5, 0x0E, 0x0F, 0x02, 0xBF, 0x82, 0x82, 0x00, 0xF8, 0x0B, 0xAB, 0x00, 0xFB, 0x0B, 0xAE, 
+    0x05, 0x5C, 0x00, 0xC0, 0x0E, 0x07, 0x02, 0x9F, 0x02, 0x48, 0x8E, 0x00,
-    0x00, 0xC0, 0x0E, 0x40, 0x00, 0x81, 0x0B, 0x8D, 0x00, 0xC2, 0x0E, 0x0B, 0x00, 0x83, 0x0E, 0x44, 0x00, 0xC4, 0x0E, 0x41, 0x00, 0xC5, 0x0E, 0x0C, 0x02, 0xBF, 0x82, 0x82, 0x00, 0xF8, 0x0B, 0xAA, 
+    0x00, 0x86, 0x04, 0x00, 0x81, 0x00, 0x89, 0x70, 0x19, 0x1C, 0x2E, 0xCE,
-    0x00, 0xFB, 0x0B, 0xAD, 0x00, 0xC0, 0x0E, 0x43, 0x00, 0x81, 0x0B, 0x99, 0x00, 0xC2, 0x0E, 0x0D, 0x00, 0x83, 0x0E, 0x44, 0x02, 0xBF, 0x84, 0x5D, 0x00, 0xF8, 0x0B, 0xB0, 0x02, 0xDF, 0x00, 0x82, 
+    0x2C, 0xCF, 0x1F, 0xC6, 0x2E, 0xCD, 0x16, 0xC9, 0x00, 0x01, 0x16, 0xCB,
-    0x01, 0x3E, 0x01, 0xBC, 0x02, 0x48, 0x04, 0x13, 0x04, 0x27, 0x01, 0x65, 0x05, 0x74, 0x0B, 0x37, 0x01, 0x5F, 0x04, 0x78, 0x04, 0x74, 0x04, 0x76, 0x01, 0xA9, 0x04, 0x3B, 0x04, 0x7A, 0x0B, 0xB1, 
+    0x07, 0x80, 0x02, 0xBF, 0x05, 0x5C, 0x02, 0xBF, 0x04, 0x84, 0x02, 0x9F,
-    0x01, 0x75, 0x07, 0x68, 0x07, 0x7A, 0x07, 0x9D, 0x07, 0xC0, 0x07, 0xF4, 0x08, 0x11, 0x08, 0x44, 0x08, 0x77, 0x08, 0xC6, 0x08, 0xD9, 0x08, 0xFE, 0x09, 0x23, 0x09, 0x5A, 0x09, 0x79, 0x09, 0xAF, 
+    0x00, 0x68, 0x8E, 0x00, 0x00, 0x86, 0x07, 0xC0, 0x81, 0x00, 0x89, 0x70,
-    0x09, 0xE5, 0x0A, 0x39, 0x0A, 0x5B, 0x07, 0x68, 0x07, 0x68, 0x07, 0x68, 0x07, 0x68, 0x07, 0x68, 0x07, 0x68, 0x0A, 0x99, 0x0A, 0xBD, 0x07, 0x68, 0x07, 0x68, 0x07, 0x68, 0x07, 0x68, 0x07, 0x68, 
+    0x19, 0x1C, 0x2E, 0xCE, 0x2C, 0xCF, 0x1F, 0xC6, 0x2E, 0xCD, 0x16, 0xC9,
-    0x07, 0x68, 0x05, 0xA8, 0x06, 0x5D, 0x07, 0x07, 0x10, 0x00, 0x12, 0x00, 0x14, 0x00, 0x8E, 0x00, 0x81, 0x00, 0x89, 0x70, 0x19, 0x1C, 0x2E, 0xCE, 0x2C, 0xCF, 0x16, 0xCD, 0x0E, 0x80, 0x16, 0xC9, 
+    0x00, 0x01, 0x16, 0xCB, 0x07, 0x80, 0x02, 0xBF, 0x05, 0x5C, 0x02, 0xBF,
-    0x00, 0x00, 0x16, 0xCB, 0x01, 0x00, 0x1F, 0x7E, 0x1F, 0x3C, 0x81, 0x00, 0x26, 0xC9, 0x02, 0xA0, 0x00, 0x04, 0x02, 0x9C, 0x0B, 0x46, 0x19, 0x1E, 0x19, 0x1C, 0x2E, 0xCE, 0x2C, 0xCF, 0x16, 0xCD, 
+    0x04, 0x84, 0x02, 0x9F, 0x00, 0x68, 0x8C, 0x00, 0x8A, 0x00, 0x81, 0x00,
-    0x02, 0x80, 0x16, 0xC9, 0x00, 0x00, 0x16, 0xCB, 0x02, 0x80, 0x1C, 0x80, 0x00, 0x80, 0x02, 0x80, 0x00, 0xC1, 0x0E, 0x1B, 0x00, 0x85, 0x00, 0x00, 0x00, 0x89, 0x00, 0x7F, 0x00, 0x82, 0x0F, 0x00, 
+    0x89, 0x70, 0x19, 0x1F, 0x2E, 0xCE, 0x2F, 0xCF, 0x16, 0xCD, 0x02, 0x80,
-    0x00, 0x83, 0x16, 0xB4, 0x1C, 0xE3, 0x81, 0x00, 0x26, 0xC9, 0x02, 0xA0, 0x00, 0x04, 0x02, 0x9C, 0x0B, 0x64, 0x8F, 0x00, 0x8A, 0x78, 0x8C, 0x68, 0xF1, 0x00, 0x1A, 0x3F, 0x84, 0xE3, 0x10, 0x7E, 
+    0x16, 0xC9, 0x00, 0x01, 0x16, 0xCB, 0x02, 0x80, 0x8F, 0x50, 0x81, 0x40,
-    0xF2, 0xE3, 0xF2, 0xE7, 0xF2, 0x78, 0x6E, 0x68, 0xF1, 0x32, 0x1A, 0x3F, 0x11, 0x9E, 0x0B, 0x80, 0x1C, 0x67, 0x84, 0xE3, 0x10, 0x7E, 0xF2, 0xE3, 0xF2, 0xE7, 0xF2, 0x78, 0x6E, 0x68, 0xF1, 0x32, 
+    0x00, 0x81, 0x04, 0x00, 0x00, 0x83, 0x00, 0x00, 0x00, 0x82, 0x01, 0x40,
-    0x1A, 0x3F, 0x1C, 0x67, 0x84, 0xE3, 0x10, 0x7E, 0xF2, 0xE3, 0xF2, 0xE7, 0xF2, 0x00, 0x6E, 0x00, 0x1B, 0x5E, 0x00, 0xE1, 0x0E, 0x1B, 0x00, 0x80, 0x02, 0x80, 0x00, 0x83, 0x0F, 0x00, 0x00, 0x81, 
+    0x00, 0x99, 0x00, 0x80, 0x02, 0xBF, 0x05, 0x5C, 0x11, 0x05, 0x04, 0x6C,
-    0x00, 0x00, 0x00, 0x82, 0x01, 0x40, 0x00, 0x89, 0xFF, 0xFF, 0x89, 0x00, 0x81, 0x00, 0x8F, 0x00, 0x11, 0xA0, 0x0B, 0xA0, 0x19, 0x7F, 0x99, 0x30, 0x1B, 0x1E, 0x1B, 0x3F, 0x7D, 0x29, 0x1B, 0x5F, 
+    0x1F, 0x61, 0x11, 0x20, 0x04, 0x5E, 0x89, 0x72, 0x19, 0x5C, 0xF0, 0x7B,
-    0x1B, 0x5D, 0x8E, 0x00, 0x1F, 0xDB, 0x1F, 0x99, 0x2E, 0xCE, 0x2C, 0xCF, 0x16, 0xCD, 0x0E, 0x80, 0x16, 0xC9, 0x00, 0x01, 0x16, 0xCB, 0x01, 0x00, 0x02, 0xBF, 0x05, 0x5C, 0x1C, 0x04, 0x02, 0x9F, 
+    0x19, 0x7D, 0xF1, 0x31, 0x81, 0x39, 0x89, 0x00, 0x68, 0x00, 0x2E, 0xCE,
-    0x00, 0x68, 0x8E, 0x00, 0x81, 0x00, 0x89, 0x70, 0x19, 0x1C, 0x2E, 0xCE, 0x2C, 0xCF, 0x16, 0xCD, 0x07, 0xC0, 0x16, 0xC9, 0x00, 0x01, 0x16, 0xCB, 0x05, 0x00, 0x02, 0xBF, 0x05, 0x5C, 0x81, 0x00, 
+    0x2C, 0xCF, 0x1F, 0xFB, 0x2F, 0xCD, 0x0F, 0x01, 0x2F, 0xC9, 0x1F, 0xF9,
-    0x89, 0x70, 0x19, 0x1C, 0x2E, 0xCE, 0x2C, 0xCF, 0x16, 0xCD, 0x07, 0xC0, 0x16, 0xC9, 0x00, 0x00, 0x89, 0x00, 0x0D, 0x20, 0x2D, 0xCB, 0x4C, 0x00, 0x1C, 0x80, 0x00, 0x80, 0x07, 0xC0, 0x00, 0x83, 
+    0x2F, 0xCB, 0x72, 0x00, 0x1F, 0x5E, 0x1F, 0x1C, 0x81, 0x00, 0x26, 0xC9,
-    0x00, 0x00, 0x1C, 0x43, 0x0A, 0x00, 0x27, 0xC9, 0x03, 0xA0, 0x00, 0x04, 0x02, 0x9C, 0x0B, 0xD3, 0x2E, 0xCE, 0x2C, 0xCF, 0x16, 0xCD, 0x07, 0xD0, 0x16, 0xC9, 0x00, 0x00, 0x16, 0xCB, 0x04, 0xE0, 
+    0x02, 0xA0, 0x00, 0x04, 0x02, 0x9C, 0x04, 0x6D, 0x02, 0x9F, 0x00, 0x68,
-    0x8F, 0x00, 0x80, 0xF0, 0x80, 0xC0, 0x6A, 0x00, 0x48, 0x00, 0x11, 0x4F, 0x0B, 0xEE, 0x80, 0xF0, 0x80, 0xC0, 0x6B, 0x32, 0x49, 0x22, 0x80, 0xF0, 0x80, 0xC0, 0x6A, 0x3A, 0x48, 0x2A, 0x80, 0xF0, 
+    0x02, 0x9F, 0x00, 0x68, 0x02, 0x9F, 0x00, 0x68, 0x02, 0x9F, 0x00, 0x68,
-    0x80, 0xC0, 0x6B, 0x32, 0x49, 0x22, 0x1B, 0x5F, 0x1B, 0x5D, 0x80, 0xF0, 0x80, 0xC0, 0x68, 0x00, 0x7C, 0x00, 0x4A, 0x00, 0x11, 0x4F, 0x0C, 0x05, 0x80, 0xF0, 0x80, 0xC0, 0x69, 0x32, 0x7D, 0x00, 
+    0x16, 0xFC, 0xDC, 0xD1, 0x16, 0xFD, 0x00, 0x02, 0x16, 0xFB, 0x00, 0x01,
-    0x4B, 0x22, 0x80, 0xF0, 0x80, 0xC0, 0x68, 0x3A, 0x7C, 0x00, 0x4A, 0x2A, 0x80, 0xF0, 0x80, 0xC0, 0x69, 0x32, 0x7D, 0x00, 0x4B, 0x22, 0x1B, 0x5F, 0x1B, 0x5D, 0x1C, 0x04, 0x02, 0x9F, 0x00, 0x68, 
+    0x02, 0x9F, 0x0C, 0x91, 0x02, 0x9F, 0x00, 0x45, 0x8E, 0x00, 0x19, 0x1F,
-    0x8E, 0x00, 0x16, 0xFC, 0xEC, 0xC0, 0x1F, 0xCC, 0x1D, 0x9E, 0x2E, 0xFD, 0x26, 0xFC, 0x02, 0xA0, 0x80, 0x00, 0x02, 0x9C, 0x0C, 0x16, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xFF, 0x8E, 0x00, 
+    0x19, 0x1D, 0x1F, 0x5F, 0x1F, 0x1D, 0x2F, 0xCE, 0x2D, 0xCF, 0x89, 0x00,
-    0x00, 0xF0, 0x0E, 0x17, 0x00, 0xFE, 0x0E, 0x18, 0x00, 0xFC, 0x0E, 0x19, 0x1F, 0xCC, 0x1D, 0x9E, 0x16, 0xFC, 0xFE, 0xED, 0x2E, 0xFD, 0x26, 0xFC, 0x02, 0xA0, 0x80, 0x00, 0x02, 0x9C, 0x0C, 0x2B, 
+    0x1F, 0xA6, 0x2D, 0xCD, 0x0E, 0x00, 0x2E, 0xC9, 0x81, 0x00, 0x00, 0x9C,
-    0x00, 0xD0, 0x0E, 0x17, 0x00, 0xDE, 0x0E, 0x18, 0x00, 0xDC, 0x0E, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xFF, 0x8E, 0x00, 0x1D, 0xBC, 0x1D, 0xBE, 0x81, 0x00, 0x00, 0xDE, 
+    0x00, 0xC0, 0x2C, 0xCB, 0x1C, 0xA0, 0x00, 0x81, 0x0E, 0x44, 0x48, 0x00,
-    0x0B, 0xB7, 0x06, 0x01, 0x02, 0x95, 0x0C, 0x47, 0x0E, 0x00, 0x00, 0xFE, 0x0B, 0x87, 0x1F, 0xCD, 0x1F, 0x8D, 0x02, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xFF, 
+    0x1B, 0x3E, 0x1B, 0x3C, 0x0B, 0x00, 0x00, 0x99, 0x00, 0x60, 0x4B, 0x00,
-    0x8E, 0x00, 0x1D, 0xBC, 0x1D, 0xBE, 0x81, 0x00, 0x00, 0xDE, 0x0B, 0xB7, 0x06, 0x01, 0x02, 0x95, 0x0C, 0x5F, 0x0E, 0x00, 0x00, 0xFE, 0x0B, 0x87, 0x1F, 0xCD, 0x1F, 0x8D, 0x02, 0xFF, 0x81, 0x00, 
+    0x1B, 0x3D, 0x00, 0x81, 0x0E, 0x44, 0x1C, 0x06, 0x00, 0x83, 0x00, 0x00,
-    0x00, 0xDE, 0x0B, 0x88, 0x06, 0x01, 0x02, 0x95, 0x0C, 0x71, 0x00, 0xDE, 0x0B, 0xDA, 0x2E, 0xDA, 0x00, 0xDE, 0x0B, 0xDB, 0x2E, 0xDB, 0x00, 0xDE, 0x0B, 0xDC, 0x2E, 0xDC, 0x1F, 0xCD, 0x1F, 0x8D, 
+    0x1C, 0x43, 0x27, 0xC9, 0x03, 0xA0, 0x00, 0x04, 0x02, 0x9C, 0x04, 0xA5,
-    0x02, 0xFF, 0x00, 0xDE, 0x0B, 0xDA, 0x2E, 0xDA, 0x26, 0xDB, 0x2E, 0xDB, 0x26, 0xDC, 0x2E, 0xDC, 0x81, 0x00, 0x00, 0xDC, 0x0B, 0xDD, 0x76, 0x00, 0x00, 0xFC, 0x0B, 0xDD, 0x81, 0x00, 0x1F, 0xCD, 
+    0x11, 0x09, 0x04, 0xDA, 0x8E, 0x00, 0x19, 0x3A, 0x19, 0x38, 0x69, 0x00,
-    0x1F, 0x8D, 0x02, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xFF, 0x0C, 0x9F, 0x0C, 0xA2, 0x0C, 0xDA, 
+    0x2F, 0xCE, 0x2D, 0xCF, 0x89, 0x00, 0x19, 0x3D, 0x2D, 0xCD, 0x16, 0xC9,
-    0x0C, 0xDD, 0x8E, 0x00, 0x81, 0x00, 0x89, 0x00, 0x02, 0xBF, 0x0C, 0xE0, 0x27, 0xFF, 0x00, 0x9E, 0x0C, 0x8D, 0x4C, 0x00, 0x1C, 0x7E, 0x03, 0x13, 0x1C, 0x7F, 0x17, 0x6F, 0x00, 0x21, 0x02, 0x9F, 
+    0x00, 0x00, 0x81, 0x00, 0x00, 0x9C, 0x00, 0xC0, 0x2C, 0xCB, 0x00, 0x81,
-    0x00, 0x30, 0x00, 0x21, 0x81, 0x00, 0x89, 0x00, 0x02, 0xBF, 0x0C, 0xE0, 0x24, 0xFF, 0x02, 0xBF, 0x0C, 0xE6, 0x25, 0xFF, 0x02, 0xBF, 0x0C, 0xE6, 0x27, 0xFF, 0x2E, 0xCE, 0x2C, 0xCF, 0x16, 0xC9, 
+    0x0E, 0x44, 0x48, 0x00, 0x1B, 0x3E, 0x1B, 0x3C, 0x0B, 0x00, 0x09, 0x60,
-    0x00, 0x01, 0x2F, 0xCD, 0x2D, 0xCB, 0x81, 0x00, 0x89, 0x00, 0x02, 0xBF, 0x0C, 0xE0, 0x24, 0xFF, 0x1C, 0x9E, 0x1C, 0xBC, 0x02, 0xBF, 0x0C, 0xE6, 0x25, 0xFF, 0x02, 0xBF, 0x0C, 0xE6, 0x27, 0xFF, 
+    0x4B, 0x00, 0x1B, 0x3D, 0x00, 0x81, 0x0E, 0x44, 0x8F, 0x00, 0x80, 0xF0,
-    0x1C, 0xDF, 0x1C, 0xFD, 0x81, 0x00, 0x02, 0xBF, 0x0C, 0xE0, 0x26, 0xFF, 0x1C, 0x1E, 0x89, 0x00, 0x02, 0xBF, 0x0C, 0xE6, 0x20, 0xFF, 0x1F, 0x5F, 0x02, 0xBF, 0x0C, 0xE0, 0x21, 0xFF, 0x02, 0xBF, 
+    0x80, 0xC0, 0x6A, 0x00, 0x48, 0x00, 0x11, 0x17, 0x04, 0xD4, 0x80, 0xF0,
-    0x0C, 0xE0, 0x23, 0xFF, 0x26, 0xC9, 0x02, 0xA0, 0x00, 0x04, 0x02, 0x9C, 0x0C, 0xD2, 0x02, 0x9F, 0x80, 0xB5, 0x00, 0x21, 0x02, 0x9F, 0x80, 0x00, 0x00, 0x21, 0x02, 0x9F, 0x00, 0x45, 0x00, 0x21, 
+    0x80, 0xC0, 0x6B, 0x32, 0x49, 0x22, 0x80, 0xF0, 0x80, 0xC0, 0x6A, 0x3A,
-    0x26, 0xFE, 0x02, 0xC0, 0x80, 0x00, 0x02, 0x9C, 0x0C, 0xE0, 0x02, 0xDF, 0x27, 0xFE, 0x03, 0xC0, 0x80, 0x00, 0x02, 0x9C, 0x0C, 0xE6, 0x02, 0xDF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x48, 0x2A, 0x80, 0xF0, 0x80, 0xC0, 0x6B, 0x32, 0x49, 0x22, 0x1B, 0x5F,
+    0x1B, 0x5D, 0x80, 0xF0, 0x80, 0xC0, 0x6A, 0x00, 0x48, 0x00, 0x11, 0x17,
+    0x04, 0xE8, 0x80, 0xF0, 0x80, 0xC0, 0x6B, 0x32, 0x49, 0x22, 0x80, 0xF0,
+    0x80, 0xC0, 0x6A, 0x3A, 0x48, 0x2A, 0x80, 0xF0, 0x80, 0xC0, 0x6B, 0x32,
+    0x49, 0x22, 0x1B, 0x5F, 0x1B, 0x5D, 0x1C, 0x05, 0x02, 0xDF, 0x8E, 0x00,
+    0x00, 0x9B, 0x0E, 0x44, 0x00, 0x9D, 0x00, 0xC0, 0x02, 0xBF, 0x05, 0x41,
+    0x49, 0x00, 0x00, 0xFF, 0x0E, 0x1D, 0x00, 0xFD, 0x0E, 0x1E, 0x89, 0x00,
+    0x02, 0xBF, 0x05, 0x5C, 0x11, 0x04, 0x05, 0x2C, 0x00, 0xDA, 0x0E, 0x1D,
+    0x00, 0xD8, 0x0E, 0x1E, 0x00, 0x9B, 0x0E, 0xA4, 0x00, 0x9D, 0x00, 0xC0,
+    0x02, 0xBF, 0x05, 0x41, 0x49, 0x00, 0x00, 0xFF, 0x0E, 0x1D, 0x00, 0xFD,
+    0x0E, 0x1E, 0x00, 0x83, 0x0E, 0x44, 0x02, 0xBF, 0x05, 0x4C, 0x89, 0x00,
+    0x00, 0xDA, 0x0E, 0x1D, 0x00, 0xD8, 0x0E, 0x1E, 0x00, 0x9B, 0x0E, 0x44,
+    0x00, 0x9D, 0x00, 0xC0, 0x02, 0xBF, 0x05, 0x41, 0x49, 0x00, 0x00, 0xFF,
+    0x0E, 0x1D, 0x00, 0xFD, 0x0E, 0x1E, 0x00, 0x83, 0x0E, 0xA4, 0x02, 0xBF,
+    0x05, 0x4C, 0x00, 0x00, 0x00, 0x00, 0x8E, 0x00, 0x89, 0x00, 0x00, 0xDA,
+    0x0E, 0x1D, 0x00, 0xD8, 0x0E, 0x1E, 0x00, 0x9B, 0x0E, 0xA4, 0x00, 0x9D,
+    0x00, 0xC0, 0x02, 0xBF, 0x05, 0x41, 0x49, 0x00, 0x00, 0x83, 0x0E, 0x44,
+    0x02, 0xBF, 0x05, 0x4C, 0x00, 0x83, 0x0E, 0xA4, 0x02, 0xBF, 0x05, 0x4C,
+    0x02, 0xDF, 0x8E, 0x00, 0x00, 0xFA, 0xFF, 0xCE, 0x00, 0xF8, 0xFF, 0xCF,
+    0x00, 0xFB, 0xFF, 0xCD, 0x16, 0xC9, 0x00, 0x00, 0x2D, 0xCB, 0x02, 0xDF,
+    0x8F, 0x00, 0x8D, 0x00, 0x8A, 0x00, 0x19, 0x7A, 0x19, 0x78, 0xA0, 0x00,
+    0xB6, 0x00, 0x11, 0x30, 0x05, 0x5A, 0x91, 0x79, 0x4E, 0x6D, 0x19, 0x7A,
+    0x4D, 0x43, 0xA0, 0x39, 0xB6, 0x29, 0x02, 0xDF, 0x26, 0xC9, 0x02, 0xA0,
+    0x00, 0x04, 0x02, 0x9C, 0x05, 0x5C, 0x02, 0xDF, 0x26, 0xFE, 0x02, 0xC0,
+    0x80, 0x00, 0x02, 0x9C, 0x05, 0x62, 0x02, 0xDF, 0x26, 0xFC, 0x02, 0xA0,
+    0x80, 0x00, 0x02, 0x9C, 0x05, 0x68, 0x02, 0xDF, 0x26, 0xFC, 0x02, 0xA0,
+    0x80, 0x00, 0x02, 0x9C, 0x05, 0x6E, 0x02, 0xDF, 0x81, 0x00, 0x89, 0x70,
+    0x8E, 0x60, 0x2E, 0xCE, 0x2C, 0xCF, 0x16, 0xCD, 0x0E, 0x44, 0x16, 0xC9,
+    0x00, 0x00, 0x89, 0x00, 0x0D, 0x20, 0x2D, 0xCB, 0x4C, 0x00, 0x1C, 0x80,
+    0x00, 0x80, 0x02, 0x80, 0x00, 0x81, 0x00, 0x00, 0x00, 0x82, 0x01, 0x40,
+    0x00, 0x83, 0x0E, 0x44, 0x0A, 0x00, 0x27, 0xC9, 0x03, 0xA0, 0x00, 0x04,
+    0x02, 0x9C, 0x05, 0x8B, 0x2E, 0xCE, 0x2C, 0xCF, 0x16, 0xCD, 0x0E, 0x54,
+    0x16, 0xC9, 0x00, 0x00, 0x16, 0xCB, 0x02, 0x60, 0x00, 0x9F, 0x00, 0xA0,
+    0x8F, 0x00, 0x00, 0x7F, 0x05, 0xA4, 0x19, 0x7E, 0x1B, 0x1A, 0x19, 0x7C,
+    0x1B, 0x1A, 0x1B, 0x5E, 0x1B, 0x5C, 0x1B, 0x3E, 0x1B, 0x3C, 0x1C, 0x04,
+    0x02, 0x9F, 0x00, 0x68, 0x00, 0x82, 0x0B, 0xB8, 0x19, 0x5E, 0x2E, 0xD1,
+    0x19, 0x5E, 0x2E, 0xD4, 0x19, 0x5E, 0x2E, 0xD5, 0x19, 0x5E, 0x2E, 0xD6,
+    0x19, 0x5E, 0x2E, 0xD7, 0x19, 0x5E, 0x2E, 0xD8, 0x19, 0x5E, 0x2E, 0xD9,
+    0x19, 0x5E, 0x2E, 0xA0, 0x19, 0x5E, 0x2E, 0xA1, 0x19, 0x5E, 0x2E, 0xA2,
+    0x19, 0x5E, 0x2E, 0xA3, 0x19, 0x5E, 0x2E, 0xA4, 0x19, 0x5E, 0x2E, 0xA5,
+    0x19, 0x5E, 0x2E, 0xA6, 0x19, 0x5E, 0x2E, 0xA7, 0x19, 0x5E, 0x2E, 0xA8,
+    0x19, 0x5E, 0x2E, 0xA9, 0x19, 0x5E, 0x2E, 0xAA, 0x19, 0x5E, 0x2E, 0xAB,
+    0x19, 0x5E, 0x2E, 0xAC, 0x19, 0x5E, 0x2E, 0xAD, 0x19, 0x5E, 0x2E, 0xAE,
+    0x19, 0x5E, 0x2E, 0xAF, 0x19, 0x5E, 0x2E, 0xDE, 0x19, 0x5E, 0x2E, 0xDA,
+    0x19, 0x5E, 0x2E, 0xDB, 0x19, 0x5E, 0x2E, 0xDC, 0x8C, 0x00, 0x8A, 0x00,
+    0x8E, 0x00, 0x00, 0xD8, 0x0E, 0x16, 0x19, 0x5B, 0x19, 0x59, 0x81, 0x00,
+    0x19, 0x5C, 0x00, 0x80, 0x0E, 0x44, 0x19, 0x5F, 0x1B, 0x1F, 0x19, 0x5F,
+    0x1B, 0x1F, 0x19, 0x5F, 0x1B, 0x1F, 0x18, 0x5F, 0x1B, 0x1F, 0x6B, 0x00,
+    0x15, 0x05, 0x4D, 0x00, 0x15, 0x7E, 0x1C, 0x9F, 0x1C, 0xBD, 0x05, 0xE0,
+    0x99, 0x00, 0x7D, 0x00, 0x1C, 0xDD, 0x89, 0x00, 0x1F, 0xA5, 0x15, 0x02,
+    0x1C, 0xBF, 0x00, 0x9A, 0x01, 0xFC, 0x00, 0x9E, 0x0E, 0x44, 0x00, 0x81,
+    0xFF, 0xDD, 0x00, 0x83, 0x0D, 0x80, 0x00, 0x64, 0x06, 0x1A, 0x18, 0x27,
+    0x1B, 0x07, 0x4A, 0x00, 0x1F, 0xFC, 0x18, 0x27, 0x1B, 0x07, 0x15, 0x79,
+    0x35, 0x00, 0x18, 0x27, 0x1B, 0x07, 0x41, 0x00, 0x1B, 0x7E, 0x18, 0x27,
+    0x1B, 0x07, 0x1B, 0x7F, 0x00, 0x00, 0x00, 0x65, 0x06, 0x20, 0x18, 0x27,
+    0x1B, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x18, 0x7F, 0x00, 0x66,
+    0x06, 0x29, 0x4A, 0x3B, 0x1F, 0xFC, 0x15, 0x79, 0x35, 0x33, 0x41, 0x00,
+    0x1B, 0x7F, 0x00, 0x04, 0x18, 0x9F, 0x1A, 0xDF, 0x18, 0x9F, 0x1A, 0xDF,
+    0x18, 0x9F, 0x1A, 0xDF, 0x18, 0x9F, 0x1A, 0xDF, 0x1A, 0xDC, 0x00, 0x82,
+    0x0B, 0xD2, 0x27, 0xDC, 0x1A, 0xDF, 0x27, 0xDB, 0x1A, 0xDF, 0x27, 0xDA,
+    0x1A, 0xDF, 0x00, 0x82, 0x0B, 0xBE, 0x27, 0xD9, 0x1A, 0xDF, 0x27, 0xD8,
+    0x1A, 0xDF, 0x8F, 0x00, 0x00, 0xC1, 0x0E, 0x42, 0x00, 0x82, 0x0D, 0x80,
+    0x19, 0x40, 0x19, 0x43, 0x80, 0xF0, 0xB8, 0xC0, 0x11, 0x1F, 0x06, 0x54,
+    0xA6, 0xF0, 0xBC, 0xF0, 0x19, 0x40, 0x19, 0x43, 0xBC, 0xF0, 0x4E, 0xC0,
+    0xB8, 0x31, 0xA6, 0xF0, 0xBC, 0xF0, 0xBC, 0x00, 0x4E, 0x00, 0x1B, 0x3E,
+    0x00, 0xE1, 0x0E, 0x42, 0x02, 0xDF, 0x00, 0x82, 0x0B, 0xB8, 0x19, 0x5E,
+    0x2E, 0xD1, 0x19, 0x5E, 0x2E, 0xD4, 0x19, 0x5E, 0x2E, 0xD5, 0x19, 0x5E,
+    0x2E, 0xD6, 0x19, 0x5E, 0x2E, 0xD7, 0x19, 0x5E, 0x2E, 0xD8, 0x19, 0x5E,
+    0x2E, 0xD9, 0x19, 0x5E, 0x2E, 0xA0, 0x19, 0x5E, 0x2E, 0xA1, 0x19, 0x5E,
+    0x2E, 0xA2, 0x19, 0x5E, 0x2E, 0xA3, 0x19, 0x5E, 0x2E, 0xA4, 0x19, 0x5E,
+    0x2E, 0xA5, 0x19, 0x5E, 0x2E, 0xA6, 0x19, 0x5E, 0x2E, 0xA7, 0x19, 0x5E,
+    0x2E, 0xA8, 0x19, 0x5E, 0x2E, 0xA9, 0x19, 0x5E, 0x2E, 0xAA, 0x19, 0x5E,
+    0x2E, 0xAB, 0x19, 0x5E, 0x2E, 0xAC, 0x19, 0x5E, 0x2E, 0xAD, 0x19, 0x5E,
+    0x2E, 0xAE, 0x19, 0x5E, 0x2E, 0xAF, 0x19, 0x5E, 0x2E, 0xDE, 0x19, 0x5E,
+    0x2E, 0xDA, 0x19, 0x5E, 0x2E, 0xDB, 0x19, 0x5E, 0x2E, 0xDC, 0x8C, 0x00,
+    0x8A, 0x00, 0x8E, 0x00, 0x19, 0x5B, 0x19, 0x59, 0x81, 0x00, 0x19, 0x5C,
+    0x00, 0x80, 0x0E, 0x44, 0x19, 0x5F, 0x19, 0x5F, 0x19, 0x5F, 0x1B, 0x1F,
+    0x18, 0x5F, 0x1B, 0x1F, 0x6B, 0x00, 0x15, 0x05, 0x4D, 0x00, 0x15, 0x7E,
+    0x1C, 0x9F, 0x1C, 0xBD, 0x05, 0xE0, 0x99, 0x00, 0x7D, 0x00, 0x1C, 0xDD,
+    0x89, 0x00, 0x1F, 0xA5, 0x15, 0x02, 0x1C, 0xBF, 0x00, 0x9A, 0x01, 0xFC,
+    0x00, 0x9E, 0x0E, 0x45, 0x00, 0x81, 0xFF, 0xDD, 0x00, 0x83, 0x0D, 0x80,
+    0x00, 0x64, 0x06, 0xCB, 0x18, 0x27, 0x1B, 0x07, 0x4A, 0x00, 0x1B, 0x7E,
+    0x18, 0x27, 0x1B, 0x07, 0x1B, 0x7C, 0x00, 0x00, 0x18, 0x27, 0x1B, 0x07,
+    0x00, 0x00, 0x00, 0x00, 0x18, 0x27, 0x1B, 0x07, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x65, 0x06, 0xD1, 0x18, 0x27, 0x1B, 0x07, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x66, 0x06, 0xD6, 0x4A, 0x00, 0x1B, 0x7E, 0x1B, 0x7C, 0x00, 0x04,
+    0x18, 0x9F, 0x1A, 0xDF, 0x18, 0x9F, 0x1A, 0xDF, 0x18, 0x9F, 0x1A, 0xDF,
+    0x18, 0x9F, 0x1A, 0xDF, 0x1A, 0xDC, 0x00, 0x82, 0x0B, 0xD2, 0x27, 0xDC,
+    0x1A, 0xDF, 0x27, 0xDB, 0x1A, 0xDF, 0x27, 0xDA, 0x1A, 0xDF, 0x00, 0x82,
+    0x0B, 0xBE, 0x27, 0xD9, 0x1A, 0xDF, 0x27, 0xD8, 0x1A, 0xDF, 0x8D, 0x00,
+    0x8B, 0x00, 0x8F, 0x00, 0x00, 0xC1, 0x0E, 0x42, 0x00, 0x82, 0x0D, 0x80,
+    0x81, 0x00, 0x11, 0x20, 0x07, 0x03, 0x89, 0x00, 0x19, 0x40, 0x18, 0x9E,
+    0x18, 0x1B, 0x19, 0x9A, 0x54, 0x00, 0x1F, 0x5E, 0x19, 0x59, 0xB0, 0x00,
+    0xFB, 0x00, 0x81, 0x39, 0x00, 0xE1, 0x0E, 0x42, 0x02, 0xDF, 0x00, 0x82,
+    0x0B, 0xB8, 0x19, 0x5E, 0x2E, 0xD1, 0x19, 0x5E, 0x2E, 0xD4, 0x19, 0x5E,
+    0x2E, 0xD5, 0x19, 0x5E, 0x2E, 0xD6, 0x19, 0x5E, 0x2E, 0xD7, 0x19, 0x5E,
+    0x2E, 0xD8, 0x19, 0x5E, 0x2E, 0xD9, 0x19, 0x5E, 0x2E, 0xA0, 0x19, 0x5E,
+    0x2E, 0xA1, 0x19, 0x5E, 0x2E, 0xA2, 0x19, 0x5E, 0x2E, 0xA3, 0x19, 0x5E,
+    0x2E, 0xA4, 0x19, 0x5E, 0x2E, 0xA5, 0x19, 0x5E, 0x2E, 0xA6, 0x19, 0x5E,
+    0x2E, 0xA7, 0x19, 0x5E, 0x2E, 0xA8, 0x19, 0x5E, 0x2E, 0xA9, 0x19, 0x5E,
+    0x2E, 0xAA, 0x19, 0x5E, 0x2E, 0xAB, 0x19, 0x5E, 0x2E, 0xAC, 0x19, 0x5E,
+    0x2E, 0xAD, 0x19, 0x5E, 0x2E, 0xAE, 0x19, 0x5E, 0x2E, 0xAF, 0x19, 0x5E,
+    0x2E, 0xDE, 0x19, 0x5E, 0x2E, 0xDA, 0x19, 0x5E, 0x2E, 0xDB, 0x19, 0x5E,
+    0x2E, 0xDC, 0x00, 0xC0, 0x0E, 0x42, 0x00, 0x81, 0xFF, 0xDD, 0x11, 0x20,
+    0x07, 0x48, 0x18, 0x24, 0x1B, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0,
+    0x0E, 0x42, 0x00, 0x82, 0x0B, 0xD9, 0x00, 0x04, 0x18, 0x9F, 0x1A, 0xDF,
+    0x18, 0x9F, 0x1A, 0xDF, 0x18, 0x9F, 0x1A, 0xDF, 0x18, 0x9F, 0x1A, 0xDF,
+    0x89, 0x00, 0x1A, 0xDC, 0x27, 0xDC, 0x00, 0xFF, 0x0B, 0xD2, 0x27, 0xDB,
+    0x00, 0xFF, 0x0B, 0xD1, 0x27, 0xDA, 0x00, 0xFF, 0x0B, 0xD0, 0x27, 0xD9,
+    0x00, 0xFF, 0x0B, 0xBE, 0x27, 0xD8, 0x00, 0xFF, 0x0B, 0xBD, 0x02, 0xDF,
+    0x00, 0xC0, 0x0E, 0x40, 0x00, 0x81, 0x0B, 0x89, 0x00, 0xC2, 0x0E, 0x08,
+    0x1C, 0x62, 0x00, 0xC4, 0x0E, 0x41, 0x00, 0xC5, 0x0E, 0x09, 0x02, 0xBF,
+    0x80, 0xE7, 0x00, 0xF8, 0x0B, 0xA9, 0x00, 0xFB, 0x0B, 0xAC, 0x02, 0xDF,
+    0x00, 0xC0, 0x0E, 0x40, 0x00, 0x81, 0x0B, 0x89, 0x00, 0xC2, 0x0E, 0x08,
+    0x1C, 0x62, 0x00, 0xC4, 0x0E, 0x41, 0x00, 0xC5, 0x0E, 0x09, 0x02, 0xBF,
+    0x80, 0xE7, 0x00, 0xF8, 0x0B, 0xA9, 0x00, 0xFB, 0x0B, 0xAC, 0x00, 0xC0,
+    0x0E, 0x40, 0x00, 0x81, 0x0B, 0x8D, 0x00, 0xC2, 0x0E, 0x0B, 0x1C, 0x62,
+    0x00, 0xC4, 0x0E, 0x41, 0x00, 0xC5, 0x0E, 0x0C, 0x02, 0xBF, 0x80, 0xE7,
+    0x00, 0xF8, 0x0B, 0xAA, 0x00, 0xFB, 0x0B, 0xAD, 0x02, 0xDF, 0x00, 0xC0,
+    0x0E, 0x40, 0x00, 0x81, 0x0B, 0x89, 0x00, 0xC2, 0x0E, 0x08, 0x1C, 0x62,
+    0x00, 0xC4, 0x0E, 0x41, 0x00, 0xC5, 0x0E, 0x09, 0x02, 0xBF, 0x80, 0xE7,
+    0x00, 0xF8, 0x0B, 0xA9, 0x00, 0xFB, 0x0B, 0xAC, 0x00, 0xC0, 0x0E, 0x40,
+    0x00, 0x81, 0x0B, 0x91, 0x00, 0xC2, 0x0E, 0x0E, 0x1C, 0x62, 0x00, 0xC4,
+    0x0E, 0x41, 0x00, 0xC5, 0x0E, 0x0F, 0x02, 0xBF, 0x80, 0xE7, 0x00, 0xF8,
+    0x0B, 0xAB, 0x00, 0xFB, 0x0B, 0xAE, 0x02, 0xDF, 0x00, 0xC0, 0x0E, 0x40,
+    0x00, 0x81, 0x0B, 0x89, 0x00, 0xC2, 0x0E, 0x08, 0x1C, 0x62, 0x00, 0xC4,
+    0x0E, 0x41, 0x00, 0xC5, 0x0E, 0x09, 0x02, 0xBF, 0x80, 0xE7, 0x00, 0xF8,
+    0x0B, 0xA9, 0x00, 0xFB, 0x0B, 0xAC, 0x00, 0xC0, 0x0E, 0x40, 0x00, 0x81,
+    0x0B, 0x8D, 0x00, 0xC2, 0x0E, 0x0B, 0x1C, 0x62, 0x00, 0xC4, 0x0E, 0x41,
+    0x00, 0xC5, 0x0E, 0x0C, 0x02, 0xBF, 0x80, 0xE7, 0x00, 0xF8, 0x0B, 0xAA,
+    0x00, 0xFB, 0x0B, 0xAD, 0x00, 0xC0, 0x0E, 0x40, 0x00, 0x81, 0x0B, 0x91,
+    0x00, 0xC2, 0x0E, 0x0E, 0x1C, 0x62, 0x00, 0xC4, 0x0E, 0x41, 0x00, 0xC5,
+    0x0E, 0x0F, 0x02, 0xBF, 0x80, 0xE7, 0x00, 0xF8, 0x0B, 0xAB, 0x00, 0xFB,
+    0x0B, 0xAE, 0x02, 0xDF, 0x00, 0xC0, 0x0E, 0x40, 0x00, 0x81, 0x0B, 0x89,
+    0x00, 0xC2, 0x0E, 0x08, 0x1C, 0x62, 0x00, 0xC4, 0x0E, 0x41, 0x00, 0xC5,
+    0x0E, 0x09, 0x02, 0xBF, 0x80, 0xE7, 0x00, 0xF8, 0x0B, 0xA9, 0x00, 0xFB,
+    0x0B, 0xAC, 0x00, 0xC0, 0x0E, 0x43, 0x00, 0x81, 0x0B, 0x97, 0x00, 0xC2,
+    0x0E, 0x0A, 0x1C, 0x62, 0x02, 0xBF, 0x81, 0xF9, 0x00, 0xF8, 0x0B, 0xAF,
+    0x02, 0xDF, 0x00, 0xC0, 0x0E, 0x40, 0x00, 0x81, 0x0B, 0x89, 0x00, 0xC2,
+    0x0E, 0x08, 0x1C, 0x62, 0x00, 0xC4, 0x0E, 0x41, 0x00, 0xC5, 0x0E, 0x09,
+    0x02, 0xBF, 0x80, 0xE7, 0x00, 0xF8, 0x0B, 0xA9, 0x00, 0xFB, 0x0B, 0xAC,
+    0x00, 0xC0, 0x0E, 0x40, 0x00, 0x81, 0x0B, 0x8D, 0x00, 0xC2, 0x0E, 0x0B,
+    0x1C, 0x62, 0x00, 0xC4, 0x0E, 0x41, 0x00, 0xC5, 0x0E, 0x0C, 0x02, 0xBF,
+    0x80, 0xE7, 0x00, 0xF8, 0x0B, 0xAA, 0x00, 0xFB, 0x0B, 0xAD, 0x00, 0xC0,
+    0x0E, 0x43, 0x00, 0x81, 0x0B, 0x97, 0x00, 0xC2, 0x0E, 0x0A, 0x1C, 0x62,
+    0x1C, 0x80, 0x00, 0xC5, 0x0E, 0x0D, 0x02, 0xBF, 0x80, 0xE7, 0x00, 0xF8,
+    0x0B, 0xAF, 0x00, 0xFB, 0x0B, 0xB0, 0x02, 0xDF, 0x00, 0xC0, 0x0E, 0x40,
+    0x00, 0x81, 0x0B, 0x89, 0x00, 0xC2, 0x0E, 0x08, 0x1C, 0x62, 0x00, 0xC4,
+    0x0E, 0x41, 0x00, 0xC5, 0x0E, 0x09, 0x02, 0xBF, 0x80, 0xE7, 0x00, 0xF8,
+    0x0B, 0xA9, 0x00, 0xFB, 0x0B, 0xAC, 0x00, 0xC0, 0x0E, 0x40, 0x00, 0x81,
+    0x0B, 0x91, 0x00, 0xC2, 0x0E, 0x0E, 0x1C, 0x62, 0x00, 0xC4, 0x0E, 0x41,
+    0x00, 0xC5, 0x0E, 0x0F, 0x02, 0xBF, 0x80, 0xE7, 0x00, 0xF8, 0x0B, 0xAB,
+    0x00, 0xFB, 0x0B, 0xAE, 0x00, 0xC0, 0x0E, 0x43, 0x00, 0x81, 0x0B, 0x95,
+    0x00, 0xC2, 0x0E, 0x10, 0x1C, 0x62, 0x1C, 0x80, 0x00, 0xC5, 0x0E, 0x0A,
+    0x02, 0xBF, 0x80, 0xE7, 0x00, 0xF8, 0x0B, 0xB1, 0x00, 0xFB, 0x0B, 0xAF,
+    0x02, 0xDF, 0x00, 0xC0, 0x0E, 0x40, 0x00, 0x81, 0x0B, 0x89, 0x00, 0xC2,
+    0x0E, 0x08, 0x1C, 0x62, 0x00, 0xC4, 0x0E, 0x41, 0x00, 0xC5, 0x0E, 0x09,
+    0x02, 0xBF, 0x80, 0xE7, 0x00, 0xF8, 0x0B, 0xA9, 0x00, 0xFB, 0x0B, 0xAC,
+    0x00, 0xC0, 0x0E, 0x40, 0x00, 0x81, 0x0B, 0x8D, 0x00, 0xC2, 0x0E, 0x0B,
+    0x1C, 0x62, 0x00, 0xC4, 0x0E, 0x41, 0x00, 0xC5, 0x0E, 0x0C, 0x02, 0xBF,
+    0x80, 0xE7, 0x00, 0xF8, 0x0B, 0xAA, 0x00, 0xFB, 0x0B, 0xAD, 0x00, 0xC0,
+    0x0E, 0x40, 0x00, 0x81, 0x0B, 0x91, 0x00, 0xC2, 0x0E, 0x0E, 0x1C, 0x62,
+    0x00, 0xC4, 0x0E, 0x41, 0x00, 0xC5, 0x0E, 0x0F, 0x02, 0xBF, 0x80, 0xE7,
+    0x00, 0xF8, 0x0B, 0xAB, 0x00, 0xFB, 0x0B, 0xAE, 0x00, 0xC0, 0x0E, 0x43,
+    0x00, 0x81, 0x0B, 0x97, 0x00, 0xC2, 0x0E, 0x0A, 0x1C, 0x62, 0x1C, 0x80,
+    0x00, 0xC5, 0x0E, 0x0D, 0x02, 0xBF, 0x80, 0xE7, 0x00, 0xF8, 0x0B, 0xAF,
+    0x00, 0xFB, 0x0B, 0xB0, 0x00, 0xC0, 0x0E, 0x43, 0x00, 0x81, 0x0B, 0x95,
+    0x00, 0xC2, 0x0E, 0x10, 0x1C, 0x62, 0x02, 0xBF, 0x81, 0xF9, 0x00, 0xF8,
+    0x0B, 0xB1, 0x02, 0xDF, 0x00, 0xC0, 0x0E, 0x40, 0x00, 0x81, 0x0B, 0x89,
+    0x00, 0xC2, 0x0E, 0x08, 0x00, 0x83, 0x0E, 0x44, 0x00, 0xC4, 0x0E, 0x41,
+    0x00, 0xC5, 0x0E, 0x09, 0x02, 0xBF, 0x82, 0x82, 0x00, 0xF8, 0x0B, 0xA9,
+    0x00, 0xFB, 0x0B, 0xAC, 0x02, 0xDF, 0x00, 0xC0, 0x0E, 0x40, 0x00, 0x81,
+    0x0B, 0x89, 0x00, 0xC2, 0x0E, 0x08, 0x00, 0x83, 0x0E, 0x44, 0x00, 0xC4,
+    0x0E, 0x41, 0x00, 0xC5, 0x0E, 0x09, 0x02, 0xBF, 0x82, 0x82, 0x00, 0xF8,
+    0x0B, 0xA9, 0x00, 0xFB, 0x0B, 0xAC, 0x00, 0xC0, 0x0E, 0x40, 0x00, 0x81,
+    0x0B, 0x8D, 0x00, 0xC2, 0x0E, 0x0B, 0x00, 0x83, 0x0E, 0x44, 0x00, 0xC4,
+    0x0E, 0x41, 0x00, 0xC5, 0x0E, 0x0C, 0x02, 0xBF, 0x82, 0x82, 0x00, 0xF8,
+    0x0B, 0xAA, 0x00, 0xFB, 0x0B, 0xAD, 0x02, 0xDF, 0x00, 0xC0, 0x0E, 0x40,
+    0x00, 0x81, 0x0B, 0x89, 0x00, 0xC2, 0x0E, 0x08, 0x00, 0x83, 0x0E, 0x44,
+    0x00, 0xC4, 0x0E, 0x41, 0x00, 0xC5, 0x0E, 0x09, 0x02, 0xBF, 0x82, 0x82,
+    0x00, 0xF8, 0x0B, 0xA9, 0x00, 0xFB, 0x0B, 0xAC, 0x00, 0xC0, 0x0E, 0x40,
+    0x00, 0x81, 0x0B, 0x91, 0x00, 0xC2, 0x0E, 0x0E, 0x00, 0x83, 0x0E, 0x44,
+    0x00, 0xC4, 0x0E, 0x41, 0x00, 0xC5, 0x0E, 0x0F, 0x02, 0xBF, 0x82, 0x82,
+    0x00, 0xF8, 0x0B, 0xAB, 0x00, 0xFB, 0x0B, 0xAE, 0x02, 0xDF, 0x00, 0xC0,
+    0x0E, 0x40, 0x00, 0x81, 0x0B, 0x89, 0x00, 0xC2, 0x0E, 0x08, 0x00, 0x83,
+    0x0E, 0x44, 0x00, 0xC4, 0x0E, 0x41, 0x00, 0xC5, 0x0E, 0x09, 0x02, 0xBF,
+    0x82, 0x82, 0x00, 0xF8, 0x0B, 0xA9, 0x00, 0xFB, 0x0B, 0xAC, 0x00, 0xC0,
+    0x0E, 0x40, 0x00, 0x81, 0x0B, 0x8D, 0x00, 0xC2, 0x0E, 0x0B, 0x00, 0x83,
+    0x0E, 0x44, 0x00, 0xC4, 0x0E, 0x41, 0x00, 0xC5, 0x0E, 0x0C, 0x02, 0xBF,
+    0x82, 0x82, 0x00, 0xF8, 0x0B, 0xAA, 0x00, 0xFB, 0x0B, 0xAD, 0x00, 0xC0,
+    0x0E, 0x40, 0x00, 0x81, 0x0B, 0x91, 0x00, 0xC2, 0x0E, 0x0E, 0x00, 0x83,
+    0x0E, 0x44, 0x00, 0xC4, 0x0E, 0x41, 0x00, 0xC5, 0x0E, 0x0F, 0x02, 0xBF,
+    0x82, 0x82, 0x00, 0xF8, 0x0B, 0xAB, 0x00, 0xFB, 0x0B, 0xAE, 0x02, 0xDF,
+    0x00, 0xC0, 0x0E, 0x40, 0x00, 0x81, 0x0B, 0x89, 0x00, 0xC2, 0x0E, 0x08,
+    0x00, 0x83, 0x0E, 0x44, 0x00, 0xC4, 0x0E, 0x41, 0x00, 0xC5, 0x0E, 0x09,
+    0x02, 0xBF, 0x82, 0x82, 0x00, 0xF8, 0x0B, 0xA9, 0x00, 0xFB, 0x0B, 0xAC,
+    0x00, 0xC0, 0x0E, 0x43, 0x00, 0x81, 0x0B, 0x97, 0x00, 0xC2, 0x0E, 0x0A,
+    0x00, 0x83, 0x0E, 0x44, 0x02, 0xBF, 0x84, 0x5D, 0x00, 0xF8, 0x0B, 0xAF,
+    0x02, 0xDF, 0x00, 0xC0, 0x0E, 0x40, 0x00, 0x81, 0x0B, 0x89, 0x00, 0xC2,
+    0x0E, 0x08, 0x00, 0x83, 0x0E, 0x44, 0x00, 0xC4, 0x0E, 0x41, 0x00, 0xC5,
+    0x0E, 0x09, 0x02, 0xBF, 0x82, 0x82, 0x00, 0xF8, 0x0B, 0xA9, 0x00, 0xFB,
+    0x0B, 0xAC, 0x00, 0xC0, 0x0E, 0x40, 0x00, 0x81, 0x0B, 0x8D, 0x00, 0xC2,
+    0x0E, 0x0B, 0x00, 0x83, 0x0E, 0x44, 0x00, 0xC4, 0x0E, 0x41, 0x00, 0xC5,
+    0x0E, 0x0C, 0x02, 0xBF, 0x82, 0x82, 0x00, 0xF8, 0x0B, 0xAA, 0x00, 0xFB,
+    0x0B, 0xAD, 0x00, 0xC0, 0x0E, 0x43, 0x00, 0x81, 0x0B, 0x97, 0x00, 0xC2,
+    0x0E, 0x0A, 0x00, 0x83, 0x0E, 0x44, 0x1C, 0x80, 0x00, 0xC5, 0x0E, 0x0D,
+    0x02, 0xBF, 0x82, 0x82, 0x00, 0xF8, 0x0B, 0xAF, 0x00, 0xFB, 0x0B, 0xB0,
+    0x02, 0xDF, 0x00, 0xC0, 0x0E, 0x40, 0x00, 0x81, 0x0B, 0x89, 0x00, 0xC2,
+    0x0E, 0x08, 0x00, 0x83, 0x0E, 0x44, 0x00, 0xC4, 0x0E, 0x41, 0x00, 0xC5,
+    0x0E, 0x09, 0x02, 0xBF, 0x82, 0x82, 0x00, 0xF8, 0x0B, 0xA9, 0x00, 0xFB,
+    0x0B, 0xAC, 0x00, 0xC0, 0x0E, 0x40, 0x00, 0x81, 0x0B, 0x91, 0x00, 0xC2,
+    0x0E, 0x0E, 0x00, 0x83, 0x0E, 0x44, 0x00, 0xC4, 0x0E, 0x41, 0x00, 0xC5,
+    0x0E, 0x0F, 0x02, 0xBF, 0x82, 0x82, 0x00, 0xF8, 0x0B, 0xAB, 0x00, 0xFB,
+    0x0B, 0xAE, 0x00, 0xC0, 0x0E, 0x43, 0x00, 0x81, 0x0B, 0x95, 0x00, 0xC2,
+    0x0E, 0x10, 0x00, 0x83, 0x0E, 0x44, 0x1C, 0x80, 0x00, 0xC5, 0x0E, 0x0A,
+    0x02, 0xBF, 0x82, 0x82, 0x00, 0xF8, 0x0B, 0xB1, 0x00, 0xFB, 0x0B, 0xAF,
+    0x02, 0xDF, 0x00, 0xC0, 0x0E, 0x40, 0x00, 0x81, 0x0B, 0x89, 0x00, 0xC2,
+    0x0E, 0x08, 0x00, 0x83, 0x0E, 0x44, 0x00, 0xC4, 0x0E, 0x41, 0x00, 0xC5,
+    0x0E, 0x09, 0x02, 0xBF, 0x82, 0x82, 0x00, 0xF8, 0x0B, 0xA9, 0x00, 0xFB,
+    0x0B, 0xAC, 0x00, 0xC0, 0x0E, 0x40, 0x00, 0x81, 0x0B, 0x8D, 0x00, 0xC2,
+    0x0E, 0x0B, 0x00, 0x83, 0x0E, 0x44, 0x00, 0xC0, 0x0E, 0x41, 0x00, 0xC5,
+    0x0E, 0x0C, 0x02, 0xBF, 0x82, 0x82, 0x00, 0xF8, 0x0B, 0xAA, 0x00, 0xFB,
+    0x0B, 0xAD, 0x00, 0xC0, 0x0E, 0x40, 0x00, 0x81, 0x0B, 0x91, 0x00, 0xC2,
+    0x0E, 0x0E, 0x00, 0x83, 0x0E, 0x44, 0x00, 0xC4, 0x0E, 0x41, 0x00, 0xC5,
+    0x0E, 0x0F, 0x02, 0xBF, 0x82, 0x82, 0x00, 0xF8, 0x0B, 0xAB, 0x00, 0xFB,
+    0x0B, 0xAE, 0x00, 0xC0, 0x0E, 0x43, 0x00, 0x81, 0x0B, 0x97, 0x00, 0xC2,
+    0x0E, 0x0A, 0x00, 0x83, 0x0E, 0x44, 0x1C, 0x80, 0x00, 0xC5, 0x0E, 0x0D,
+    0x02, 0xBF, 0x82, 0x82, 0x00, 0xF8, 0x0B, 0xAF, 0x00, 0xFB, 0x0B, 0xB0,
+    0x00, 0xC0, 0x0E, 0x43, 0x00, 0x81, 0x0B, 0x95, 0x00, 0xC2, 0x0E, 0x10,
+    0x00, 0x83, 0x0E, 0x44, 0x02, 0xBF, 0x84, 0x5D, 0x00, 0xF8, 0x0B, 0xB1,
+    0x02, 0xDF, 0x00, 0xC0, 0x0E, 0x40, 0x00, 0x81, 0x0B, 0x89, 0x00, 0xC2,
+    0x0E, 0x08, 0x1C, 0x62, 0x00, 0xC4, 0x0E, 0x41, 0x00, 0xC5, 0x0E, 0x09,
+    0x02, 0xBF, 0x80, 0xE7, 0x00, 0xF8, 0x0B, 0xA9, 0x00, 0xFB, 0x0B, 0xAC,
+    0x00, 0xC0, 0x0E, 0x43, 0x00, 0x81, 0x0B, 0x91, 0x00, 0xC2, 0x0E, 0x0E,
+    0x1C, 0x62, 0x1C, 0x80, 0x00, 0xC5, 0x0E, 0x0F, 0x02, 0xBF, 0x80, 0xE7,
+    0x00, 0xF8, 0x0B, 0xAB, 0x00, 0xFB, 0x0B, 0xAE, 0x02, 0xDF, 0x00, 0xC0,
+    0x0E, 0x40, 0x00, 0x81, 0x0B, 0x89, 0x00, 0xC2, 0x0E, 0x08, 0x1C, 0x62,
+    0x00, 0xC4, 0x0E, 0x41, 0x00, 0xC5, 0x0E, 0x09, 0x02, 0xBF, 0x80, 0xE7,
+    0x00, 0xF8, 0x0B, 0xA9, 0x00, 0xFB, 0x0B, 0xAC, 0x00, 0xC0, 0x0E, 0x43,
+    0x00, 0x81, 0x0B, 0x91, 0x00, 0xC2, 0x0E, 0x0E, 0x1C, 0x62, 0x1C, 0x80,
+    0x00, 0xC5, 0x0E, 0x0F, 0x02, 0xBF, 0x80, 0xE7, 0x00, 0xF8, 0x0B, 0xAB,
+    0x00, 0xFB, 0x0B, 0xAE, 0x00, 0xC0, 0x0E, 0x40, 0x00, 0x81, 0x0B, 0x8D,
+    0x00, 0xC2, 0x0E, 0x0B, 0x1C, 0x62, 0x00, 0xC4, 0x0E, 0x41, 0x00, 0xC5,
+    0x0E, 0x0C, 0x02, 0xBF, 0x80, 0xE7, 0x00, 0xF8, 0x0B, 0xAA, 0x00, 0xFB,
+    0x0B, 0xAD, 0x00, 0xC0, 0x0E, 0x43, 0x00, 0x81, 0x0B, 0x99, 0x00, 0xC2,
+    0x0E, 0x0D, 0x1C, 0x62, 0x02, 0xBF, 0x81, 0xF9, 0x00, 0xF8, 0x0B, 0xB0,
+    0x02, 0xDF, 0x00, 0xC0, 0x0E, 0x40, 0x00, 0x81, 0x0B, 0x89, 0x00, 0xC2,
+    0x0E, 0x08, 0x00, 0x83, 0x0E, 0x44, 0x00, 0xC4, 0x0E, 0x41, 0x00, 0xC5,
+    0x0E, 0x09, 0x02, 0xBF, 0x82, 0x82, 0x00, 0xF8, 0x0B, 0xA9, 0x00, 0xFB,
+    0x0B, 0xAC, 0x00, 0xC0, 0x0E, 0x43, 0x00, 0x81, 0x0B, 0x91, 0x00, 0xC2,
+    0x0E, 0x0E, 0x00, 0x83, 0x0E, 0x44, 0x1C, 0x80, 0x00, 0xC5, 0x0E, 0x0F,
+    0x02, 0xBF, 0x82, 0x82, 0x00, 0xF8, 0x0B, 0xAB, 0x00, 0xFB, 0x0B, 0xAE,
+    0x02, 0xDF, 0x00, 0xC0, 0x0E, 0x40, 0x00, 0x81, 0x0B, 0x89, 0x00, 0xC2,
+    0x0E, 0x08, 0x00, 0x83, 0x0E, 0x44, 0x00, 0xC4, 0x0E, 0x41, 0x00, 0xC5,
+    0x0E, 0x09, 0x02, 0xBF, 0x82, 0x82, 0x00, 0xF8, 0x0B, 0xA9, 0x00, 0xFB,
+    0x0B, 0xAC, 0x00, 0xC0, 0x0E, 0x43, 0x00, 0x81, 0x0B, 0x91, 0x00, 0xC2,
+    0x0E, 0x0E, 0x00, 0x83, 0x0E, 0x44, 0x1C, 0x80, 0x00, 0xC5, 0x0E, 0x0F,
+    0x02, 0xBF, 0x82, 0x82, 0x00, 0xF8, 0x0B, 0xAB, 0x00, 0xFB, 0x0B, 0xAE,
+    0x00, 0xC0, 0x0E, 0x40, 0x00, 0x81, 0x0B, 0x8D, 0x00, 0xC2, 0x0E, 0x0B,
+    0x00, 0x83, 0x0E, 0x44, 0x00, 0xC4, 0x0E, 0x41, 0x00, 0xC5, 0x0E, 0x0C,
+    0x02, 0xBF, 0x82, 0x82, 0x00, 0xF8, 0x0B, 0xAA, 0x00, 0xFB, 0x0B, 0xAD,
+    0x00, 0xC0, 0x0E, 0x43, 0x00, 0x81, 0x0B, 0x99, 0x00, 0xC2, 0x0E, 0x0D,
+    0x00, 0x83, 0x0E, 0x44, 0x02, 0xBF, 0x84, 0x5D, 0x00, 0xF8, 0x0B, 0xB0,
+    0x02, 0xDF, 0x00, 0x82, 0x01, 0x3E, 0x01, 0xBC, 0x02, 0x48, 0x04, 0x13,
+    0x04, 0x27, 0x01, 0x65, 0x05, 0x74, 0x0B, 0x37, 0x01, 0x5F, 0x04, 0x78,
+    0x04, 0x74, 0x04, 0x76, 0x01, 0xA9, 0x04, 0x3B, 0x04, 0x7A, 0x0B, 0xB1,
+    0x01, 0x75, 0x07, 0x68, 0x07, 0x7A, 0x07, 0x9D, 0x07, 0xC0, 0x07, 0xF4,
+    0x08, 0x11, 0x08, 0x44, 0x08, 0x77, 0x08, 0xC6, 0x08, 0xD9, 0x08, 0xFE,
+    0x09, 0x23, 0x09, 0x5A, 0x09, 0x79, 0x09, 0xAF, 0x09, 0xE5, 0x0A, 0x39,
+    0x0A, 0x5B, 0x07, 0x68, 0x07, 0x68, 0x07, 0x68, 0x07, 0x68, 0x07, 0x68,
+    0x07, 0x68, 0x0A, 0x99, 0x0A, 0xBD, 0x07, 0x68, 0x07, 0x68, 0x07, 0x68,
+    0x07, 0x68, 0x07, 0x68, 0x07, 0x68, 0x05, 0xA8, 0x06, 0x5D, 0x07, 0x07,
+    0x10, 0x00, 0x12, 0x00, 0x14, 0x00, 0x8E, 0x00, 0x81, 0x00, 0x89, 0x70,
+    0x19, 0x1C, 0x2E, 0xCE, 0x2C, 0xCF, 0x16, 0xCD, 0x0E, 0x80, 0x16, 0xC9,
+    0x00, 0x00, 0x16, 0xCB, 0x01, 0x00, 0x1F, 0x7E, 0x1F, 0x3C, 0x81, 0x00,
+    0x26, 0xC9, 0x02, 0xA0, 0x00, 0x04, 0x02, 0x9C, 0x0B, 0x46, 0x19, 0x1E,
+    0x19, 0x1C, 0x2E, 0xCE, 0x2C, 0xCF, 0x16, 0xCD, 0x02, 0x80, 0x16, 0xC9,
+    0x00, 0x00, 0x16, 0xCB, 0x02, 0x80, 0x1C, 0x80, 0x00, 0x80, 0x02, 0x80,
+    0x00, 0xC1, 0x0E, 0x1B, 0x00, 0x85, 0x00, 0x00, 0x00, 0x89, 0x00, 0x7F,
+    0x00, 0x82, 0x0F, 0x00, 0x00, 0x83, 0x16, 0xB4, 0x1C, 0xE3, 0x81, 0x00,
+    0x26, 0xC9, 0x02, 0xA0, 0x00, 0x04, 0x02, 0x9C, 0x0B, 0x64, 0x8F, 0x00,
+    0x8A, 0x78, 0x8C, 0x68, 0xF1, 0x00, 0x1A, 0x3F, 0x84, 0xE3, 0x10, 0x7E,
+    0xF2, 0xE3, 0xF2, 0xE7, 0xF2, 0x78, 0x6E, 0x68, 0xF1, 0x32, 0x1A, 0x3F,
+    0x11, 0x9E, 0x0B, 0x80, 0x1C, 0x67, 0x84, 0xE3, 0x10, 0x7E, 0xF2, 0xE3,
+    0xF2, 0xE7, 0xF2, 0x78, 0x6E, 0x68, 0xF1, 0x32, 0x1A, 0x3F, 0x1C, 0x67,
+    0x84, 0xE3, 0x10, 0x7E, 0xF2, 0xE3, 0xF2, 0xE7, 0xF2, 0x00, 0x6E, 0x00,
+    0x1B, 0x5E, 0x00, 0xE1, 0x0E, 0x1B, 0x00, 0x80, 0x02, 0x80, 0x00, 0x83,
+    0x0F, 0x00, 0x00, 0x81, 0x00, 0x00, 0x00, 0x82, 0x01, 0x40, 0x00, 0x89,
+    0xFF, 0xFF, 0x89, 0x00, 0x81, 0x00, 0x8F, 0x00, 0x11, 0xA0, 0x0B, 0xA0,
+    0x19, 0x7F, 0x99, 0x30, 0x1B, 0x1E, 0x1B, 0x3F, 0x7D, 0x29, 0x1B, 0x5F,
+    0x1B, 0x5D, 0x8E, 0x00, 0x1F, 0xDB, 0x1F, 0x99, 0x2E, 0xCE, 0x2C, 0xCF,
+    0x16, 0xCD, 0x0E, 0x80, 0x16, 0xC9, 0x00, 0x01, 0x16, 0xCB, 0x01, 0x00,
+    0x02, 0xBF, 0x05, 0x5C, 0x1C, 0x04, 0x02, 0x9F, 0x00, 0x68, 0x8E, 0x00,
+    0x81, 0x00, 0x89, 0x70, 0x19, 0x1C, 0x2E, 0xCE, 0x2C, 0xCF, 0x16, 0xCD,
+    0x07, 0xC0, 0x16, 0xC9, 0x00, 0x01, 0x16, 0xCB, 0x05, 0x00, 0x02, 0xBF,
+    0x05, 0x5C, 0x81, 0x00, 0x89, 0x70, 0x19, 0x1C, 0x2E, 0xCE, 0x2C, 0xCF,
+    0x16, 0xCD, 0x07, 0xC0, 0x16, 0xC9, 0x00, 0x00, 0x89, 0x00, 0x0D, 0x20,
+    0x2D, 0xCB, 0x4C, 0x00, 0x1C, 0x80, 0x00, 0x80, 0x07, 0xC0, 0x00, 0x83,
+    0x00, 0x00, 0x1C, 0x43, 0x0A, 0x00, 0x27, 0xC9, 0x03, 0xA0, 0x00, 0x04,
+    0x02, 0x9C, 0x0B, 0xD3, 0x2E, 0xCE, 0x2C, 0xCF, 0x16, 0xCD, 0x07, 0xD0,
+    0x16, 0xC9, 0x00, 0x00, 0x16, 0xCB, 0x04, 0xE0, 0x8F, 0x00, 0x80, 0xF0,
+    0x80, 0xC0, 0x6A, 0x00, 0x48, 0x00, 0x11, 0x4F, 0x0B, 0xEE, 0x80, 0xF0,
+    0x80, 0xC0, 0x6B, 0x32, 0x49, 0x22, 0x80, 0xF0, 0x80, 0xC0, 0x6A, 0x3A,
+    0x48, 0x2A, 0x80, 0xF0, 0x80, 0xC0, 0x6B, 0x32, 0x49, 0x22, 0x1B, 0x5F,
+    0x1B, 0x5D, 0x80, 0xF0, 0x80, 0xC0, 0x68, 0x00, 0x7C, 0x00, 0x4A, 0x00,
+    0x11, 0x4F, 0x0C, 0x05, 0x80, 0xF0, 0x80, 0xC0, 0x69, 0x32, 0x7D, 0x00,
+    0x4B, 0x22, 0x80, 0xF0, 0x80, 0xC0, 0x68, 0x3A, 0x7C, 0x00, 0x4A, 0x2A,
+    0x80, 0xF0, 0x80, 0xC0, 0x69, 0x32, 0x7D, 0x00, 0x4B, 0x22, 0x1B, 0x5F,
+    0x1B, 0x5D, 0x1C, 0x04, 0x02, 0x9F, 0x00, 0x68, 0x8E, 0x00, 0x16, 0xFC,
+    0xEC, 0xC0, 0x1F, 0xCC, 0x1D, 0x9E, 0x2E, 0xFD, 0x26, 0xFC, 0x02, 0xA0,
+    0x80, 0x00, 0x02, 0x9C, 0x0C, 0x16, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x02, 0xFF, 0x8E, 0x00, 0x00, 0xF0, 0x0E, 0x17, 0x00, 0xFE, 0x0E, 0x18,
+    0x00, 0xFC, 0x0E, 0x19, 0x1F, 0xCC, 0x1D, 0x9E, 0x16, 0xFC, 0xFE, 0xED,
+    0x2E, 0xFD, 0x26, 0xFC, 0x02, 0xA0, 0x80, 0x00, 0x02, 0x9C, 0x0C, 0x2B,
+    0x00, 0xD0, 0x0E, 0x17, 0x00, 0xDE, 0x0E, 0x18, 0x00, 0xDC, 0x0E, 0x19,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xFF, 0x8E, 0x00,
+    0x1D, 0xBC, 0x1D, 0xBE, 0x81, 0x00, 0x00, 0xDE, 0x0B, 0xB7, 0x06, 0x01,
+    0x02, 0x95, 0x0C, 0x47, 0x0E, 0x00, 0x00, 0xFE, 0x0B, 0x87, 0x1F, 0xCD,
+    0x1F, 0x8D, 0x02, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x02, 0xFF, 0x8E, 0x00, 0x1D, 0xBC, 0x1D, 0xBE, 0x81, 0x00,
+    0x00, 0xDE, 0x0B, 0xB7, 0x06, 0x01, 0x02, 0x95, 0x0C, 0x5F, 0x0E, 0x00,
+    0x00, 0xFE, 0x0B, 0x87, 0x1F, 0xCD, 0x1F, 0x8D, 0x02, 0xFF, 0x81, 0x00,
+    0x00, 0xDE, 0x0B, 0x88, 0x06, 0x01, 0x02, 0x95, 0x0C, 0x71, 0x00, 0xDE,
+    0x0B, 0xDA, 0x2E, 0xDA, 0x00, 0xDE, 0x0B, 0xDB, 0x2E, 0xDB, 0x00, 0xDE,
+    0x0B, 0xDC, 0x2E, 0xDC, 0x1F, 0xCD, 0x1F, 0x8D, 0x02, 0xFF, 0x00, 0xDE,
+    0x0B, 0xDA, 0x2E, 0xDA, 0x26, 0xDB, 0x2E, 0xDB, 0x26, 0xDC, 0x2E, 0xDC,
+    0x81, 0x00, 0x00, 0xDC, 0x0B, 0xDD, 0x76, 0x00, 0x00, 0xFC, 0x0B, 0xDD,
+    0x81, 0x00, 0x1F, 0xCD, 0x1F, 0x8D, 0x02, 0xFF, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xFF, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x02, 0xFF, 0x0C, 0x9F, 0x0C, 0xA2, 0x0C, 0xDA,
+    0x0C, 0xDD, 0x8E, 0x00, 0x81, 0x00, 0x89, 0x00, 0x02, 0xBF, 0x0C, 0xE0,
+    0x27, 0xFF, 0x00, 0x9E, 0x0C, 0x8D, 0x4C, 0x00, 0x1C, 0x7E, 0x03, 0x13,
+    0x1C, 0x7F, 0x17, 0x6F, 0x00, 0x21, 0x02, 0x9F, 0x00, 0x30, 0x00, 0x21,
+    0x81, 0x00, 0x89, 0x00, 0x02, 0xBF, 0x0C, 0xE0, 0x24, 0xFF, 0x02, 0xBF,
+    0x0C, 0xE6, 0x25, 0xFF, 0x02, 0xBF, 0x0C, 0xE6, 0x27, 0xFF, 0x2E, 0xCE,
+    0x2C, 0xCF, 0x16, 0xC9, 0x00, 0x01, 0x2F, 0xCD, 0x2D, 0xCB, 0x81, 0x00,
+    0x89, 0x00, 0x02, 0xBF, 0x0C, 0xE0, 0x24, 0xFF, 0x1C, 0x9E, 0x1C, 0xBC,
+    0x02, 0xBF, 0x0C, 0xE6, 0x25, 0xFF, 0x02, 0xBF, 0x0C, 0xE6, 0x27, 0xFF,
+    0x1C, 0xDF, 0x1C, 0xFD, 0x81, 0x00, 0x02, 0xBF, 0x0C, 0xE0, 0x26, 0xFF,
+    0x1C, 0x1E, 0x89, 0x00, 0x02, 0xBF, 0x0C, 0xE6, 0x20, 0xFF, 0x1F, 0x5F,
+    0x02, 0xBF, 0x0C, 0xE0, 0x21, 0xFF, 0x02, 0xBF, 0x0C, 0xE0, 0x23, 0xFF,
+    0x26, 0xC9, 0x02, 0xA0, 0x00, 0x04, 0x02, 0x9C, 0x0C, 0xD2, 0x02, 0x9F,
+    0x80, 0xB5, 0x00, 0x21, 0x02, 0x9F, 0x80, 0x00, 0x00, 0x21, 0x02, 0x9F,
+    0x00, 0x45, 0x00, 0x21, 0x26, 0xFE, 0x02, 0xC0, 0x80, 0x00, 0x02, 0x9C,
+    0x0C, 0xE0, 0x02, 0xDF, 0x27, 0xFE, 0x03, 0xC0, 0x80, 0x00, 0x02, 0x9C,
+    0x0C, 0xE6, 0x02, 0xDF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 };
 
 short dspSlaveLength = sizeof(dspSlave);
+
 #ifdef __cplusplus
 }
 #endif

src/musyx/snd3d.c

@@ -3,6 +3,7 @@
 #ifdef __cplusplus
 extern "C" {
 #endif
+
 s8 s3dCallCnt;
 s32 s3dDoorRoot;
 s32 s3dEmitterRoot;
@@ -13,7 +14,6 @@ s8 snd_base_studio;
 s8 snd_max_studios;
 s32 snd_used_studios;
 
-
 void s3dInit(s32 flags) {
   s3dEmitterRoot = 0;
   s3dListenerRoot = 0;
@@ -26,10 +26,7 @@ void s3dInit(s32 flags) {
   s3dUseMaxVoices = (flags >> 1) & 1;
 }
 
-
+void s3dExit() {}
-void s3dExit() {
-    
-}
 
 #ifdef __cplusplus
 extern "C" {

src/musyx/snd_init.c

@@ -4,6 +4,7 @@
 #ifdef __cplusplus
 extern "C" {
 #endif
+
 /* TODO: Move these to a more approprate location */
 extern s8 sndActive;
 extern s8 synthIdleWaitActive;
@@ -48,7 +49,6 @@ s32 sndInit(u8 voices, u8 music, u8 sfx, u8 studios, s32 flags, s32 aramSize) {
   return ret;
 }
 
-
 void sndQuit() {
   hwExit();
   dataExit();

src/os/__ppc_eabi_init.c

@@ -4,6 +4,7 @@ extern void __OSPSInit();
 extern void __OSCacheInit();
 
 asm void __init_hardware(void) {
+// clang-format off
   nofralloc
   mfmsr r0
   ori r0, r0, 0x2000
@@ -14,9 +15,11 @@ asm void __init_hardware(void) {
   bl __OSCacheInit
   mtlr r31
   blr
+// clang-format on
 }
 
 asm void __flush_cache(register void* address, register unsigned int size) {
+// clang-format off
   nofralloc
   lis r5,  0xFFFF
   ori r5, r5, 0xFFF1
@@ -33,6 +36,7 @@ loop:
   bge loop
   isync
   blr
+// clang-format on
 }
 
 #if 0

src/os/__start.c

@@ -1,17 +1,14 @@
 #include "Dolphin/__start.h"
 
-void __check_pad3(void)
+void __check_pad3(void) {
-{
   if ((Pad3Button & 0x0eef) == 0x0eef) {
     OSResetSystem(OS_RESET_RESTART, 0, FALSE);
   }
   return;
 }
 
+__declspec (weak) asm void __start(void) {
 // clang-format off
-
-__declspec (weak) asm void __start(void)
-{
 	nofralloc
 	bl __init_registers
 	bl __init_hardware
@@ -111,10 +108,11 @@ _goto_skip_init_bba:
 	mr r4, r15
 	bl main
 	b exit
+// clang-format on
 }
 
-asm static void __init_registers(void)
+asm static void __init_registers(void) {
-{
+// clang-format off
 	nofralloc
 	lis r1,  _stack_addr@h
 	ori r1, r1,  _stack_addr@l
@@ -123,31 +121,28 @@ asm static void __init_registers(void)
 	lis r13, _SDA_BASE_@h
 	ori r13, r13, _SDA_BASE_@l
 	blr
+// clang-format on
 }
 
 __declspec(section ".init") extern __rom_copy_info _rom_copy_info[];
 __declspec(section ".init") extern __bss_init_info _bss_init_info[];
 
-// clang-format on
+inline static void __copy_rom_section(void* dst, const void* src,
-
+                                      unsigned long size) {
-inline static void __copy_rom_section(void* dst, const void* src, unsigned long size)
-{
   if (size && (dst != src)) {
     memcpy(dst, src, size);
     __flush_cache(dst, size);
   }
 }
 
-inline static void __init_bss_section(void* dst, unsigned long size)
+inline static void __init_bss_section(void* dst, unsigned long size) {
-{
   if (size) {
     memset(dst, 0, size);
   }
 }
 
 #pragma scheduling off
-void __init_data(void)
+void __init_data(void) {
-{
   __rom_copy_info* dci;
   __bss_init_info* bii;
 

tools/asmdiff.sh

@@ -1,4 +1,4 @@
-#!/bin/bash
+#!/bin/bash -e
 
 OBJDUMP="$DEVKITPPC/bin/powerpc-eabi-objdump -D -bbinary -EB -mpowerpc -M gekko"
 OPTIONS="--start-address=$(($1)) --stop-address=$(($1 + $2))"

tools/clang-format.sh

@@ -0,0 +1,15 @@
+#!/bin/bash -e
+
+function add_newline {
+    if [[ -z "$(tail -c 1 "$1")" ]]; then
+        :
+    else
+        echo >> "$1"
+    fi
+}
+
+FILES=$(git ls-files -o "*.h" "*.hpp" "*.c" "*.cpp")
+clang-format -i ${FILES}
+for f in ${FILES}; do
+    add_newline $f
+done

tools/decompctx.py

@@ -0,0 +1,68 @@
+#!/usr/bin/env python3
+
+import argparse
+import os
+import re
+
+script_dir = os.path.dirname(os.path.realpath(__file__))
+root_dir = os.path.abspath(os.path.join(script_dir, ".."))
+src_dir = os.path.join(root_dir, "src")
+include_dir = os.path.join(root_dir, "include")
+
+include_pattern = re.compile(r'^#include\s*[<"](.+?)[>"]$')
+guard_pattern = re.compile(r'^#ifndef\s+(.*)$')
+
+defines = set()
+
+def import_h_file(in_file, r_path) -> str:
+    rel_path = os.path.join(root_dir, r_path, in_file)
+    inc_path = os.path.join(include_dir, in_file)
+    if os.path.exists(rel_path):
+      return import_c_file(rel_path)
+    elif os.path.exists(inc_path):
+      return import_c_file(inc_path)
+    else:
+      print("Failed to locate", in_file)
+      exit(1)
+
+def import_c_file(in_file) -> str:
+    in_file = os.path.relpath(in_file, root_dir)
+    out_text = ''
+
+    with open(in_file) as file:
+      for idx, line in enumerate(file):
+        guard_match = guard_pattern.match(line.strip())
+        if idx == 0:
+          if guard_match:
+            if guard_match[1] in defines:
+              break
+            defines.add(guard_match[1])
+          print("Processing file", in_file)
+        include_match = include_pattern.match(line.strip())
+        if include_match:
+          out_text += f"/* \"{in_file}\" line {idx} \"{include_match[1]}\" */\n"
+          out_text += import_h_file(include_match[1], os.path.dirname(in_file))
+          out_text += f"/* end \"{include_match[1]}\" */\n"
+        else:
+          out_text += line
+
+    return out_text
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="""Create a context file which can be used for decomp.me"""
+    )
+    parser.add_argument(
+        "c_file",
+        help="""File from which to create context""",
+    )
+    args = parser.parse_args()
+
+    output = import_c_file(args.c_file)
+
+    with open(os.path.join(root_dir, "ctx.c"), "w", encoding="UTF-8") as f:
+        f.write(output)
+
+
+if __name__ == "__main__":
+    main()

tools/elf2dol.c

@@ -1,7 +1,7 @@
-#include <stdlib.h>
-#include <stdio.h>
-#include <stdint.h>
 #include <errno.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
 #include <string.h>
 #include <sys/param.h>
 
@@ -15,7 +15,7 @@
 #define MIN(a, b) (((a) < (b)) ? (a) : (b))
 #endif
 
-#define ARRAY_COUNT(arr) (sizeof(arr)/sizeof((arr)[0]))
+#define ARRAY_COUNT(arr) (sizeof(arr) / sizeof((arr)[0]))
 
 #define EI_NIDENT 16
 
@@ -74,18 +74,12 @@ int verbosity = 0;
 
 #else
 
-static inline uint32_t swap32(uint32_t v)
+static inline uint32_t swap32(uint32_t v) {
-{
+  return (v >> 24) | ((v >> 8) & 0x0000FF00) | ((v << 8) & 0x00FF0000) |
-	return (v >> 24) |
-	       ((v >> 8)  & 0x0000FF00) |
-	       ((v << 8)  & 0x00FF0000) |
          (v << 24);
 }
 
-static inline uint16_t swap16(uint16_t v)
+static inline uint16_t swap16(uint16_t v) { return (v >> 8) | (v << 8); }
-{
-	return (v >> 8) | (v << 8);
-}
 
 #endif /* BIG_ENDIAN */
 
@@ -119,11 +113,10 @@ typedef struct {
   uint32_t text_elf_off[7];
   uint32_t data_elf_off[11];
   uint32_t flags;
-	FILE *elf;
+  FILE* elf;
 } DOL_map;
 
-void usage(const char *name)
+void usage(const char* name) {
-{
   fprintf(stderr, "Usage: %s [-h] [-v] [--] elf-file dol-file\n", name);
   fprintf(stderr, " Convert an ELF file to a DOL file (by segments)\n");
   fprintf(stderr, " Options:\n");
@@ -131,15 +124,22 @@ void usage(const char *name)
   fprintf(stderr, "  -v    Be more verbose (twice for even more)\n");
 }
 
-#define die(x) { fprintf(stderr, x "\n"); exit(1); }
+#define die(x)                                                                 \
-#define perrordie(x) { perror(x); exit(1); }
+  {                                                                            \
+    fprintf(stderr, x "\n");                                                   \
+    exit(1);                                                                   \
+  }
+#define perrordie(x)                                                           \
+  {                                                                            \
+    perror(x);                                                                 \
+    exit(1);                                                                   \
+  }
 
-void ferrordie(FILE *f, const char *str)
+void ferrordie(FILE* f, const char* str) {
-{
+  if (ferror(f)) {
-	if(ferror(f)) {
     fprintf(stderr, "Error while ");
     perrordie(str);
-	} else if(feof(f)) {
+  } else if (feof(f)) {
     fprintf(stderr, "EOF while %s\n", str);
     exit(1);
   } else {
@@ -148,9 +148,8 @@ void ferrordie(FILE *f, const char *str)
   }
 }
 
-void add_bss(DOL_map *map, uint32_t paddr, uint32_t memsz)
+void add_bss(DOL_map* map, uint32_t paddr, uint32_t memsz) {
-{
+  if (map->flags & HAVE_BSS) {
-	if(map->flags & HAVE_BSS) {
     uint32_t curr_start = swap32(map->header.bss_addr);
     uint32_t curr_size = swap32(map->header.bss_size);
     if (paddr < curr_start)
@@ -166,87 +165,88 @@ void add_bss(DOL_map *map, uint32_t paddr, uint32_t memsz)
   }
 }
 
-void read_elf_segments(DOL_map *map, const char *elf)
+void read_elf_segments(DOL_map* map, const char* elf) {
-{
   int read, i;
   Elf32_Ehdr ehdr;
 
-	if(verbosity >= 2)
+  if (verbosity >= 2)
     fprintf(stderr, "Reading ELF file...\n");
 
   map->elf = fopen(elf, "rb");
-	if(!map->elf)
+  if (!map->elf)
     perrordie("Could not open ELF file");
 
   read = fread(&ehdr, sizeof(ehdr), 1, map->elf);
-	if(read != 1)
+  if (read != 1)
     ferrordie(map->elf, "reading ELF header");
 
-	if(memcmp(&ehdr.e_ident[0], "\177ELF", 4))
+  if (memcmp(&ehdr.e_ident[0], "\177ELF", 4))
     die("Invalid ELF header");
-	if(ehdr.e_ident[EI_CLASS] != ELFCLASS32)
+  if (ehdr.e_ident[EI_CLASS] != ELFCLASS32)
     die("Invalid ELF class");
-	if(ehdr.e_ident[EI_DATA] != ELFDATA2MSB)
+  if (ehdr.e_ident[EI_DATA] != ELFDATA2MSB)
     die("Invalid ELF byte order");
-	if(ehdr.e_ident[EI_VERSION] != EV_CURRENT)
+  if (ehdr.e_ident[EI_VERSION] != EV_CURRENT)
     die("Invalid ELF ident version");
-	if(swap32(ehdr.e_version) != EV_CURRENT)
+  if (swap32(ehdr.e_version) != EV_CURRENT)
     die("Invalid ELF version");
-	if(swap16(ehdr.e_type) != ET_EXEC)
+  if (swap16(ehdr.e_type) != ET_EXEC)
     die("ELF is not an executable");
-	if(swap16(ehdr.e_machine) != EM_PPC)
+  if (swap16(ehdr.e_machine) != EM_PPC)
     die("Machine is not PowerPC");
-	if(!swap32(ehdr.e_entry))
+  if (!swap32(ehdr.e_entry))
     die("ELF has no entrypoint");
 
   map->header.entry = ehdr.e_entry;
 
-	if(verbosity >= 2)
+  if (verbosity >= 2)
     fprintf(stderr, "Valid ELF header found\n");
 
   uint16_t phnum = swap16(ehdr.e_phnum);
   uint32_t phoff = swap32(ehdr.e_phoff);
-	Elf32_Phdr *phdrs;
+  Elf32_Phdr* phdrs;
 
-	if(!phnum || !phoff)
+  if (!phnum || !phoff)
     die("ELF has no program headers");
 
-	if(swap16(ehdr.e_phentsize) != sizeof(Elf32_Phdr))
+  if (swap16(ehdr.e_phentsize) != sizeof(Elf32_Phdr))
     die("Invalid program header entry size");
 
   phdrs = malloc(phnum * sizeof(Elf32_Phdr));
 
-	if(fseek(map->elf, phoff, SEEK_SET) < 0)
+  if (fseek(map->elf, phoff, SEEK_SET) < 0)
     ferrordie(map->elf, "reading ELF program headers");
   read = fread(phdrs, sizeof(Elf32_Phdr), phnum, map->elf);
-	if(read != phnum)
+  if (read != phnum)
     ferrordie(map->elf, "reading ELF program headers");
 
-	for(i=0; i<phnum; i++) {
+  for (i = 0; i < phnum; i++) {
-		if(swap32(phdrs[i].p_type) == PT_LOAD) {
+    if (swap32(phdrs[i].p_type) == PT_LOAD) {
       uint32_t offset = swap32(phdrs[i].p_offset);
       uint32_t paddr = swap32(phdrs[i].p_vaddr);
       uint32_t filesz = swap32(phdrs[i].p_filesz);
       uint32_t memsz = swap32(phdrs[i].p_memsz);
       uint32_t flags = swap32(phdrs[i].p_flags);
-			if(memsz) {
+      if (memsz) {
-				if(verbosity >= 2)
+        if (verbosity >= 2)
           fprintf(stderr, "PHDR %d: 0x%x [0x%x] -> 0x%08x [0x%x] flags 0x%x\n",
                   i, offset, filesz, paddr, memsz, flags);
-				if(flags & PF_X) {
+        if (flags & PF_X) {
           // TEXT segment
-					if(!(flags & PF_R))
+          if (!(flags & PF_R))
             fprintf(stderr, "Warning: non-readable segment %d\n", i);
-					if(flags & PF_W)
+          if (flags & PF_W)
             fprintf(stderr, "Warning: writable and executable segment %d\n", i);
-					if(filesz > memsz) {
+          if (filesz > memsz) {
-							fprintf(stderr, "Error: TEXT segment %d memory size (0x%x) smaller than file size (0x%x)\n",
+            fprintf(stderr,
+                    "Error: TEXT segment %d memory size (0x%x) smaller than "
+                    "file size (0x%x)\n",
                     i, memsz, filesz);
             exit(1);
           } else if (memsz > filesz) {
             add_bss(map, paddr + filesz, memsz - filesz);
           }
-					if(map->text_cnt >= MAX_TEXT_SEGMENTS) {
+          if (map->text_cnt >= MAX_TEXT_SEGMENTS) {
             die("Error: Too many TEXT segments");
           }
           map->header.text_addr[map->text_cnt] = swap32(paddr);
@@ -255,19 +255,21 @@ void read_elf_segments(DOL_map *map, const char *elf)
           map->text_cnt++;
         } else {
           // DATA or BSS segment
-					if(!(flags & PF_R))
+          if (!(flags & PF_R))
             fprintf(stderr, "Warning: non-readable segment %d\n", i);
-					if(filesz == 0) {
+          if (filesz == 0) {
             // BSS segment
             add_bss(map, paddr, memsz);
           } else {
             // DATA segment
-						if(filesz > memsz) {
+            if (filesz > memsz) {
-							fprintf(stderr, "Error: segment %d memory size (0x%x) is smaller than file size (0x%x)\n",
+              fprintf(stderr,
+                      "Error: segment %d memory size (0x%x) is smaller than "
+                      "file size (0x%x)\n",
                       i, memsz, filesz);
               exit(1);
             }
-						if(map->data_cnt >= MAX_DATA_SEGMENTS) {
+            if (map->data_cnt >= MAX_DATA_SEGMENTS) {
               die("Error: Too many DATA segments");
             }
             map->header.data_addr[map->data_cnt] = swap32(paddr);
@@ -278,92 +280,94 @@ void read_elf_segments(DOL_map *map, const char *elf)
         }
 
       } else {
-				if(verbosity >= 1)
+        if (verbosity >= 1)
           fprintf(stderr, "Skipping empty program header %d\n", i);
       }
-		} else if(verbosity >= 1) {
+    } else if (verbosity >= 1) {
-			fprintf(stderr, "Skipping program header %d of type %d\n", i, swap32(phdrs[i].p_type));
+      fprintf(stderr, "Skipping program header %d of type %d\n", i,
+              swap32(phdrs[i].p_type));
     }
   }
-	if(verbosity >= 2) {
+  if (verbosity >= 2) {
     fprintf(stderr, "Segments:\n");
-		for(i=0; i<map->text_cnt; i++) {
+    for (i = 0; i < map->text_cnt; i++) {
-			fprintf(stderr, " TEXT %d: 0x%08x [0x%x] from ELF offset 0x%x\n",
+      fprintf(stderr, " TEXT %d: 0x%08x [0x%x] from ELF offset 0x%x\n", i,
-			        i, swap32(map->header.text_addr[i]), swap32(map->header.text_size[i]),
+              swap32(map->header.text_addr[i]),
-			        map->text_elf_off[i]);
+              swap32(map->header.text_size[i]), map->text_elf_off[i]);
     }
-		for(i=0; i<map->data_cnt; i++) {
+    for (i = 0; i < map->data_cnt; i++) {
-			fprintf(stderr, " DATA %d: 0x%08x [0x%x] from ELF offset 0x%x\n",
+      fprintf(stderr, " DATA %d: 0x%08x [0x%x] from ELF offset 0x%x\n", i,
-			        i, swap32(map->header.data_addr[i]), swap32(map->header.data_size[i]),
+              swap32(map->header.data_addr[i]),
-			        map->data_elf_off[i]);
+              swap32(map->header.data_size[i]), map->data_elf_off[i]);
     }
-		if(map->flags & HAVE_BSS)
+    if (map->flags & HAVE_BSS)
-			fprintf(stderr, " BSS segment: 0x%08x [0x%x]\n", swap32(map->header.bss_addr),
+      fprintf(stderr, " BSS segment: 0x%08x [0x%x]\n",
-			        swap32(map->header.bss_size));
+              swap32(map->header.bss_addr), swap32(map->header.bss_size));
   }
 }
 
-void map_dol(DOL_map *map)
+void map_dol(DOL_map* map) {
-{
   uint32_t fpos;
   int i;
 
-	if(verbosity >= 2)
+  if (verbosity >= 2)
     fprintf(stderr, "Laying out DOL file...\n");
 
   fpos = DOL_ALIGN(sizeof(DOL_hdr));
 
-	for(i=0; i<map->text_cnt; i++) {
+  for (i = 0; i < map->text_cnt; i++) {
-		if(verbosity >= 2)
+    if (verbosity >= 2)
       fprintf(stderr, " TEXT segment %d at 0x%x\n", i, fpos);
     map->header.text_off[i] = swap32(fpos);
     fpos = DOL_ALIGN(fpos + swap32(map->header.text_size[i]));
   }
-	for(i=0; i<map->data_cnt; i++) {
+  for (i = 0; i < map->data_cnt; i++) {
-		if(verbosity >= 2)
+    if (verbosity >= 2)
       fprintf(stderr, " DATA segment %d at 0x%x\n", i, fpos);
     map->header.data_off[i] = swap32(fpos);
     fpos = DOL_ALIGN(fpos + swap32(map->header.data_size[i]));
   }
 
-	if(map->text_cnt == 0) {
+  if (map->text_cnt == 0) {
-		if(verbosity >= 1)
+    if (verbosity >= 1)
-			fprintf(stderr, "Note: adding dummy TEXT segment to work around IOS bug\n");
+      fprintf(stderr,
+              "Note: adding dummy TEXT segment to work around IOS bug\n");
     map->header.text_off[0] = swap32(DOL_ALIGN(sizeof(DOL_hdr)));
   }
-	if(map->data_cnt == 0) {
+  if (map->data_cnt == 0) {
-		if(verbosity >= 1)
+    if (verbosity >= 1)
-			fprintf(stderr, "Note: adding dummy DATA segment to work around IOS bug\n");
+      fprintf(stderr,
+              "Note: adding dummy DATA segment to work around IOS bug\n");
     map->header.data_off[0] = swap32(DOL_ALIGN(sizeof(DOL_hdr)));
   }
 }
 
-#define BLOCK (1024*1024)
+#define BLOCK (1024 * 1024)
 
-void fcpy(FILE *dst, FILE *src, uint32_t dst_off, uint32_t src_off, uint32_t size)
+void fcpy(FILE* dst, FILE* src, uint32_t dst_off, uint32_t src_off,
-{
+          uint32_t size) {
   int left = size;
   int read;
   int written;
   int block;
-	void *blockbuf;
+  void* blockbuf;
 
-	if(fseek(src, src_off, SEEK_SET) < 0)
+  if (fseek(src, src_off, SEEK_SET) < 0)
     ferrordie(src, "reading ELF segment data");
-	if(fseek(dst, dst_off, SEEK_SET) < 0)
+  if (fseek(dst, dst_off, SEEK_SET) < 0)
     ferrordie(dst, "writing DOL segment data");
 
   blockbuf = malloc(MIN(BLOCK, left));
 
-	while(left) {
+  while (left) {
     block = MIN(BLOCK, left);
     read = fread(blockbuf, 1, block, src);
-		if(read != block) {
+    if (read != block) {
       free(blockbuf);
       ferrordie(src, "reading ELF segment data");
     }
     written = fwrite(blockbuf, 1, block, dst);
-		if(written != block) {
+    if (written != block) {
       free(blockbuf);
       ferrordie(dst, "writing DOL segment data");
     }
@@ -372,40 +376,40 @@ void fcpy(FILE *dst, FILE *src, uint32_t dst_off, uint32_t src_off, uint32_t siz
   free(blockbuf);
 }
 
-void fpad(FILE *dst, uint32_t dst_off, uint32_t size)
+void fpad(FILE* dst, uint32_t dst_off, uint32_t size) {
-{
   uint32_t i;
 
-	if(fseek(dst, dst_off, SEEK_SET) < 0)
+  if (fseek(dst, dst_off, SEEK_SET) < 0)
     ferrordie(dst, "writing DOL segment data");
-	for(i=0; i<size; i++)
+  for (i = 0; i < size; i++)
     fputc(0, dst);
 }
 
-void write_dol(DOL_map *map, const char *dol)
+void write_dol(DOL_map* map, const char* dol) {
-{
+  FILE* dolf;
-	FILE *dolf;
   int written;
   int i;
 
-	if(verbosity >= 2)
+  if (verbosity >= 2)
     fprintf(stderr, "Writing DOL file...\n");
 
   dolf = fopen(dol, "wb");
-	if(!dolf)
+  if (!dolf)
     perrordie("Could not open DOL file");
 
-	if(verbosity >= 2) {
+  if (verbosity >= 2) {
     fprintf(stderr, "DOL header:\n");
-		for(i=0; i<MAX(1,map->text_cnt); i++)
+    for (i = 0; i < MAX(1, map->text_cnt); i++)
       fprintf(stderr, " TEXT %d @ 0x%08x [0x%x] off 0x%x\n", i,
-			        swap32(map->header.text_addr[i]), swap32(map->header.text_size[i]),
+              swap32(map->header.text_addr[i]),
+              swap32(map->header.text_size[i]),
               swap32(map->header.text_off[i]));
-		for(i=0; i<MAX(1,map->data_cnt); i++)
+    for (i = 0; i < MAX(1, map->data_cnt); i++)
       fprintf(stderr, " DATA %d @ 0x%08x [0x%x] off 0x%x\n", i,
-			        swap32(map->header.data_addr[i]), swap32(map->header.data_size[i]),
+              swap32(map->header.data_addr[i]),
+              swap32(map->header.data_size[i]),
               swap32(map->header.data_off[i]));
-		if(swap32(map->header.bss_addr) && swap32(map->header.bss_size))
+    if (swap32(map->header.bss_addr) && swap32(map->header.bss_size))
       fprintf(stderr, " BSS @ 0x%08x [0x%x]\n", swap32(map->header.bss_addr),
               swap32(map->header.bss_size));
     fprintf(stderr, " Entry: 0x%08x\n", swap32(map->header.entry));
@@ -414,58 +418,61 @@ void write_dol(DOL_map *map, const char *dol)
 
   // Write DOL header with aligned text and data section sizes
   DOL_hdr aligned_header = map->header;
-	for(i=0; i<ARRAY_COUNT(aligned_header.text_size); i++)
+  for (i = 0; i < ARRAY_COUNT(aligned_header.text_size); i++)
-		aligned_header.text_size[i] = swap32(DOL_ALIGN(swap32(aligned_header.text_size[i])));
+    aligned_header.text_size[i] =
-	for(i=0; i<ARRAY_COUNT(aligned_header.data_size); i++)
+        swap32(DOL_ALIGN(swap32(aligned_header.text_size[i])));
-		aligned_header.data_size[i] = swap32(DOL_ALIGN(swap32(aligned_header.data_size[i])));
+  for (i = 0; i < ARRAY_COUNT(aligned_header.data_size); i++)
+    aligned_header.data_size[i] =
+        swap32(DOL_ALIGN(swap32(aligned_header.data_size[i])));
   written = fwrite(&aligned_header, sizeof(DOL_hdr), 1, dolf);
-	if(written != 1)
+  if (written != 1)
     ferrordie(dolf, "writing DOL header");
 
-	for(i=0; i<map->text_cnt; i++) {
+  for (i = 0; i < map->text_cnt; i++) {
     uint32_t size = swap32(map->header.text_size[i]);
     uint32_t padded_size = DOL_ALIGN(size);
-		if(verbosity >= 2)
+    if (verbosity >= 2)
       fprintf(stderr, "Writing TEXT segment %d...\n", i);
-		fcpy(dolf, map->elf, swap32(map->header.text_off[i]), map->text_elf_off[i], size);
+    fcpy(dolf, map->elf, swap32(map->header.text_off[i]), map->text_elf_off[i],
+         size);
     if (padded_size > size)
       fpad(dolf, swap32(map->header.text_off[i]) + size, padded_size - size);
   }
-	for(i=0; i<map->data_cnt; i++) {
+  for (i = 0; i < map->data_cnt; i++) {
     uint32_t size = swap32(map->header.data_size[i]);
     uint32_t padded_size = DOL_ALIGN(size);
-		if(verbosity >= 2)
+    if (verbosity >= 2)
       fprintf(stderr, "Writing DATA segment %d...\n", i);
-		fcpy(dolf, map->elf, swap32(map->header.data_off[i]), map->data_elf_off[i], size);
+    fcpy(dolf, map->elf, swap32(map->header.data_off[i]), map->data_elf_off[i],
+         size);
     if (padded_size > size)
       fpad(dolf, swap32(map->header.data_off[i]) + size, padded_size - size);
   }
 
-	if(verbosity >= 2)
+  if (verbosity >= 2)
     fprintf(stderr, "All done!\n");
 
   fclose(map->elf);
   fclose(dolf);
 }
 
-int main(int argc, char **argv)
+int main(int argc, char** argv) {
-{
+  char** arg;
-	char **arg;
 
-	if(argc < 2) {
+  if (argc < 2) {
     usage(argv[0]);
     return 1;
   }
   arg = &argv[1];
   argc--;
 
-	while(argc && *arg[0] == '-') {
+  while (argc && *arg[0] == '-') {
-		if(!strcmp(*arg, "-h")) {
+    if (!strcmp(*arg, "-h")) {
       usage(argv[0]);
       return 1;
-		} else if(!strcmp(*arg, "-v")) {
+    } else if (!strcmp(*arg, "-v")) {
       verbosity++;
-		} else if(!strcmp(*arg, "--")) {
+    } else if (!strcmp(*arg, "--")) {
       arg++;
       argc--;
       break;
@@ -477,13 +484,13 @@ int main(int argc, char **argv)
     arg++;
     argc--;
   }
-	if(argc < 2) {
+  if (argc < 2) {
     usage(argv[0]);
     exit(1);
   }
 
-	const char *elf_file = arg[0];
+  const char* elf_file = arg[0];
-	const char *dol_file = arg[1];
+  const char* dol_file = arg[1];
 
   DOL_map map;
 

tools/elf2rel.c

@@ -1,10 +1,10 @@
 #include <assert.h>
+#include <errno.h>
 #include <stdarg.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include <errno.h>
 
 #ifndef MAX
 #define MAX(a, b) (((a) > (b)) ? (a) : (b))
@@ -14,9 +14,9 @@
 #define MIN(a, b) (((a) < (b)) ? (a) : (b))
 #endif
 
-#define ARRAY_COUNT(arr) (sizeof(arr)/sizeof((arr)[0]))
+#define ARRAY_COUNT(arr) (sizeof(arr) / sizeof((arr)[0]))
 
-#define IS_LITTLE_ENDIAN  (((char *)((uint32_t[]){1}))[0] == 1)
+#define IS_LITTLE_ENDIAN (((char*)((uint32_t[]){1}))[0] == 1)
 
 // Relevant portions of elf.h
 
@@ -29,8 +29,7 @@ typedef uint16_t Elf32_Section;
 
 #define EI_NIDENT (16)
 
-typedef struct
+typedef struct {
-{
   unsigned char e_ident[EI_NIDENT]; /* Magic number and other info */
   Elf32_Half e_type;                /* Object file type */
   Elf32_Half e_machine;             /* Architecture */
@@ -55,8 +54,7 @@ typedef struct
 
 #define EM_PPC 20 /* PowerPC */
 
-typedef struct
+typedef struct {
-{
   Elf32_Word sh_name;      /* Section name (string tbl index) */
   Elf32_Word sh_type;      /* Section type */
   Elf32_Word sh_flags;     /* Section flags */
@@ -78,8 +76,7 @@ typedef struct
 #define SHF_ALLOC (1 << 1)     /* Occupies memory during execution */
 #define SHF_EXECINSTR (1 << 2) /* Executable */
 
-typedef struct
+typedef struct {
-{
   Elf32_Word st_name;     /* Symbol name (string tbl index) */
   Elf32_Addr st_value;    /* Symbol value */
   Elf32_Word st_size;     /* Symbol size */
@@ -88,15 +85,14 @@ typedef struct
   Elf32_Section st_shndx; /* Section index */
 } Elf32_Sym;
 
-#define ELF32_ST_TYPE(val)        ((val) & 0xf)
+#define ELF32_ST_TYPE(val) ((val)&0xf)
 
 /* Legal values for ST_TYPE subfield of st_info (symbol type).  */
 
 #define STT_NOTYPE 0 /* Symbol type is unspecified */
 #define STT_FUNC 2   /* Symbol is a code object */
 
-typedef struct
+typedef struct {
-{
   Elf32_Addr r_offset;  /* Address */
   Elf32_Word r_info;    /* Relocation type and symbol index */
   Elf32_Sword r_addend; /* Addend */
@@ -105,7 +101,7 @@ typedef struct
 /* How to extract and insert information held in the r_info field.  */
 
 #define ELF32_R_SYM(val) ((val) >> 8)
-#define ELF32_R_TYPE(val)		((val) & 0xff)
+#define ELF32_R_TYPE(val) ((val)&0xff)
 
 #define R_PPC_NONE 0
 #define R_PPC_ADDR32 1    /* 32bit absolute address */
@@ -125,67 +121,71 @@ typedef struct
 
 // end elf.h
 
-struct RelHeader
+struct RelHeader {
-{
   uint32_t moduleId;           // unique module identifier
   uint32_t nextModule;         // always 0; filled in at runtime
   uint32_t prevModule;         // always 0; filled in at runtime
   uint32_t sectionCount;       // number of sections in the section table
   uint32_t sectionTableOffset; // file position of section table
-    uint32_t moduleNameOffset;       // offset of the module name in the string table (not in this file)
+  uint32_t moduleNameOffset;   // offset of the module name in the string table
-    uint32_t moduleNameSize;         // size of the module name in the string table (not in this file)
+                               // (not in this file)
+  uint32_t moduleNameSize; // size of the module name in the string table (not
+                           // in this file)
   uint32_t formatVersion;  // REL format version
   uint32_t bssSize;        // size of the BSS section
   uint32_t relocationTableOffset; // file position of relocation entries
   uint32_t importTableOffset;     // file position of import table
   uint32_t importTableSize;       // size of import table
-    uint8_t  prologSection;          // section in which the _prolog function is in, or 0 if absent
+  uint8_t prologSection; // section in which the _prolog function is in, or 0 if
-    uint8_t  epilogSection;          // section in which the _epilog function is in, or 0 if absent
+                         // absent
-    uint8_t  unresolvedSection;      // section in which the _unresolved function is in, or 0 if absent
+  uint8_t epilogSection; // section in which the _epilog function is in, or 0 if
+                         // absent
+  uint8_t unresolvedSection; // section in which the _unresolved function is in,
+                             // or 0 if absent
   uint8_t pad33;
   uint32_t prologOffset; // offset of the _prolog function in its section
   uint32_t epilogOffset; // offset of the _epilog function in its section
-    uint32_t unresolvedOffset;       // offset of the _unresolved function in its section
+  uint32_t
+      unresolvedOffset; // offset of the _unresolved function in its section
 };
 
-struct RelRelocEntry
+struct RelRelocEntry {
-{
   int type;             // relocation type
   int patchSection;     // section which relocation patch applies to
   uint32_t patchOffset; // offset where this relocation patch applies
   int symbolSection;    // section of symbol
-    uint32_t symbolAddr;     // for dol symbols, absolute address. for rel symbols, section offset
+  uint32_t symbolAddr;  // for dol symbols, absolute address. for rel symbols,
+                        // section offset
 };
 
-struct RelImportEntry
+struct RelImportEntry {
-{
+  int moduleId; // ID of module from which the relocation symbols are imported
-    int moduleId;                  // ID of module from which the relocation symbols are imported from
+                // from
-    struct RelRelocEntry *relocs;  // relocation entries
+  struct RelRelocEntry* relocs; // relocation entries
   int relocsCount;              // number of relocation entries
   size_t relocsOffset;          // file offset to relocation entries
 };
 
-struct Module
+struct Module {
-{
+  int moduleId; // unique identifier of the module; the id of the DOL is always
-    int moduleId;          // unique identifier of the module; the id of the DOL is always 0
+                // 0
-    const char *filename;  // name of the module's ELF file
+  const char* filename; // name of the module's ELF file
-    FILE *file;            // ELF file
+  FILE* file;           // ELF file
   Elf32_Ehdr ehdr;      // ELF header
-    Elf32_Sym *symtab;     // ELF symbol table entries
+  Elf32_Sym* symtab;    // ELF symbol table entries
   int symtabCount;      // number of ELF symbol table entries
-    char *strtab;          // ELF string table
+  char* strtab;         // ELF string table
   size_t strtabSize;    // size of ELF string table
 };
 
 static struct Module dolModule;
 static struct Module relModule;
-static struct RelImportEntry *imports;
+static struct RelImportEntry* imports;
 static int importsCount = 0;
 static int minSectionCount = 0;
 static int undefinedSymError = 0;
 
-static void fatal_error(const char *msg, ...)
+static void fatal_error(const char* msg, ...) {
-{
   va_list args;
 
   va_start(args, msg);
@@ -196,45 +196,33 @@ static void fatal_error(const char *msg, ...)
 
 // Swaps byte order if the system is little endian
 
-static void bswap32(uint32_t *ptr)
+static void bswap32(uint32_t* ptr) {
-{
   if (IS_LITTLE_ENDIAN)
-        *ptr = (((*ptr >> 24) & 0xFF) << 0)
+    *ptr = (((*ptr >> 24) & 0xFF) << 0) | (((*ptr >> 16) & 0xFF) << 8) |
-             | (((*ptr >> 16) & 0xFF) << 8)
+           (((*ptr >> 8) & 0xFF) << 16) | (((*ptr >> 0) & 0xFF) << 24);
-             | (((*ptr >> 8)  & 0xFF) << 16)
-             | (((*ptr >> 0)  & 0xFF) << 24);
 }
 
-static void bswap16(uint16_t *ptr)
+static void bswap16(uint16_t* ptr) {
-{
   if (IS_LITTLE_ENDIAN)
-        *ptr = (((*ptr >> 8) & 0xFF) << 0)
+    *ptr = (((*ptr >> 8) & 0xFF) << 0) | (((*ptr >> 0) & 0xFF) << 8);
-             | (((*ptr >> 0) & 0xFF) << 8);
 }
 
-static int read_checked(FILE *f, size_t offset, void *out, size_t size)
+static int read_checked(FILE* f, size_t offset, void* out, size_t size) {
-{
+  return fseek(f, offset, SEEK_SET) == 0 && fread(out, size, 1, f) == 1;
-    return fseek(f, offset, SEEK_SET) == 0
-        && fread(out, size, 1, f) == 1;
 }
 
-static int write_checked(FILE *f, size_t offset, const void *in, size_t size)
+static int write_checked(FILE* f, size_t offset, const void* in, size_t size) {
-{
+  return fseek(f, offset, SEEK_SET) == 0 && fwrite(in, size, 1, f) == 1;
-    return fseek(f, offset, SEEK_SET) == 0
-        && fwrite(in, size, 1, f) == 1;
 }
 
-static uint32_t align(uint32_t n, unsigned int alignment)
+static uint32_t align(uint32_t n, unsigned int alignment) {
-{
   if (alignment == 0 || n % alignment == 0)
     return n;
   return n + alignment - (n % alignment);
 }
 
-static int is_supported_reloc_type(int type)
+static int is_supported_reloc_type(int type) {
-{
+  switch (type) {
-    switch (type)
-    {
   case R_PPC_ADDR32:
   case R_PPC_ADDR24:
   case R_PPC_ADDR16_LO:
@@ -246,15 +234,15 @@ static int is_supported_reloc_type(int type)
   return 0;
 }
 
-static const char *symbol_name(const struct Module *module, const Elf32_Sym *sym)
+static const char* symbol_name(const struct Module* module,
-{
+                               const Elf32_Sym* sym) {
   if (sym->st_name >= module->strtabSize)
     return NULL;
   return module->strtab + sym->st_name;
 }
 
-static int get_symtab_entry(const struct Module *module, int index, Elf32_Sym *sym)
+static int get_symtab_entry(const struct Module* module, int index,
-{
+                            Elf32_Sym* sym) {
   if (index >= module->symtabCount)
     return 0;
   *sym = module->symtab[index];
@@ -265,39 +253,36 @@ static int get_symtab_entry(const struct Module *module, int index, Elf32_Sym *s
   return 1;
 }
 
-static int lookup_symbol_by_name(const struct Module *module, const char *name, Elf32_Sym *sym)
+static int lookup_symbol_by_name(const struct Module* module, const char* name,
-{
+                                 Elf32_Sym* sym) {
   int i;
 
-    for (i = 0; i < module->symtabCount; i++)
+  for (i = 0; i < module->symtabCount; i++) {
-    {
     get_symtab_entry(module, i, sym);
-        const char *n = symbol_name(module, sym);
+    const char* n = symbol_name(module, sym);
     if (n != NULL && strcmp(name, n) == 0)
       return 1;
   }
   return 0;
 }
 
-static struct RelImportEntry *get_import_for_module_id(int moduleId)
+static struct RelImportEntry* get_import_for_module_id(int moduleId) {
-{
   int i;
 
-    for (i = 0; i < importsCount; i++)
+  for (i = 0; i < importsCount; i++) {
-    {
     if (imports[i].moduleId == moduleId)
       return &imports[i];
   }
   return NULL;
 }
 
-static void add_reloc_entry(const struct Module *module, const Elf32_Rela *reloc, int relocSection)
+static void add_reloc_entry(const struct Module* module,
-{
+                            const Elf32_Rela* reloc, int relocSection) {
   Elf32_Sym sym;
   int symIdx = ELF32_R_SYM(reloc->r_info);
   int relocType = ELF32_R_TYPE(reloc->r_info);
   struct RelRelocEntry rentry;
-    struct RelImportEntry *import;
+  struct RelImportEntry* import;
   int moduleId; // module containing the symbol
 
   if (!is_supported_reloc_type(relocType))
@@ -315,12 +300,10 @@ static void add_reloc_entry(const struct Module *module, const Elf32_Rela *reloc
     rentry.symbolSection = sym.st_shndx;
     rentry.symbolAddr = sym.st_value + reloc->r_addend;
     moduleId = module->moduleId;
-    }
+  } else // symbol is in another module (the DOL)
-    else  // symbol is in another module (the DOL)
-    {
-        const char *name = symbol_name(&relModule, &sym);
-        if (!lookup_symbol_by_name(&dolModule, name, &sym))
   {
+    const char* name = symbol_name(&relModule, &sym);
+    if (!lookup_symbol_by_name(&dolModule, name, &sym)) {
       undefinedSymError = 1;
       fprintf(stderr, "could not find symbol '%s' in any module\n", name);
       return;
@@ -335,8 +318,7 @@ static void add_reloc_entry(const struct Module *module, const Elf32_Rela *reloc
 
   import = get_import_for_module_id(moduleId);
   // add import entry if it does not exist.
-    if (import == NULL)
+  if (import == NULL) {
-    {
     imports = realloc(imports, (importsCount + 1) * sizeof(*imports));
     import = &imports[importsCount++];
     import->moduleId = moduleId;
@@ -345,12 +327,13 @@ static void add_reloc_entry(const struct Module *module, const Elf32_Rela *reloc
   }
 
   // add relocation entry
-    import->relocs = realloc(import->relocs, (import->relocsCount + 1) * sizeof(*import->relocs));
+  import->relocs = realloc(import->relocs,
+                           (import->relocsCount + 1) * sizeof(*import->relocs));
   import->relocs[import->relocsCount++] = rentry;
 }
 
-static void module_get_section_header(const struct Module *module, int secNum, Elf32_Shdr *shdr)
+static void module_get_section_header(const struct Module* module, int secNum,
-{
+                                      Elf32_Shdr* shdr) {
   size_t offset = module->ehdr.e_shoff + secNum * module->ehdr.e_shentsize;
 
   if (secNum >= module->ehdr.e_shnum)
@@ -371,33 +354,30 @@ static void module_get_section_header(const struct Module *module, int secNum, E
   bswap32(&shdr->sh_entsize);
 }
 
-static void module_read_relocs(struct Module *module)
+static void module_read_relocs(struct Module* module) {
-{
   int i;
   int j;
 
   undefinedSymError = 0;
 
-    for (i = 0; i < (int)module->ehdr.e_shnum; i++)
+  for (i = 0; i < (int)module->ehdr.e_shnum; i++) {
-    {
     Elf32_Shdr shdr;
     Elf32_Shdr forSection;
 
     module_get_section_header(module, i, &shdr);
-        if (shdr.sh_type == SHT_RELA)
+    if (shdr.sh_type == SHT_RELA) {
-        {
       module_get_section_header(module, shdr.sh_info, &forSection);
       if (!(forSection.sh_flags & SHF_ALLOC))
         continue;
-            for (j = 0; j < shdr.sh_size / sizeof(Elf32_Rela); j++)
+      for (j = 0; j < shdr.sh_size / sizeof(Elf32_Rela); j++) {
-            {
         Elf32_Rela reloc;
 
-                read_checked(module->file, shdr.sh_offset + j * sizeof(Elf32_Rela), &reloc, sizeof(reloc));
+        read_checked(module->file, shdr.sh_offset + j * sizeof(Elf32_Rela),
+                     &reloc, sizeof(reloc));
         // convert from big endian
         bswap32(&reloc.r_offset);
         bswap32(&reloc.r_info);
-                bswap32((uint32_t *)&reloc.r_addend);
+        bswap32((uint32_t*)&reloc.r_addend);
 
         add_reloc_entry(&relModule, &reloc, shdr.sh_info);
       }
@@ -408,19 +388,22 @@ static void module_read_relocs(struct Module *module)
     exit(1);
 }
 
-static int open_module(struct Module *module)
+static int open_module(struct Module* module) {
-{
   int i;
 
   // open file
   module->file = fopen(module->filename, "rb");
   if (module->file == NULL)
-        fatal_error("could not open %s for reading: %s\n", module->filename, strerror(errno));
+    fatal_error("could not open %s for reading: %s\n", module->filename,
+                strerror(errno));
 
   // read and verify ELF header
   if (!read_checked(module->file, 0, &module->ehdr, sizeof(module->ehdr)))
     fatal_error("error reading ELF header\n");
-    if (memcmp(module->ehdr.e_ident, "\x7F""ELF", 4) != 0)
+  if (memcmp(module->ehdr.e_ident,
+             "\x7F"
+             "ELF",
+             4) != 0)
     fatal_error("%s is not a valid ELF file\n", module->filename);
 
   // convert from big endian
@@ -442,29 +425,29 @@ static int open_module(struct Module *module)
     fatal_error("invalid section header size");
 
   // Verify architecture
-    if (module->ehdr.e_ident[EI_CLASS] != ELFCLASS32
+  if (module->ehdr.e_ident[EI_CLASS] != ELFCLASS32 ||
-     || module->ehdr.e_ident[EI_DATA] != ELFDATA2MSB
+      module->ehdr.e_ident[EI_DATA] != ELFDATA2MSB ||
-     || module->ehdr.e_machine != EM_PPC)
+      module->ehdr.e_machine != EM_PPC)
-        fatal_error("%s: wrong architecture. expected PowerPC 32-bit big endian.\n", module->filename);
+    fatal_error("%s: wrong architecture. expected PowerPC 32-bit big endian.\n",
+                module->filename);
 
   // Read symbol table and string table
-    for (i = 0; i < (int)module->ehdr.e_shnum; i++)
+  for (i = 0; i < (int)module->ehdr.e_shnum; i++) {
-    {
     Elf32_Shdr shdr;
 
     module_get_section_header(module, i, &shdr);
-        if (shdr.sh_type == SHT_SYMTAB && module->symtab == NULL)
+    if (shdr.sh_type == SHT_SYMTAB && module->symtab == NULL) {
-        {
       module->symtabCount = shdr.sh_size / sizeof(Elf32_Sym);
       module->symtab = malloc(shdr.sh_size);
-            if (!read_checked(module->file, shdr.sh_offset, module->symtab, shdr.sh_size))
+      if (!read_checked(module->file, shdr.sh_offset, module->symtab,
+                        shdr.sh_size))
         fatal_error("error reading symbol table\n");
-        }
+    } else if (shdr.sh_type == SHT_STRTAB && i != module->ehdr.e_shstrndx &&
-        else if (shdr.sh_type == SHT_STRTAB && i != module->ehdr.e_shstrndx && module->strtab == NULL)
+               module->strtab == NULL) {
-        {
       module->strtabSize = shdr.sh_size;
       module->strtab = malloc(shdr.sh_size);
-            if (!read_checked(module->file, shdr.sh_offset, module->strtab, shdr.sh_size))
+      if (!read_checked(module->file, shdr.sh_offset, module->strtab,
+                        shdr.sh_size))
         fatal_error("error reading string table\n");
     }
   }
@@ -477,35 +460,29 @@ static int open_module(struct Module *module)
 }
 
 // searches for the special functions "_prolog", "_epliog", and "_unresolved"
-static void find_rel_entry_functions(const struct Module *module, struct RelHeader *relHdr)
+static void find_rel_entry_functions(const struct Module* module,
-{
+                                     struct RelHeader* relHdr) {
   int i;
 
-    //puts("finding entry points");
+  // puts("finding entry points");
-    for (i = 0; i < module->symtabCount; i++)
+  for (i = 0; i < module->symtabCount; i++) {
-    {
     Elf32_Sym sym;
     Elf32_Shdr shdr;
-        const char *name;
+    const char* name;
 
     get_symtab_entry(module, i, &sym);
     name = symbol_name(module, &sym);
     if (name == NULL)
       continue;
-        if (strcmp(name, "_prolog") == 0)
+    if (strcmp(name, "_prolog") == 0) {
-        {
       module_get_section_header(module, sym.st_shndx, &shdr);
       relHdr->prologSection = sym.st_shndx;
       relHdr->prologOffset = sym.st_value - shdr.sh_addr;
-        }
+    } else if (strcmp(name, "_epilog") == 0) {
-        else if (strcmp(name, "_epilog") == 0)
-        {
       module_get_section_header(module, sym.st_shndx, &shdr);
       relHdr->epilogSection = sym.st_shndx;
       relHdr->epilogOffset = sym.st_value - shdr.sh_addr;
-        }
+    } else if (strcmp(name, "_unresolved") == 0) {
-        else if (strcmp(name, "_unresolved") == 0)
-        {
       module_get_section_header(module, sym.st_shndx, &shdr);
       relHdr->unresolvedSection = sym.st_shndx;
       relHdr->unresolvedOffset = sym.st_value - shdr.sh_addr;
@@ -514,16 +491,16 @@ static void find_rel_entry_functions(const struct Module *module, struct RelHead
 }
 
 // patches the bl instruction at insnp to jump to offset
-static void patch_rel24_branch_offset(uint8_t *insnp, int32_t branchOffset)
+static void patch_rel24_branch_offset(uint8_t* insnp, int32_t branchOffset) {
-{
+  const uint32_t offsetMask =
-    const uint32_t offsetMask = 0x03FFFFFC;  // bits of instruction that contain the offset
+      0x03FFFFFC; // bits of instruction that contain the offset
   uint32_t insn = (insnp[0] << 24) // read instruction
-                  | (insnp[1] << 16)
+                  | (insnp[1] << 16) | (insnp[2] << 8) | (insnp[3] << 0);
-                  | (insnp[2] << 8)
-                  | (insnp[3] << 0);
 
-    assert(((insn >> 26) & 0x3F) == 18);  // TODO: do other instructions besides bl use R_PPC_REL24?
+  assert(((insn >> 26) & 0x3F) ==
-    insn = (insn & ~offsetMask) | (branchOffset & offsetMask);  // patch instruction
+         18); // TODO: do other instructions besides bl use R_PPC_REL24?
+  insn =
+      (insn & ~offsetMask) | (branchOffset & offsetMask); // patch instruction
   // write instruction
   insnp[0] = (insn >> 24) & 0xFF;
   insnp[1] = (insn >> 16) & 0xFF;
@@ -531,23 +508,21 @@ static void patch_rel24_branch_offset(uint8_t *insnp, int32_t branchOffset)
   insnp[3] = (insn >> 0) & 0xFF;
 }
 
-static void patch_code_relocs(struct RelHeader *relHdr, int sectionId, uint8_t *code, size_t size)
+static void patch_code_relocs(struct RelHeader* relHdr, int sectionId,
-{
+                              uint8_t* code, size_t size) {
-    struct RelImportEntry *import;
+  struct RelImportEntry* import;
-    struct RelRelocEntry *reloc;
+  struct RelRelocEntry* reloc;
   int i;
 
   // Remove redundant R_PPC_REL24 relocations for calls to functions within
   // the same module
   import = get_import_for_module_id(relModule.moduleId);
   assert(import != NULL);
-    for (i = 0, reloc = &import->relocs[0]; i < import->relocsCount; i++, reloc++)
+  for (i = 0, reloc = &import->relocs[0]; i < import->relocsCount;
-    {
+       i++, reloc++) {
-        if (reloc->patchSection == sectionId && reloc->type == R_PPC_REL24)
+    if (reloc->patchSection == sectionId && reloc->type == R_PPC_REL24) {
-        {
       assert(reloc->patchOffset < size);
-            patch_rel24_branch_offset(
+      patch_rel24_branch_offset(code + reloc->patchOffset,
-                code + reloc->patchOffset,
                                 reloc->symbolAddr - reloc->patchOffset);
       // remove the relocation
       reloc->type = R_PPC_NONE;
@@ -560,22 +535,19 @@ static void patch_code_relocs(struct RelHeader *relHdr, int sectionId, uint8_t *
     return;
   import = get_import_for_module_id(0);
   assert(import != NULL);
-    for (i = 0, reloc = &import->relocs[0]; i < import->relocsCount; i++, reloc++)
+  for (i = 0, reloc = &import->relocs[0]; i < import->relocsCount;
-    {
+       i++, reloc++) {
-        if (reloc->patchSection == sectionId && reloc->type == R_PPC_REL24)
+    if (reloc->patchSection == sectionId && reloc->type == R_PPC_REL24) {
-        {
       assert(reloc->patchOffset < size);
-            patch_rel24_branch_offset(
+      patch_rel24_branch_offset(code + reloc->patchOffset,
-                code + reloc->patchOffset,
                                 relHdr->unresolvedOffset - reloc->patchOffset);
     }
   }
 }
 
-static int compare_relocs(const void *a, const void *b)
+static int compare_relocs(const void* a, const void* b) {
-{
+  const struct RelRelocEntry* relocA = a;
-    const struct RelRelocEntry *relocA = a;
+  const struct RelRelocEntry* relocB = b;
-    const struct RelRelocEntry *relocB = b;
 
   // Sort by sections to which these relocations apply
   if (relocA->patchSection != relocB->patchSection)
@@ -587,23 +559,23 @@ static int compare_relocs(const void *a, const void *b)
   return (uintptr_t)a - (uintptr_t)b;
 }
 
-static int compare_imports(const void *a, const void *b)
+static int compare_imports(const void* a, const void* b) {
-{
+  const struct RelImportEntry* impA = a;
-    const struct RelImportEntry *impA = a;
+  const struct RelImportEntry* impB = b;
-    const struct RelImportEntry *impB = b;
 
   return impA->moduleId - impB->moduleId;
 }
 
-static void write_rel_file(struct Module *module, struct RelHeader *relHdr, const char *filename)
+static void write_rel_file(struct Module* module, struct RelHeader* relHdr,
-{
+                           const char* filename) {
   int i, j;
   size_t filePos = sizeof(struct RelHeader); // skip over header for now
-    struct RelImportEntry *imp;
+  struct RelImportEntry* imp;
-    FILE *fout = fopen(filename, "wb");
+  FILE* fout = fopen(filename, "wb");
 
   if (fout == NULL)
-        fatal_error("could not open %s for writing: %s\n", filename, strerror(errno));
+    fatal_error("could not open %s for writing: %s\n", filename,
+                strerror(errno));
 
   relHdr->moduleId = module->moduleId;
   relHdr->formatVersion = 1;
@@ -617,22 +589,22 @@ static void write_rel_file(struct Module *module, struct RelHeader *relHdr, cons
   // section contents follow section info table
   filePos = relHdr->sectionTableOffset + relHdr->sectionCount * 8;
   relHdr->bssSize = 0;
-    for (i = 0; i < module->ehdr.e_shnum; i++)
+  for (i = 0; i < module->ehdr.e_shnum; i++) {
-    {
     Elf32_Shdr shdr;
-        struct { uint32_t offset; uint32_t size; } secEntry = {0};
+    struct {
+      uint32_t offset;
+      uint32_t size;
+    } secEntry = {0};
 
     module_get_section_header(module, i, &shdr);
     // write section contents
-        if (shdr.sh_type == SHT_PROGBITS && (shdr.sh_flags & SHF_ALLOC))
+    if (shdr.sh_type == SHT_PROGBITS && (shdr.sh_flags & SHF_ALLOC)) {
-        {
       size_t sizeAligned = align(shdr.sh_size, 4);
       uint32_t execflg = (shdr.sh_flags & SHF_EXECINSTR) ? 1 : 0;
 
       filePos = align(filePos, shdr.sh_addralign);
-            if (shdr.sh_size > 0)
+      if (shdr.sh_size > 0) {
-            {
+        uint8_t* data = calloc(sizeAligned, 1);
-                uint8_t *data = calloc(sizeAligned, 1);
 
         if (!read_checked(module->file, shdr.sh_offset, data, shdr.sh_size))
           fatal_error("error reading section\n");
@@ -651,7 +623,8 @@ static void write_rel_file(struct Module *module, struct RelHeader *relHdr, cons
     // write section table entry
     bswap32(&secEntry.offset);
     bswap32(&secEntry.size);
-        write_checked(fout, relHdr->sectionTableOffset + i * 8, &secEntry, sizeof(secEntry));
+    write_checked(fout, relHdr->sectionTableOffset + i * 8, &secEntry,
+                  sizeof(secEntry));
 
     // calculate total BSS size
     if ((shdr.sh_flags & SHF_ALLOC) && shdr.sh_type == SHT_NOBITS)
@@ -663,13 +636,11 @@ static void write_rel_file(struct Module *module, struct RelHeader *relHdr, cons
   relHdr->relocationTableOffset = filePos;
   // sort imports by module id
   qsort(imports, importsCount, sizeof(struct RelImportEntry), compare_imports);
-    for (i = 0, imp = &imports[0]; i < importsCount; i++, imp++)
+  for (i = 0, imp = &imports[0]; i < importsCount; i++, imp++) {
-    {
+    struct RelRelocEntry* reloc;
-        struct RelRelocEntry *reloc;
     int currSection = -1;
     uint32_t prevOffset = 0;
-        struct
+    struct {
-        {
       uint16_t offset;
       uint8_t type;
       uint8_t section;
@@ -678,9 +649,9 @@ static void write_rel_file(struct Module *module, struct RelHeader *relHdr, cons
 
     imp->relocsOffset = filePos;
     // sort relocation entries by section
-        qsort(imp->relocs, imp->relocsCount, sizeof(struct RelRelocEntry), compare_relocs);
+    qsort(imp->relocs, imp->relocsCount, sizeof(struct RelRelocEntry),
-        for (j = 0, reloc = &imp->relocs[0]; j < imp->relocsCount; j++, reloc++)
+          compare_relocs);
-        {
+    for (j = 0, reloc = &imp->relocs[0]; j < imp->relocsCount; j++, reloc++) {
       if (reloc->type == R_PPC_NONE) // ignore null relocations
         continue;
 
@@ -733,10 +704,12 @@ static void write_rel_file(struct Module *module, struct RelHeader *relHdr, cons
   // 3. Write module import table
 
   relHdr->importTableOffset = filePos;
-    for (i = 0, imp = &imports[0]; i < importsCount; i++, imp++)
+  for (i = 0, imp = &imports[0]; i < importsCount; i++, imp++) {
-    {
     // write import table entry
-        struct { uint32_t moduleId; uint32_t relocsOffset; } ent;
+    struct {
+      uint32_t moduleId;
+      uint32_t relocsOffset;
+    } ent;
     ent.moduleId = imp->moduleId;
     ent.relocsOffset = imp->relocsOffset;
     bswap32(&ent.moduleId);
@@ -766,55 +739,47 @@ static void write_rel_file(struct Module *module, struct RelHeader *relHdr, cons
   fclose(fout);
 }
 
-static int parse_number(const char *str, int *n)
+static int parse_number(const char* str, int* n) {
-{
+  char* end;
-    char *end;
   *n = strtol(str, &end, 0);
   return end > str && *end == 0;
 }
 
-int main(int argc, char **argv)
+int main(int argc, char** argv) {
-{
   int i;
   int moduleId = -1;
   int nameOffset = 0;
   int nameLen = 0;
-    const char *relName = NULL;
+  const char* relName = NULL;
   struct RelHeader relHdr = {0};
 
   // Read command-line args
-    for (i = 1; i < argc; i++)
+  for (i = 1; i < argc; i++) {
-    {
+    if (strcmp(argv[i], "-c") == 0 ||
-        if (strcmp(argv[i], "-c") == 0 || strcmp(argv[i], "--pad-section-count") == 0)
+        strcmp(argv[i], "--pad-section-count") == 0) {
-        {
       if (i + 1 < argc && parse_number(argv[i + 1], &minSectionCount))
         i++;
       else
         goto usage;
-        }
+    } else if (strcmp(argv[i], "-i") == 0 ||
-        else if (strcmp(argv[i], "-i") == 0 || strcmp(argv[i], "--module-id") == 0)
+               strcmp(argv[i], "--module-id") == 0) {
-        {
       if (i + 1 < argc && parse_number(argv[i + 1], &moduleId))
         i++;
       else
         goto usage;
-        }
+    } else if (strcmp(argv[i], "-o") == 0 ||
-        else if (strcmp(argv[i], "-o") == 0 || strcmp(argv[i], "--name-offset") == 0)
+               strcmp(argv[i], "--name-offset") == 0) {
-        {
       if (i + 1 < argc && parse_number(argv[i + 1], &nameOffset))
         i++;
       else
         goto usage;
-        }
+    } else if (strcmp(argv[i], "-l") == 0 ||
-        else if (strcmp(argv[i], "-l") == 0 || strcmp(argv[i], "--name-length") == 0)
+               strcmp(argv[i], "--name-length") == 0) {
-        {
       if (i + 1 < argc && parse_number(argv[i + 1], &nameLen))
         i++;
       else
         goto usage;
-        }
+    } else {
-        else
-        {
       if (relModule.filename == NULL)
         relModule.filename = argv[i];
       else if (dolModule.filename == NULL)
@@ -825,7 +790,8 @@ int main(int argc, char **argv)
         goto usage;
     }
   }
-    if (relModule.filename == NULL || dolModule.filename == NULL || relName == NULL)
+  if (relModule.filename == NULL || dolModule.filename == NULL ||
+      relName == NULL)
     goto usage;
 
   open_module(&relModule);
@@ -855,12 +821,16 @@ usage:
   fprintf(stderr,
           "usage: %s reloc_elf static_elf rel_file\n"
           "options:\n"
-        "  -i, --module-id <n>          sets the module ID in the rel header to <n>\n"
+          "  -i, --module-id <n>          sets the module ID in the rel header "
-        "  -c, --pad-section-count <n>  ensures that the rel will have at least <n>\n"
+          "to <n>\n"
+          "  -c, --pad-section-count <n>  ensures that the rel will have at "
+          "least <n>\n"
           "                               sections\n"
-        "  -o, --name-offset <offset>   sets the name offset in the rel header to\n"
+          "  -o, --name-offset <offset>   sets the name offset in the rel "
+          "header to\n"
           "                               <offset>\n"
-        "  -l, --name-length <len>      sets the name length in the rel header to <len>\n",
+          "  -l, --name-length <len>      sets the name length in the rel "
+          "header to <len>\n",
           argv[0]);
   return 1;
 }

tools/m2ctx.py

@@ -0,0 +1,72 @@
+#!/usr/bin/env python3
+
+# MIT License
+# See https://github.com/ethteck/m2ctx/blob/main/m2ctx.py
+
+import argparse
+import os
+import sys
+import subprocess
+import tempfile
+
+script_dir = os.path.dirname(os.path.realpath(__file__))
+root_dir = os.path.abspath(os.path.join(script_dir, ".."))
+src_dir = root_dir + "src/"
+
+CPP_FLAGS = [
+    "-Iinclude",
+    "-Isrc",
+    "-DGEKKO",
+    "-DHW2",
+    "-D__attribute__(...)=",
+    "-D__asm__(...)=",
+    "-ffreestanding",
+    "-DM2CTX",
+]
+
+def import_c_file(in_file) -> str:
+    in_file = os.path.relpath(in_file, root_dir)
+    cpp_command = ["gcc", "-E", "-P", "-dM", *CPP_FLAGS, in_file]
+    cpp_command2 = ["gcc", "-E", "-P", *CPP_FLAGS, in_file]
+
+    with tempfile.NamedTemporaryFile(suffix=".c") as tmp:
+        stock_macros = subprocess.check_output(["gcc", "-E", "-P", "-dM", tmp.name], cwd=root_dir, encoding="utf-8")
+
+    out_text = ""
+    try:
+        out_text += subprocess.check_output(cpp_command, cwd=root_dir, encoding="utf-8")
+        out_text += subprocess.check_output(cpp_command2, cwd=root_dir, encoding="utf-8")
+    except subprocess.CalledProcessError:
+        print(
+            "Failed to preprocess input file, when running command:\n"
+            + cpp_command,
+            file=sys.stderr,
+            )
+        sys.exit(1)
+
+    if not out_text:
+        print("Output is empty - aborting")
+        sys.exit(1)
+
+    for line in stock_macros.strip().splitlines():
+        out_text = out_text.replace(line + "\n", "")
+    return out_text
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="""Create a context file which can be used for mips_to_c"""
+    )
+    parser.add_argument(
+        "c_file",
+        help="""File from which to create context""",
+    )
+    args = parser.parse_args()
+
+    output = import_c_file(args.c_file)
+
+    with open(os.path.join(root_dir, "ctx.c"), "w", encoding="UTF-8") as f:
+        f.write(output)
+
+
+if __name__ == "__main__":
+    main()