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

.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,9 +1,12 @@
+#ifndef _DOLPHIN_PPCARCH_H
+#define _DOLPHIN_PPCARCH_H
+
 #include "types.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif
-    
+
 u32 PPCMfmsr();
 void PPCMtmsr(u32 newMSR);
 u32 PPCOrMsr(u32 value);
@@ -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,56 +1,56 @@
-#include "types.h"
 #include "Dolphin/db.h"
+#include "types.h"
 
-#define PAD3_BUTTON_ADDR        0x800030E4
+#define PAD3_BUTTON_ADDR 0x800030E4
-#define OS_RESET_RESTART        0
+#define OS_RESET_RESTART 0
-#define FALSE                   0
+#define FALSE 0
-#define TRUE                    1
+#define TRUE 1
-#define EXCEPTIONMASK_ADDR      0x80000044
+#define EXCEPTIONMASK_ADDR 0x80000044
-#define BOOTINFO2_ADDR          0x800000F4
+#define BOOTINFO2_ADDR 0x800000F4
 #define OS_BI2_DEBUGFLAG_OFFSET 0xC
-#define ARENAHI_ADDR            0x80000034
+#define ARENAHI_ADDR 0x80000034
-#define DEBUGFLAG_ADDR          0x800030E8
+#define DEBUGFLAG_ADDR 0x800030E8
-#define DVD_DEVICECODE_ADDR     0x800030E6
+#define DVD_DEVICECODE_ADDR 0x800030E6
 
-#define MSR_FP               0x2000
+#define MSR_FP 0x2000
 
 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_[];
 __declspec(section ".init") extern char _SDA2_BASE_[];
 
 typedef struct __rom_copy_info {
-	char* rom;
+  char* rom;
-	char* addr;
+  char* addr;
-	unsigned int size;
+  unsigned int size;
 } __rom_copy_info;
 
 __declspec(section ".init") extern __rom_copy_info _rom_copy_info[];
 
 typedef struct __bss_init_info {
-	char* addr;
+  char* addr;
-	unsigned int size;
+  unsigned int size;
 } __bss_init_info;
 
 __declspec(section ".init") extern __bss_init_info _bss_init_info[];

include/Dolphin/db.h

@@ -3,14 +3,18 @@
 
 #include "types.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 #define ExceptionHookDestination 0x80000048
-#define IsDebuggerPresent        0x80000040
+#define IsDebuggerPresent 0x80000040
 
 // static int __DBInterface;
 
 struct DBInterface {
-	u8 filler0[4];
+  u8 filler0[4];
-	u32 unk4;
+  u32 unk4;
 };
 
 static struct DBInterface* __DBInterface;
@@ -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/gx_struct.h

@@ -8,19 +8,19 @@ extern "C" {
 #endif
 
 typedef struct _GXRenderModeObj {
-	u32 viTVMode;
+  u32 viTVMode;
-	u16 fbWidth;
+  u16 fbWidth;
-	u16 efbHeight;
+  u16 efbHeight;
-	u16 xfbHeight;
+  u16 xfbHeight;
-	u16 viXOrigin;	
+  u16 viXOrigin;
-	u16 viYOrigin;	
+  u16 viYOrigin;
-	u16 viWidth;
+  u16 viWidth;
-	u16 viHeight;
+  u16 viHeight;
-	u32  xfbMode;
+  u32 xfbMode;
-	u8  field_rendering;
+  u8 field_rendering;
-	u8  aa;
+  u8 aa;
-	u8  sample_pattern[12][2];
+  u8 sample_pattern[12][2];
-	u8  vfilter[7];
+  u8 vfilter[7];
 } GXRenderModeObj;
 
 #ifdef __cplusplus

include/musyx/dsp_import.h

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

include/musyx/musyx.h

@@ -6,15 +6,14 @@
 #ifdef __cplusplus
 extern "C" {
 #endif
-    
-typedef struct _SynthInfo {
-    u8 unk[0x210];
-    u8 voices;
-    u8 music;
-    u8 sfx;
-    u8 studios;
-} SynthInfo;
 
+typedef struct _SynthInfo {
+  u8 unk[0x210];
+  u8 voices;
+  u8 music;
+  u8 sfx;
+  u8 studios;
+} SynthInfo;
 
 #ifdef __cplusplus
 }

include/musyx/musyx_priv.h

@@ -6,15 +6,15 @@
 #ifdef __cplusplus
 extern "C" {
 #endif
-    
+
-void dataInit(u32, s32);                              /* extern */
+void dataInit(u32, s32);       /* extern */
-void dataInitStack();                                 /* extern */
+void dataInitStack();          /* extern */
-s32 hwInit(s32*, u8, u8, s32);                      /* extern */
+s32 hwInit(s32*, u8, u8, s32); /* extern */
-void s3dInit(s32);                                     /* extern */
+void s3dInit(s32);             /* extern */
-void seqInit();                                        /* extern */
+void seqInit();                /* extern */
-void streamInit();                                     /* extern */
+void streamInit();             /* extern */
-void synthInit(u32, u8);                                 /* extern */
+void synthInit(u32, u8);       /* extern */
-void vsInit();                                         /* extern */
+void vsInit();                 /* extern */
 void hwExit();
 void dataExit();
 void s3dExit();

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,50 +1,35 @@
-#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;
+  in.ReadLong();
-public:
+  in.ReadLong();
-    CStringTable(CInputStream& in);
+  size_t langCount = in.Get< size_t >();
-};
+  x0_stringCount = in.Get< u32 >();
+  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 > >());
+  }
 
-template <>
+  size_t offset = langOffsets.front().second;
-inline s32 cinput_stream_helper(TType<s32> type, CInputStream& in) { return in.ReadLong(); }
+  for (size_t i = 0; i < langCount; ++i) {
-template <>
+    if (langOffsets[i].first == mCurrentLanguage) {
-inline u32 cinput_stream_helper(TType<u32> type, CInputStream& in) { return in.ReadLong(); }
+      offset = langOffsets[i].second;
-template <>
+      break;
-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) {
+  for (u32 i = 0; i < offset; ++i) {
-    rstl::pair<L, R> result;
+    in.ReadChar();
-    result.first = in.Get<L>();
+  }
-    result.second = in.Get<R>();
+
-    return result;
+  u32 dataLen = in.Get< u32 >();
-}
+  x4_data = new u8[dataLen];
-
+  in.ReadBytes(x4_data.get(), dataLen);
-CStringTable::CStringTable(CInputStream& in) : x0_stringCount(0), x4_data(NULL) {
-    in.ReadLong();
-    in.ReadLong();
-    size_t langCount = in.Get<size_t>();
-    x0_stringCount = in.Get<u32>();
-    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> >());
-    }
-
-    size_t offset = langOffsets.front().second;
-    for (size_t i = 0; i < langCount; ++i) {
-        if (langOffsets[i].first == mCurrentLanguage) {
-            offset = langOffsets[i].second;
-            break;
-        }
-    }
-    for (u32 i = 0; i < offset; ++i) {
-        in.ReadChar();
-    }
-
-    u32 dataLen = in.Get<u32>();
-    x4_data = new u8[dataLen];
-    in.ReadBytes(x4_data.get(), dataLen);
 }

src/musyx/dsp_import.c

@@ -2,219 +2,565 @@
 
 #ifdef __cplusplus
 extern "C" {
-#endif 
+#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 
+#endif

src/musyx/snd3d.c

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

src/musyx/snd_init.c

@@ -4,57 +4,57 @@
 #ifdef __cplusplus
 extern "C" {
 #endif
+
 /* TODO: Move these to a more approprate location */
 extern s8 sndActive;
 extern s8 synthIdleWaitActive;
 extern SynthInfo synthInfo;
 
 inline s32 DoInit(u32 rate, u32 aramSize, u8 voices, u32 flags) {
-    dataInitStack();
+  dataInitStack();
-    dataInit(0, aramSize);
+  dataInit(0, aramSize);
-    seqInit();
+  seqInit();
-    synthIdleWaitActive = 0;
+  synthIdleWaitActive = 0;
-    synthInit(rate, voices);
+  synthInit(rate, voices);
-    streamInit();
+  streamInit();
-    vsInit();
+  vsInit();
-    s3dInit(flags);
+  s3dInit(flags);
-    sndActive = 1;
+  sndActive = 1;
 
-    return 0;
+  return 0;
 }
 
 s32 sndInit(u8 voices, u8 music, u8 sfx, u8 studios, s32 flags, s32 aramSize) {
-    s32 rate;
+  s32 rate;
-    s32 ret;
+  s32 ret;
 
-    sndActive = 0;
+  sndActive = 0;
-    if (64 >= voices) {
+  if (64 >= voices) {
-        synthInfo.voices = voices;
+    synthInfo.voices = voices;
-    } else {
+  } else {
-        synthInfo.voices = 64;
+    synthInfo.voices = 64;
-    }
+  }
-    if (8 >= studios) {
+  if (8 >= studios) {
-        synthInfo.studios = studios;
+    synthInfo.studios = studios;
-    } else {
+  } else {
-        synthInfo.studios = 8;
+    synthInfo.studios = 8;
-    }
+  }
-    rate = 32000;
+  rate = 32000;
-    synthInfo.music = music;
+  synthInfo.music = music;
-    synthInfo.sfx = sfx;
+  synthInfo.sfx = sfx;
-    ret = hwInit(&rate, synthInfo.voices, synthInfo.studios, flags);
+  ret = hwInit(&rate, synthInfo.voices, synthInfo.studios, flags);
-    if (ret == 0) {
+  if (ret == 0) {
-        ret = DoInit(32000, aramSize, synthInfo.voices, flags);
+    ret = DoInit(32000, aramSize, synthInfo.voices, flags);
-    }
+  }
-    return ret;
+  return ret;
 }
 
-
 void sndQuit() {
-    hwExit();
+  hwExit();
-    dataExit();
+  dataExit();
-    s3dExit();
+  s3dExit();
-    synthExit();
+  synthExit();
-    sndActive = 0;
+  sndActive = 0;
 }
 
 #ifdef __cplusplus

src/os/__ppc_eabi_init.c

@@ -4,35 +4,39 @@ extern void __OSPSInit();
 extern void __OSCacheInit();
 
 asm void __init_hardware(void) {
-    nofralloc
+// clang-format off
-    mfmsr r0
+  nofralloc
-    ori r0, r0, 0x2000
+  mfmsr r0
-    mtmsr r0
+  ori r0, r0, 0x2000
-    
+  mtmsr r0
-    mflr r31
+
-    bl __OSPSInit
+  mflr r31
-    bl __OSCacheInit
+  bl __OSPSInit
-    mtlr r31
+  bl __OSCacheInit
-    blr
+  mtlr r31
+  blr
+// clang-format on
 }
 
 asm void __flush_cache(register void* address, register unsigned int size) {
-    nofralloc
+// clang-format off
-    lis r5,  0xFFFF
+  nofralloc
-    ori r5, r5, 0xFFF1
+  lis r5,  0xFFFF
-    and r5, r5, r3
+  ori r5, r5, 0xFFF1
-    subf r3, r5, r3
+  and r5, r5, r3
-    add r4, r4, r3
+  subf r3, r5, r3
+  add r4, r4, r3
 
 loop:    
-    dcbst 0, r5
+  dcbst 0, r5
-    sync
+  sync
-    icbi 0, r5
+  icbi 0, r5
-    addic r5, r5, 8
+  addic r5, r5, 8
-    subic. r4, r4, 8    
+  subic. r4, r4, 8    
-    bge loop
+  bge loop
-    isync
+  isync
-    blr
+  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) {
-	if ((Pad3Button & 0x0eef) == 0x0eef) {
+    OSResetSystem(OS_RESET_RESTART, 0, FALSE);
-		OSResetSystem(OS_RESET_RESTART, 0, FALSE);
+  }
-	}
+  return;
-	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,47 +121,44 @@ 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);
-	if (size && (dst != src)) {
+    __flush_cache(dst, size);
-		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) {
-	if (size) {
+    memset(dst, 0, size);
-		memset(dst, 0, size);
+  }
-	}
 }
 
 #pragma scheduling off
-void __init_data(void)
+void __init_data(void) {
-{
+  __rom_copy_info* dci;
-	__rom_copy_info* dci;
+  __bss_init_info* bii;
-	__bss_init_info* bii;
 
-	dci = _rom_copy_info;
+  dci = _rom_copy_info;
-	while (TRUE) {
+  while (TRUE) {
-		if (dci->size == 0)
+    if (dci->size == 0)
-			break;
+      break;
-		__copy_rom_section(dci->addr, dci->rom, dci->size);
+    __copy_rom_section(dci->addr, dci->rom, dci->size);
-		dci++;
+    dci++;
-	}
+  }
 
-	bii = _bss_init_info;
+  bii = _bss_init_info;
-	while (TRUE) {
+  while (TRUE) {
-		if (bii->size == 0)
+    if (bii->size == 0)
-			break;
+      break;
-		__init_bss_section(bii->addr, bii->size);
+    __init_bss_section(bii->addr, bii->size);
-		bii++;
+    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,69 +1,69 @@
-#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>
 
 #ifndef MAX
 //! Get the maximum of two values
-#define MAX(a, b)	(((a) > (b)) ? (a) : (b))
+#define MAX(a, b) (((a) > (b)) ? (a) : (b))
 #endif
 
 #ifndef MIN
 //! Get the minimum of two values
-#define MIN(a, b)	(((a) < (b)) ? (a) : (b))
+#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
+#define EI_NIDENT 16
 
 typedef struct {
-	unsigned char	e_ident[EI_NIDENT];
+  unsigned char e_ident[EI_NIDENT];
-	uint16_t		e_type;
+  uint16_t e_type;
-	uint16_t		e_machine;
+  uint16_t e_machine;
-	uint32_t		e_version;
+  uint32_t e_version;
-	uint32_t		e_entry;
+  uint32_t e_entry;
-	uint32_t		e_phoff;
+  uint32_t e_phoff;
-	uint32_t		e_shoff;
+  uint32_t e_shoff;
-	uint32_t		e_flags;
+  uint32_t e_flags;
-	uint16_t		e_ehsize;
+  uint16_t e_ehsize;
-	uint16_t		e_phentsize;
+  uint16_t e_phentsize;
-	uint16_t		e_phnum;
+  uint16_t e_phnum;
-	uint16_t		e_shentsize;
+  uint16_t e_shentsize;
-	uint16_t		e_shnum;
+  uint16_t e_shnum;
-	uint16_t		e_shstrndx;
+  uint16_t e_shstrndx;
 } Elf32_Ehdr;
 
-#define EI_CLASS	4
+#define EI_CLASS 4
-#define EI_DATA		5
+#define EI_DATA 5
-#define EI_VERSION	6
+#define EI_VERSION 6
-#define EI_PAD		7
+#define EI_PAD 7
-#define EI_NIDENT	16
+#define EI_NIDENT 16
 
-#define ELFCLASS32	1
+#define ELFCLASS32 1
-#define ELFDATA2MSB	2
+#define ELFDATA2MSB 2
-#define EV_CURRENT	1
+#define EV_CURRENT 1
 
-#define ET_EXEC		2
+#define ET_EXEC 2
-#define EM_PPC		20
+#define EM_PPC 20
 
 typedef struct {
-	uint32_t	p_type;
+  uint32_t p_type;
-	uint32_t	p_offset;
+  uint32_t p_offset;
-	uint32_t	p_vaddr;
+  uint32_t p_vaddr;
-	uint32_t	p_paddr;
+  uint32_t p_paddr;
-	uint32_t	p_filesz;
+  uint32_t p_filesz;
-	uint32_t	p_memsz;
+  uint32_t p_memsz;
-	uint32_t	p_flags;
+  uint32_t p_flags;
-	uint32_t	p_align;
+  uint32_t p_align;
 } Elf32_Phdr;
 
-#define PT_LOAD	1
+#define PT_LOAD 1
-#define PF_R	4
+#define PF_R 4
-#define PF_W	2
+#define PF_W 2
-#define PF_X	1
+#define PF_X 1
 
 int verbosity = 0;
 
@@ -74,33 +74,27 @@ 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 << 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 */
 
 typedef struct {
 
-	uint32_t text_off[7];
+  uint32_t text_off[7];
-	uint32_t data_off[11];
+  uint32_t data_off[11];
-	uint32_t text_addr[7];
+  uint32_t text_addr[7];
-	uint32_t data_addr[11];
+  uint32_t data_addr[11];
-	uint32_t text_size[7];
+  uint32_t text_size[7];
-	uint32_t data_size[11];
+  uint32_t data_size[11];
-	uint32_t bss_addr;
+  uint32_t bss_addr;
-	uint32_t bss_size;
+  uint32_t bss_size;
-	uint32_t entry;
+  uint32_t entry;
-	uint32_t pad[7];
+  uint32_t pad[7];
 } DOL_hdr;
 
 #define HAVE_BSS 1
@@ -113,385 +107,398 @@ typedef struct {
 #define DOL_ALIGN(x) (((x) + DOL_ALIGNMENT - 1) & ~(DOL_ALIGNMENT - 1))
 
 typedef struct {
-	DOL_hdr header;
+  DOL_hdr header;
-	int text_cnt;
+  int text_cnt;
-	int data_cnt;
+  int data_cnt;
-	uint32_t text_elf_off[7];
+  uint32_t text_elf_off[7];
-	uint32_t data_elf_off[11];
+  uint32_t data_elf_off[11];
-	uint32_t flags;
+  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, "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, " Convert an ELF file to a DOL file (by segments)\n");
+  fprintf(stderr, " Options:\n");
-	fprintf(stderr, " Options:\n");
+  fprintf(stderr, "  -h    Show this help\n");
-	fprintf(stderr, "  -h    Show this help\n");
+  fprintf(stderr, "  -v    Be more verbose (twice for even more)\n");
-	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 ");
-		fprintf(stderr, "Error while ");
+    perrordie(str);
-		perrordie(str);
+  } else if (feof(f)) {
-	} else if(feof(f)) {
+    fprintf(stderr, "EOF while %s\n", str);
-		fprintf(stderr, "EOF while %s\n", str);
+    exit(1);
-		exit(1);
+  } else {
-	} else {
+    fprintf(stderr, "Unknown error while %s\n", str);
-		fprintf(stderr, "Unknown error while %s\n", str);
+    exit(1);
-		exit(1);
+  }
-	}
 }
 
-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_start = swap32(map->header.bss_addr);
+    uint32_t curr_size = swap32(map->header.bss_size);
-		uint32_t curr_size = swap32(map->header.bss_size);
+    if (paddr < curr_start)
-		if (paddr < curr_start)
+      map->header.bss_addr = swap32(paddr);
-			map->header.bss_addr = swap32(paddr);
+    // Total BSS size should be the end of the last bss section minus the
-		// Total BSS size should be the end of the last bss section minus the
+    // start of the first bss section.
-		// start of the first bss section.
+    if (paddr + memsz > curr_start + curr_size)
-		if (paddr + memsz > curr_start + curr_size)
+      map->header.bss_size = swap32(paddr + memsz - curr_start);
-			map->header.bss_size = swap32(paddr + memsz - curr_start);
+  } else {
-	} else {
+    map->header.bss_addr = swap32(paddr);
-		map->header.bss_addr = swap32(paddr);
+    map->header.bss_size = swap32(memsz);
-		map->header.bss_size = swap32(memsz);
+    map->flags |= HAVE_BSS;
-		map->flags |= HAVE_BSS;
+  }
-	}
 }
 
-void read_elf_segments(DOL_map *map, const char *elf)
+void read_elf_segments(DOL_map* map, const char* elf) {
-{
+  int read, i;
-	int read, i;
+  Elf32_Ehdr ehdr;
-	Elf32_Ehdr ehdr;
+
-	
+  if (verbosity >= 2)
-	if(verbosity >= 2)
+    fprintf(stderr, "Reading ELF file...\n");
-		fprintf(stderr, "Reading ELF file...\n");
+
-	
+  map->elf = fopen(elf, "rb");
-	map->elf = fopen(elf, "rb");
+  if (!map->elf)
-	if(!map->elf)
+    perrordie("Could not open ELF file");
-		perrordie("Could not open ELF file");
+
-	
+  read = fread(&ehdr, sizeof(ehdr), 1, map->elf);
-	read = fread(&ehdr, sizeof(ehdr), 1, map->elf);
+  if (read != 1)
-	if(read != 1)
+    ferrordie(map->elf, "reading ELF header");
-		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");
-		die("Invalid ELF header");
+  if (ehdr.e_ident[EI_CLASS] != ELFCLASS32)
-	if(ehdr.e_ident[EI_CLASS] != ELFCLASS32)
+    die("Invalid ELF class");
-		die("Invalid ELF class");
+  if (ehdr.e_ident[EI_DATA] != ELFDATA2MSB)
-	if(ehdr.e_ident[EI_DATA] != ELFDATA2MSB)
+    die("Invalid ELF byte order");
-		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");
-		die("Invalid ELF ident version");
+  if (swap32(ehdr.e_version) != EV_CURRENT)
-	if(swap32(ehdr.e_version) != EV_CURRENT)
+    die("Invalid ELF version");
-		die("Invalid ELF version");
+  if (swap16(ehdr.e_type) != ET_EXEC)
-	if(swap16(ehdr.e_type) != ET_EXEC)
+    die("ELF is not an executable");
-		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");
-		die("Machine is not PowerPC");
+  if (!swap32(ehdr.e_entry))
-	if(!swap32(ehdr.e_entry))
+    die("ELF has no entrypoint");
-		die("ELF has no entrypoint");
+
-		
+  map->header.entry = ehdr.e_entry;
-	map->header.entry = ehdr.e_entry;
+
-	
+  if (verbosity >= 2)
-	if(verbosity >= 2)
+    fprintf(stderr, "Valid ELF header found\n");
-		fprintf(stderr, "Valid ELF header found\n");
+
-	
+  uint16_t phnum = swap16(ehdr.e_phnum);
-	uint16_t phnum = swap16(ehdr.e_phnum);
+  uint32_t phoff = swap32(ehdr.e_phoff);
-	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");
-		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");
-		die("Invalid program header entry size");
+
-	
+  phdrs = malloc(phnum * sizeof(Elf32_Phdr));
-	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");
-		ferrordie(map->elf, "reading ELF program headers");
+  read = fread(phdrs, sizeof(Elf32_Phdr), phnum, map->elf);
-	read = fread(phdrs, sizeof(Elf32_Phdr), phnum, map->elf);
+  if (read != phnum)
-	if(read != phnum)
+    ferrordie(map->elf, "reading ELF program headers");
-		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 offset = swap32(phdrs[i].p_offset);
+      uint32_t paddr = swap32(phdrs[i].p_vaddr);
-			uint32_t paddr = swap32(phdrs[i].p_vaddr);
+      uint32_t filesz = swap32(phdrs[i].p_filesz);
-			uint32_t filesz = swap32(phdrs[i].p_filesz);
+      uint32_t memsz = swap32(phdrs[i].p_memsz);
-			uint32_t memsz = swap32(phdrs[i].p_memsz);
+      uint32_t flags = swap32(phdrs[i].p_flags);
-			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",
-					fprintf(stderr, "PHDR %d: 0x%x [0x%x] -> 0x%08x [0x%x] flags 0x%x\n",
+                  i, offset, filesz, paddr, memsz, flags);
-					        i, offset, filesz, paddr, memsz, flags);
+        if (flags & PF_X) {
-				if(flags & PF_X) {
+          // TEXT segment
-					// TEXT segment
+          if (!(flags & PF_R))
-					if(!(flags & PF_R))
+            fprintf(stderr, "Warning: non-readable segment %d\n", i);
-						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);
-						fprintf(stderr, "Warning: writable and executable segment %d\n", i);
+          if (filesz > memsz) {
-					if(filesz > memsz) {
+            fprintf(stderr,
-							fprintf(stderr, "Error: TEXT segment %d memory size (0x%x) smaller than file size (0x%x)\n",
+                    "Error: TEXT segment %d memory size (0x%x) smaller than "
-							                i, memsz, filesz);
+                    "file size (0x%x)\n",
-							exit(1);
+                    i, memsz, filesz);
-					} else if (memsz > filesz) {
+            exit(1);
-						add_bss(map, paddr + filesz, memsz - filesz);
+          } else if (memsz > filesz) {
-					}
+            add_bss(map, paddr + filesz, memsz - filesz);
-					if(map->text_cnt >= MAX_TEXT_SEGMENTS) {
+          }
-						die("Error: Too many TEXT segments");
+          if (map->text_cnt >= MAX_TEXT_SEGMENTS) {
-					}
+            die("Error: Too many TEXT segments");
-					map->header.text_addr[map->text_cnt] = swap32(paddr);
+          }
-					map->header.text_size[map->text_cnt] = swap32(filesz);
+          map->header.text_addr[map->text_cnt] = swap32(paddr);
-					map->text_elf_off[map->text_cnt] = offset;
+          map->header.text_size[map->text_cnt] = swap32(filesz);
-					map->text_cnt++;
+          map->text_elf_off[map->text_cnt] = offset;
-				} else {
+          map->text_cnt++;
-					// DATA or BSS segment
+        } else {
-					if(!(flags & PF_R))
+          // DATA or BSS segment
-						fprintf(stderr, "Warning: non-readable segment %d\n", i);
+          if (!(flags & PF_R))
-					if(filesz == 0) {
+            fprintf(stderr, "Warning: non-readable segment %d\n", i);
-						// BSS segment
+          if (filesz == 0) {
-						add_bss(map, paddr, memsz);
+            // BSS segment
-					} else {
+            add_bss(map, paddr, memsz);
-						// DATA segment
+          } else {
-						if(filesz > memsz) {
+            // DATA segment
-							fprintf(stderr, "Error: segment %d memory size (0x%x) is smaller than file size (0x%x)\n",
+            if (filesz > memsz) {
-							        i, memsz, filesz);
+              fprintf(stderr,
-							exit(1);
+                      "Error: segment %d memory size (0x%x) is smaller than "
-						}
+                      "file size (0x%x)\n",
-						if(map->data_cnt >= MAX_DATA_SEGMENTS) {
+                      i, memsz, filesz);
-							die("Error: Too many DATA segments");
+              exit(1);
-						}
+            }
-						map->header.data_addr[map->data_cnt] = swap32(paddr);
+            if (map->data_cnt >= MAX_DATA_SEGMENTS) {
-						map->header.data_size[map->data_cnt] = swap32(filesz);
+              die("Error: Too many DATA segments");
-						map->data_elf_off[map->data_cnt] = offset;
+            }
-						map->data_cnt++;
+            map->header.data_addr[map->data_cnt] = swap32(paddr);
-					}
+            map->header.data_size[map->data_cnt] = swap32(filesz);
-				}
+            map->data_elf_off[map->data_cnt] = offset;
-			
+            map->data_cnt++;
-			} else {
+          }
-				if(verbosity >= 1)
+        }
-					fprintf(stderr, "Skipping empty program header %d\n", i);
+
-			}
+      } else {
-		} else if(verbosity >= 1) {
+        if (verbosity >= 1)
-			fprintf(stderr, "Skipping program header %d of type %d\n", i, swap32(phdrs[i].p_type));
+          fprintf(stderr, "Skipping empty program header %d\n", i);
-		}
+      }
-	}
+    } else if (verbosity >= 1) {
-	if(verbosity >= 2) {
+      fprintf(stderr, "Skipping program header %d of type %d\n", i,
-		fprintf(stderr, "Segments:\n");
+              swap32(phdrs[i].p_type));
-		for(i=0; i<map->text_cnt; i++) {
+    }
-			fprintf(stderr, " TEXT %d: 0x%08x [0x%x] from ELF offset 0x%x\n",
+  }
-			        i, swap32(map->header.text_addr[i]), swap32(map->header.text_size[i]),
+  if (verbosity >= 2) {
-			        map->text_elf_off[i]);
+    fprintf(stderr, "Segments:\n");
-		}
+    for (i = 0; i < map->text_cnt; i++) {
-		for(i=0; i<map->data_cnt; i++) {
+      fprintf(stderr, " TEXT %d: 0x%08x [0x%x] from ELF offset 0x%x\n", i,
-			fprintf(stderr, " DATA %d: 0x%08x [0x%x] from ELF offset 0x%x\n",
+              swap32(map->header.text_addr[i]),
-			        i, swap32(map->header.data_addr[i]), swap32(map->header.data_size[i]),
+              swap32(map->header.text_size[i]), map->text_elf_off[i]);
-			        map->data_elf_off[i]);
+    }
-		}
+    for (i = 0; i < map->data_cnt; i++) {
-		if(map->flags & HAVE_BSS)
+      fprintf(stderr, " DATA %d: 0x%08x [0x%x] from ELF offset 0x%x\n", i,
-			fprintf(stderr, " BSS segment: 0x%08x [0x%x]\n", swap32(map->header.bss_addr),
+              swap32(map->header.data_addr[i]),
-			        swap32(map->header.bss_size));
+              swap32(map->header.data_size[i]), map->data_elf_off[i]);
-	}
+    }
+    if (map->flags & HAVE_BSS)
+      fprintf(stderr, " BSS segment: 0x%08x [0x%x]\n",
+              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;
-	uint32_t fpos;
+  int i;
-	int i;
+
-	
+  if (verbosity >= 2)
-	if(verbosity >= 2)
+    fprintf(stderr, "Laying out DOL file...\n");
-		fprintf(stderr, "Laying out DOL file...\n");
+
-	
+  fpos = DOL_ALIGN(sizeof(DOL_hdr));
-	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);
-			fprintf(stderr, " TEXT segment %d at 0x%x\n", i, fpos);
+    map->header.text_off[i] = swap32(fpos);
-		map->header.text_off[i] = swap32(fpos);
+    fpos = DOL_ALIGN(fpos + swap32(map->header.text_size[i]));
-		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);
-			fprintf(stderr, " DATA segment %d at 0x%x\n", i, fpos);
+    map->header.data_off[i] = swap32(fpos);
-		map->header.data_off[i] = swap32(fpos);
+    fpos = DOL_ALIGN(fpos + swap32(map->header.data_size[i]));
-		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,
-			fprintf(stderr, "Note: adding dummy TEXT segment to work around IOS bug\n");
+              "Note: adding dummy TEXT segment to work around IOS bug\n");
-		map->header.text_off[0] = swap32(DOL_ALIGN(sizeof(DOL_hdr)));
+    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,
-		map->header.data_off[0] = swap32(DOL_ALIGN(sizeof(DOL_hdr)));
+              "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 left = size;
-	int read;
+  int read;
-	int written;
+  int written;
-	int block;
+  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");
+    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");
+    ferrordie(dst, "writing DOL segment data");
-	
+
-	blockbuf = malloc(MIN(BLOCK, left));
+  blockbuf = malloc(MIN(BLOCK, left));
-	
+
-	while(left) {
+  while (left) {
-		block = MIN(BLOCK, left);
+    block = MIN(BLOCK, left);
-		read = fread(blockbuf, 1, block, src);
+    read = fread(blockbuf, 1, block, src);
-		if(read != block) {
+    if (read != block) {
-			free(blockbuf);
+      free(blockbuf);
-			ferrordie(src, "reading ELF segment data");
+      ferrordie(src, "reading ELF segment data");
-		}
+    }
-		written = fwrite(blockbuf, 1, block, dst);
+    written = fwrite(blockbuf, 1, block, dst);
-		if(written != block) {
+    if (written != block) {
-			free(blockbuf);
+      free(blockbuf);
-			ferrordie(dst, "writing DOL segment data");
+      ferrordie(dst, "writing DOL segment data");
-		}
+    }
-		left -= block;
+    left -= block;
-	}
+  }
-	free(blockbuf);
+  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;
-	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");
+    ferrordie(dst, "writing DOL segment data");
-	for(i=0; i<size; i++)
+  for (i = 0; i < size; i++)
-		fputc(0, dst);
+    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 written;
+  int i;
-	int i;
 
-	if(verbosity >= 2)
+  if (verbosity >= 2)
-		fprintf(stderr, "Writing DOL file...\n");
+    fprintf(stderr, "Writing DOL file...\n");
-		
+
-	dolf = fopen(dol, "wb");
+  dolf = fopen(dol, "wb");
-	if(!dolf)
+  if (!dolf)
-		perrordie("Could not open DOL file");
+    perrordie("Could not open DOL file");
-	
+
-	if(verbosity >= 2) {
+  if (verbosity >= 2) {
-		fprintf(stderr, "DOL header:\n");
+    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,
+      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_off[i]));
+              swap32(map->header.text_size[i]),
-		for(i=0; i<MAX(1,map->data_cnt); i++)
+              swap32(map->header.text_off[i]));
-			fprintf(stderr, " DATA %d @ 0x%08x [0x%x] off 0x%x\n", i,
+    for (i = 0; i < MAX(1, map->data_cnt); i++)
-			        swap32(map->header.data_addr[i]), swap32(map->header.data_size[i]),
+      fprintf(stderr, " DATA %d @ 0x%08x [0x%x] off 0x%x\n", i,
-			        swap32(map->header.data_off[i]));
+              swap32(map->header.data_addr[i]),
-		if(swap32(map->header.bss_addr) && swap32(map->header.bss_size))
+              swap32(map->header.data_size[i]),
-			fprintf(stderr, " BSS @ 0x%08x [0x%x]\n", swap32(map->header.bss_addr),
+              swap32(map->header.data_off[i]));
-			        swap32(map->header.bss_size));
+    if (swap32(map->header.bss_addr) && swap32(map->header.bss_size))
-		fprintf(stderr, " Entry: 0x%08x\n", swap32(map->header.entry));
+      fprintf(stderr, " BSS @ 0x%08x [0x%x]\n", swap32(map->header.bss_addr),
-		fprintf(stderr, "Writing DOL header...\n");
+              swap32(map->header.bss_size));
-	}
+    fprintf(stderr, " Entry: 0x%08x\n", swap32(map->header.entry));
-	
+    fprintf(stderr, "Writing DOL header...\n");
-	// 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++)
+  // Write DOL header with aligned text and data section sizes
-		aligned_header.text_size[i] = swap32(DOL_ALIGN(swap32(aligned_header.text_size[i])));
+  DOL_hdr aligned_header = map->header;
-	for(i=0; i<ARRAY_COUNT(aligned_header.data_size); i++)
+  for (i = 0; i < ARRAY_COUNT(aligned_header.text_size); i++)
-		aligned_header.data_size[i] = swap32(DOL_ALIGN(swap32(aligned_header.data_size[i])));
+    aligned_header.text_size[i] =
-	written = fwrite(&aligned_header, sizeof(DOL_hdr), 1, dolf);
+        swap32(DOL_ALIGN(swap32(aligned_header.text_size[i])));
-	if(written != 1)
+  for (i = 0; i < ARRAY_COUNT(aligned_header.data_size); i++)
-		ferrordie(dolf, "writing DOL header");
+    aligned_header.data_size[i] =
-	
+        swap32(DOL_ALIGN(swap32(aligned_header.data_size[i])));
-	for(i=0; i<map->text_cnt; i++) {
+  written = fwrite(&aligned_header, sizeof(DOL_hdr), 1, dolf);
-		uint32_t size = swap32(map->header.text_size[i]);
+  if (written != 1)
-		uint32_t padded_size = DOL_ALIGN(size);
+    ferrordie(dolf, "writing DOL header");
-		if(verbosity >= 2)
+
-			fprintf(stderr, "Writing TEXT segment %d...\n", i);
+  for (i = 0; i < map->text_cnt; i++) {
-		fcpy(dolf, map->elf, swap32(map->header.text_off[i]), map->text_elf_off[i], size);
+    uint32_t size = swap32(map->header.text_size[i]);
-		if (padded_size > size)
+    uint32_t padded_size = DOL_ALIGN(size);
-			fpad(dolf, swap32(map->header.text_off[i]) + size, padded_size - size);
+    if (verbosity >= 2)
-	}
+      fprintf(stderr, "Writing TEXT segment %d...\n", i);
-	for(i=0; i<map->data_cnt; i++) {
+    fcpy(dolf, map->elf, swap32(map->header.text_off[i]), map->text_elf_off[i],
-		uint32_t size = swap32(map->header.data_size[i]);
+         size);
-		uint32_t padded_size = DOL_ALIGN(size);
+    if (padded_size > size)
-		if(verbosity >= 2)
+      fpad(dolf, swap32(map->header.text_off[i]) + size, padded_size - size);
-			fprintf(stderr, "Writing DATA segment %d...\n", i);
+  }
-		fcpy(dolf, map->elf, swap32(map->header.data_off[i]), map->data_elf_off[i], size);
+  for (i = 0; i < map->data_cnt; i++) {
-		if (padded_size > size)
+    uint32_t size = swap32(map->header.data_size[i]);
-			fpad(dolf, swap32(map->header.data_off[i]) + size, padded_size - size);
+    uint32_t padded_size = DOL_ALIGN(size);
-	}
+    if (verbosity >= 2)
-	
+      fprintf(stderr, "Writing DATA segment %d...\n", i);
-	if(verbosity >= 2)
+    fcpy(dolf, map->elf, swap32(map->header.data_off[i]), map->data_elf_off[i],
-		fprintf(stderr, "All done!\n");
+         size);
-	
+    if (padded_size > size)
-	fclose(map->elf);
+      fpad(dolf, swap32(map->header.data_off[i]) + size, padded_size - size);
-	fclose(dolf);
+  }
+
+  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]);
+    usage(argv[0]);
-		return 1;
+    return 1;
-	}
+  }
-	arg = &argv[1];
+  arg = &argv[1];
-	argc--;
+  argc--;
 
-	while(argc && *arg[0] == '-') {
+  while (argc && *arg[0] == '-') {
-		if(!strcmp(*arg, "-h")) {
+    if (!strcmp(*arg, "-h")) {
-			usage(argv[0]);
+      usage(argv[0]);
-			return 1;
+      return 1;
-		} else if(!strcmp(*arg, "-v")) {
+    } else if (!strcmp(*arg, "-v")) {
-			verbosity++;
+      verbosity++;
-		} else if(!strcmp(*arg, "--")) {
+    } else if (!strcmp(*arg, "--")) {
-			arg++;
+      arg++;
-			argc--;
+      argc--;
-			break;
+      break;
-		} else {
+    } else {
-			fprintf(stderr, "Unrecognized option %s\n", *arg);
+      fprintf(stderr, "Unrecognized option %s\n", *arg);
-			usage(argv[0]);
+      usage(argv[0]);
-			return 1;
+      return 1;
-		}
+    }
-		arg++;
+    arg++;
-		argc--;
+    argc--;
-	}
+  }
-	if(argc < 2) {
+  if (argc < 2) {
-		usage(argv[0]);
+    usage(argv[0]);
-		exit(1);
+    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;
+  DOL_map map;
 
-	memset(&map, 0, sizeof(map));
+  memset(&map, 0, sizeof(map));
 
-	read_elf_segments(&map, elf_file);
+  read_elf_segments(&map, elf_file);
-	map_dol(&map);
+  map_dol(&map);
-	write_dol(&map, dol_file);
+  write_dol(&map, dol_file);
-	
+
-	return 0;
+  return 0;
 }

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