diff --git a/thirdparty/opnmidi/CMakeLists.txt b/thirdparty/opnmidi/CMakeLists.txt index 955ff4a..61cdf90 100644 --- a/thirdparty/opnmidi/CMakeLists.txt +++ b/thirdparty/opnmidi/CMakeLists.txt @@ -10,16 +10,34 @@ add_definitions(-DOPNMIDI_DISABLE_MIDI_SEQUENCER) add_definitions(-DOPNMIDI_DISABLE_GX_EMULATOR) add_library( opn STATIC - chips/gens_opn2.cpp - chips/gens/Ym2612_Emu.cpp - chips/mame/mame_ym2612fm.c - chips/mame_opn2.cpp - chips/nuked_opn2.cpp - chips/nuked/ym3438.c - opnmidi.cpp opnmidi_load.cpp + opnmidi_private.cpp + opnmidi.cpp opnmidi_midiplay.cpp opnmidi_opn2.cpp - opnmidi_private.cpp - wopn/wopn_file.c ) + chips/np2/fmgen_fmgen.cpp + chips/np2/fmgen_opna.cpp + chips/np2/fmgen_fmtimer.cpp + chips/np2/fmgen_file.cpp + chips/np2/fmgen_psg.cpp + chips/mame_opn2.cpp + chips/gens_opn2.cpp + chips/mame_opna.cpp + chips/np2_opna.cpp + chips/mamefm/ymdeltat.cpp + chips/mamefm/resampler.cpp + chips/mamefm/fm.cpp + chips/nuked_opn2.cpp + chips/gens/Ym2612_Emu.cpp + chips/gx_opn2.cpp + chips/pmdwin_opna.cpp + chips/nuked/ym3438.c + chips/gx/gx_ym2612.c + chips/pmdwin/opna.c + chips/pmdwin/psg.c + chips/pmdwin/rhythmdata.c + chips/mamefm/emu2149.c + chips/mame/mame_ym2612fm.c + wopn/wopn_file.c + ) target_link_libraries( opn ) diff --git a/thirdparty/opnmidi/chips/gens_opn2.cpp b/thirdparty/opnmidi/chips/gens_opn2.cpp index a43e57e..492efdc 100644 --- a/thirdparty/opnmidi/chips/gens_opn2.cpp +++ b/thirdparty/opnmidi/chips/gens_opn2.cpp @@ -1,7 +1,7 @@ /* * Interfaces over Yamaha OPN2 (YM2612) chip emulators * - * Copyright (C) 2017-2018 Vitaly Novichkov (Wohlstand) + * Copyright (c) 2017-2020 Vitaly Novichkov (Wohlstand) * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public @@ -23,8 +23,9 @@ #include "gens/Ym2612_Emu.h" -GensOPN2::GensOPN2() - : chip(new Ym2612_Emu()) +GensOPN2::GensOPN2(OPNFamily f) + : OPNChipBaseBufferedT(f), + chip(new Ym2612_Emu()) { setRate(m_rate, m_clock); } @@ -37,7 +38,7 @@ GensOPN2::~GensOPN2() void GensOPN2::setRate(uint32_t rate, uint32_t clock) { OPNChipBaseBufferedT::setRate(rate, clock); - uint32_t chipRate = isRunningAtPcmRate() ? rate : static_cast(nativeRate); + uint32_t chipRate = isRunningAtPcmRate() ? rate : nativeRate(); chip->set_rate(chipRate, clock); // implies reset() } diff --git a/thirdparty/opnmidi/chips/gens_opn2.h b/thirdparty/opnmidi/chips/gens_opn2.h index 240a620..90efb0e 100644 --- a/thirdparty/opnmidi/chips/gens_opn2.h +++ b/thirdparty/opnmidi/chips/gens_opn2.h @@ -1,7 +1,7 @@ /* * Interfaces over Yamaha OPN2 (YM2612) chip emulators * - * Copyright (C) 2017-2018 Vitaly Novichkov (Wohlstand) + * Copyright (c) 2017-2020 Vitaly Novichkov (Wohlstand) * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public @@ -28,7 +28,7 @@ class GensOPN2 final : public OPNChipBaseBufferedT { Ym2612_Emu *chip; public: - GensOPN2(); + explicit GensOPN2(OPNFamily f); ~GensOPN2() override; bool canRunAtPcmRate() const override { return true; } diff --git a/thirdparty/opnmidi/chips/gx/gx_ym2612.c b/thirdparty/opnmidi/chips/gx/gx_ym2612.c new file mode 100644 index 0000000..246e2da --- /dev/null +++ b/thirdparty/opnmidi/chips/gx/gx_ym2612.c @@ -0,0 +1,2271 @@ +/* +** +** software implementation of Yamaha FM sound generator (YM2612/YM3438) +** +** Original code (MAME fm.c) +** +** Copyright (C) 2001, 2002, 2003 Jarek Burczynski (bujar at mame dot net) +** Copyright (C) 1998 Tatsuyuki Satoh , MultiArcadeMachineEmulator development +** +** Version 1.4 (final beta) +** +** Additional code & fixes by Eke-Eke for Genesis Plus GX +** +** Huge thanks to Nemesis, most of those fixes came from his tests on Sega Genesis hardware +** Additional info from YM2612 die shot analysis by Sauraen +** See http://gendev.spritesmind.net/forum/viewtopic.php?t=386 +** +*/ + +/* +** CHANGELOG: +** +** 08-06-2018 JPCima (OPNMIDI) +** - repaired the multichip support back +** +** 03-12-2017 Eke-Eke (Genesis Plus GX): +** - improved 9-bit DAC emulation accuracy +** - added discrete YM2612 DAC distortion emulation ("ladder effect") +** - replaced configurable DAC depth with configurable chip types (discrete, integrated or enhanced) +** +** 26-09-2017 Eke-Eke (Genesis Plus GX): +** - fixed EG counter loopback behavior (verified on YM3438 die) +** - reverted changes to EG rates 2-7 increment values +** +** 09-04-2017 Eke-Eke (Genesis Plus GX): +** - fixed LFO PM implementation: block & keyscale code should not be modified by LFO (verified on YM2612 die) +** - fixed Timer B overflow handling +** +** 12-03-2017 Eke-Eke (Genesis Plus GX): +** - fixed Op1 self-feedback regression introduced by previous modifications +** - removed one-sample extra delay on Op1 calculated output +** - refactored chan_calc() function +** +** 01-09-2012 Eke-Eke (Genesis Plus GX): +** - removed input clock / output samplerate frequency ratio, chip now always run at (original) internal sample frequency +** - removed now uneeded extra bits of precision +** +** 2006~2012 Eke-Eke (Genesis Plus GX): +** - removed unused multichip support +** - added YM2612 Context external access functions +** - fixed LFO implementation: +** .added support for CH3 special mode: fixes various sound effects (birds in Warlock, bug sound in Aladdin...) +** .inverted LFO AM waveform: fixes Spider-Man & Venom : Separation Anxiety (intro), California Games (surfing event) +** .improved LFO timing accuracy: now updated AFTER sample output, like EG/PG updates, and without any precision loss anymore. +** - improved internal timers emulation +** - adjusted lowest EG rates increment values +** - fixed Attack Rate not being updated in some specific cases (Batman & Robin intro) +** - fixed EG behavior when Attack Rate is maximal +** - fixed EG behavior when SL=0 (Mega Turrican tracks 03,09...) or/and Key ON occurs at minimal attenuation +** - implemented EG output immediate changes on register writes +** - fixed YM2612 initial values (after the reset): fixes missing intro in B.O.B +** - implemented Detune overflow (Ariel, Comix Zone, Shaq Fu, Spiderman & many other games using GEMS sound engine) +** - implemented accurate CSM mode emulation +** - implemented accurate SSG-EG emulation (Asterix, Beavis&Butthead, Bubba'n Stix & many other games) +** - implemented accurate address/data ports behavior +** - added preliminar support for DAC precision +** +** 03-08-2003 Jarek Burczynski: +** - fixed YM2608 initial values (after the reset) +** - fixed flag and irqmask handling (YM2608) +** - fixed BUFRDY flag handling (YM2608) +** +** 14-06-2003 Jarek Burczynski: +** - implemented all of the YM2608 status register flags +** - implemented support for external memory read/write via YM2608 +** - implemented support for deltat memory limit register in YM2608 emulation +** +** 22-05-2003 Jarek Burczynski: +** - fixed LFO PM calculations (copy&paste bugfix) +** +** 08-05-2003 Jarek Burczynski: +** - fixed SSG support +** +** 22-04-2003 Jarek Burczynski: +** - implemented 100% correct LFO generator (verified on real YM2610 and YM2608) +** +** 15-04-2003 Jarek Burczynski: +** - added support for YM2608's register 0x110 - status mask +** +** 01-12-2002 Jarek Burczynski: +** - fixed register addressing in YM2608, YM2610, YM2610B chips. (verified on real YM2608) +** The addressing patch used for early Neo-Geo games can be removed now. +** +** 26-11-2002 Jarek Burczynski, Nicola Salmoria: +** - recreated YM2608 ADPCM ROM using data from real YM2608's output which leads to: +** - added emulation of YM2608 drums. +** - output of YM2608 is two times lower now - same as YM2610 (verified on real YM2608) +** +** 16-08-2002 Jarek Burczynski: +** - binary exact Envelope Generator (verified on real YM2203); +** identical to YM2151 +** - corrected 'off by one' error in feedback calculations (when feedback is off) +** - corrected connection (algorithm) calculation (verified on real YM2203 and YM2610) +** +** 18-12-2001 Jarek Burczynski: +** - added SSG-EG support (verified on real YM2203) +** +** 12-08-2001 Jarek Burczynski: +** - corrected sin_tab and tl_tab data (verified on real chip) +** - corrected feedback calculations (verified on real chip) +** - corrected phase generator calculations (verified on real chip) +** - corrected envelope generator calculations (verified on real chip) +** - corrected FM volume level (YM2610 and YM2610B). +** - changed YMxxxUpdateOne() functions (YM2203, YM2608, YM2610, YM2610B, YM2612) : +** this was needed to calculate YM2610 FM channels output correctly. +** (Each FM channel is calculated as in other chips, but the output of the channel +** gets shifted right by one *before* sending to accumulator. That was impossible to do +** with previous implementation). +** +** 23-07-2001 Jarek Burczynski, Nicola Salmoria: +** - corrected YM2610 ADPCM type A algorithm and tables (verified on real chip) +** +** 11-06-2001 Jarek Burczynski: +** - corrected end of sample bug in ADPCMA_calc_cha(). +** Real YM2610 checks for equality between current and end addresses (only 20 LSB bits). +** +** 08-12-98 hiro-shi: +** rename ADPCMA -> ADPCMB, ADPCMB -> ADPCMA +** move ROM limit check.(CALC_CH? -> 2610Write1/2) +** test program (ADPCMB_TEST) +** move ADPCM A/B end check. +** ADPCMB repeat flag(no check) +** change ADPCM volume rate (8->16) (32->48). +** +** 09-12-98 hiro-shi: +** change ADPCM volume. (8->16, 48->64) +** replace ym2610 ch0/3 (YM-2610B) +** change ADPCM_SHIFT (10->8) missing bank change 0x4000-0xffff. +** add ADPCM_SHIFT_MASK +** change ADPCMA_DECODE_MIN/MAX. +*/ + +/************************************************************************/ +/* comment of hiro-shi(Hiromitsu Shioya) */ +/* YM2610(B) = OPN-B */ +/* YM2610 : PSG:3ch FM:4ch ADPCM(18.5KHz):6ch DeltaT ADPCM:1ch */ +/* YM2610B : PSG:3ch FM:6ch ADPCM(18.5KHz):6ch DeltaT ADPCM:1ch */ +/************************************************************************/ + +#include "gx_ym2612.h" +#include "../mame/mamedef.h" +#include +#include +#include + +/* envelope generator */ +#define ENV_BITS 10 +#define ENV_LEN (1<>3) + +/* sin waveform table in 'decibel' scale */ +static unsigned int sin_tab[SIN_LEN]; + +/* sustain level table (3dB per step) */ +/* bit0, bit1, bit2, bit3, bit4, bit5, bit6 */ +/* 1, 2, 4, 8, 16, 32, 64 (value)*/ +/* 0.75, 1.5, 3, 6, 12, 24, 48 (dB)*/ + +/* 0 - 15: 0, 3, 6, 9,12,15,18,21,24,27,30,33,36,39,42,93 (dB)*/ +/* attenuation value (10 bits) = (SL << 2) << 3 */ +#define SC(db) (UINT32) ( db * (4.0/ENV_STEP) ) +static const UINT32 sl_table[16]={ + SC( 0),SC( 1),SC( 2),SC(3 ),SC(4 ),SC(5 ),SC(6 ),SC( 7), + SC( 8),SC( 9),SC(10),SC(11),SC(12),SC(13),SC(14),SC(31) +}; +#undef SC + + +#define RATE_STEPS (8) +static const UINT8 eg_inc[19*RATE_STEPS]={ + +/*cycle:0 1 2 3 4 5 6 7*/ + +/* 0 */ 0,1, 0,1, 0,1, 0,1, /* rates 00..11 0 (increment by 0 or 1) */ +/* 1 */ 0,1, 0,1, 1,1, 0,1, /* rates 00..11 1 */ +/* 2 */ 0,1, 1,1, 0,1, 1,1, /* rates 00..11 2 */ +/* 3 */ 0,1, 1,1, 1,1, 1,1, /* rates 00..11 3 */ + +/* 4 */ 1,1, 1,1, 1,1, 1,1, /* rate 12 0 (increment by 1) */ +/* 5 */ 1,1, 1,2, 1,1, 1,2, /* rate 12 1 */ +/* 6 */ 1,2, 1,2, 1,2, 1,2, /* rate 12 2 */ +/* 7 */ 1,2, 2,2, 1,2, 2,2, /* rate 12 3 */ + +/* 8 */ 2,2, 2,2, 2,2, 2,2, /* rate 13 0 (increment by 2) */ +/* 9 */ 2,2, 2,4, 2,2, 2,4, /* rate 13 1 */ +/*10 */ 2,4, 2,4, 2,4, 2,4, /* rate 13 2 */ +/*11 */ 2,4, 4,4, 2,4, 4,4, /* rate 13 3 */ + +/*12 */ 4,4, 4,4, 4,4, 4,4, /* rate 14 0 (increment by 4) */ +/*13 */ 4,4, 4,8, 4,4, 4,8, /* rate 14 1 */ +/*14 */ 4,8, 4,8, 4,8, 4,8, /* rate 14 2 */ +/*15 */ 4,8, 8,8, 4,8, 8,8, /* rate 14 3 */ + +/*16 */ 8,8, 8,8, 8,8, 8,8, /* rates 15 0, 15 1, 15 2, 15 3 (increment by 8) */ +/*17 */ 16,16,16,16,16,16,16,16, /* rates 15 2, 15 3 for attack */ +/*18 */ 0,0, 0,0, 0,0, 0,0, /* infinity rates for attack and decay(s) */ +}; + + +#define O(a) (a*RATE_STEPS) + +/*note that there is no O(17) in this table - it's directly in the code */ +static const UINT8 eg_rate_select[32+64+32]={ /* Envelope Generator rates (32 + 64 rates + 32 RKS) */ +/* 32 infinite time rates (same as Rate 0) */ +O(18),O(18),O(18),O(18),O(18),O(18),O(18),O(18), +O(18),O(18),O(18),O(18),O(18),O(18),O(18),O(18), +O(18),O(18),O(18),O(18),O(18),O(18),O(18),O(18), +O(18),O(18),O(18),O(18),O(18),O(18),O(18),O(18), + +/* rates 00-11 */ +/* +O( 0),O( 1) +*/ +O(18),O(18), /* from Nemesis's tests on real YM2612 hardware */ + O( 2),O( 3), +O( 0),O( 1),O( 2),O( 3), +O( 0),O( 1),O( 2),O( 3), +O( 0),O( 1),O( 2),O( 3), +O( 0),O( 1),O( 2),O( 3), +O( 0),O( 1),O( 2),O( 3), +O( 0),O( 1),O( 2),O( 3), +O( 0),O( 1),O( 2),O( 3), +O( 0),O( 1),O( 2),O( 3), +O( 0),O( 1),O( 2),O( 3), +O( 0),O( 1),O( 2),O( 3), +O( 0),O( 1),O( 2),O( 3), + +/* rate 12 */ +O( 4),O( 5),O( 6),O( 7), + +/* rate 13 */ +O( 8),O( 9),O(10),O(11), + +/* rate 14 */ +O(12),O(13),O(14),O(15), + +/* rate 15 */ +O(16),O(16),O(16),O(16), + +/* 32 dummy rates (same as 15 3) */ +O(16),O(16),O(16),O(16),O(16),O(16),O(16),O(16), +O(16),O(16),O(16),O(16),O(16),O(16),O(16),O(16), +O(16),O(16),O(16),O(16),O(16),O(16),O(16),O(16), +O(16),O(16),O(16),O(16),O(16),O(16),O(16),O(16) + +}; +#undef O + +/*rate 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15*/ +/*shift 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 0, 0, 0, 0 */ +/*mask 2047, 1023, 511, 255, 127, 63, 31, 15, 7, 3, 1, 0, 0, 0, 0, 0 */ + +#define O(a) (a*1) +static const UINT8 eg_rate_shift[32+64+32]={ /* Envelope Generator counter shifts (32 + 64 rates + 32 RKS) */ +/* 32 infinite time rates */ +/* O(0),O(0),O(0),O(0),O(0),O(0),O(0),O(0), +O(0),O(0),O(0),O(0),O(0),O(0),O(0),O(0), +O(0),O(0),O(0),O(0),O(0),O(0),O(0),O(0), +O(0),O(0),O(0),O(0),O(0),O(0),O(0),O(0), */ + +/* fixed (should be the same as rate 0, even if it makes no difference since increment value is 0 for these rates) */ +O(11),O(11),O(11),O(11),O(11),O(11),O(11),O(11), +O(11),O(11),O(11),O(11),O(11),O(11),O(11),O(11), +O(11),O(11),O(11),O(11),O(11),O(11),O(11),O(11), +O(11),O(11),O(11),O(11),O(11),O(11),O(11),O(11), + +/* rates 00-11 */ +O(11),O(11),O(11),O(11), +O(10),O(10),O(10),O(10), +O( 9),O( 9),O( 9),O( 9), +O( 8),O( 8),O( 8),O( 8), +O( 7),O( 7),O( 7),O( 7), +O( 6),O( 6),O( 6),O( 6), +O( 5),O( 5),O( 5),O( 5), +O( 4),O( 4),O( 4),O( 4), +O( 3),O( 3),O( 3),O( 3), +O( 2),O( 2),O( 2),O( 2), +O( 1),O( 1),O( 1),O( 1), +O( 0),O( 0),O( 0),O( 0), + +/* rate 12 */ +O( 0),O( 0),O( 0),O( 0), + +/* rate 13 */ +O( 0),O( 0),O( 0),O( 0), + +/* rate 14 */ +O( 0),O( 0),O( 0),O( 0), + +/* rate 15 */ +O( 0),O( 0),O( 0),O( 0), + +/* 32 dummy rates (same as 15 3) */ +O( 0),O( 0),O( 0),O( 0),O( 0),O( 0),O( 0),O( 0), +O( 0),O( 0),O( 0),O( 0),O( 0),O( 0),O( 0),O( 0), +O( 0),O( 0),O( 0),O( 0),O( 0),O( 0),O( 0),O( 0), +O( 0),O( 0),O( 0),O( 0),O( 0),O( 0),O( 0),O( 0) + +}; +#undef O + +static const UINT8 dt_tab[4 * 32]={ +/* this is YM2151 and YM2612 phase increment data (in 10.10 fixed point format)*/ +/* FD=0 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +/* FD=1 */ + 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, + 2, 3, 3, 3, 4, 4, 4, 5, 5, 6, 6, 7, 8, 8, 8, 8, +/* FD=2 */ + 1, 1, 1, 1, 2, 2, 2, 2, 2, 3, 3, 3, 4, 4, 4, 5, + 5, 6, 6, 7, 8, 8, 9,10,11,12,13,14,16,16,16,16, +/* FD=3 */ + 2, 2, 2, 2, 2, 3, 3, 3, 4, 4, 4, 5, 5, 6, 6, 7, + 8 , 8, 9,10,11,12,13,14,16,17,19,20,22,22,22,22 +}; + + +/* OPN key frequency number -> key code follow table */ +/* fnum higher 4bit -> keycode lower 2bit */ +static const UINT8 opn_fktable[16] = {0,0,0,0,0,0,0,1,2,3,3,3,3,3,3,3}; + + +/* 8 LFO speed parameters */ +/* each value represents number of samples that one LFO level will last for */ +static const UINT32 lfo_samples_per_step[8] = {108, 77, 71, 67, 62, 44, 8, 5}; + + +/*There are 4 different LFO AM depths available, they are: + 0 dB, 1.4 dB, 5.9 dB, 11.8 dB + Here is how it is generated (in EG steps): + + 11.8 dB = 0, 2, 4, 6, 8, 10,12,14,16...126,126,124,122,120,118,....4,2,0 + 5.9 dB = 0, 1, 2, 3, 4, 5, 6, 7, 8....63, 63, 62, 61, 60, 59,.....2,1,0 + 1.4 dB = 0, 0, 0, 0, 1, 1, 1, 1, 2,...15, 15, 15, 15, 14, 14,.....0,0,0 + + (1.4 dB is loosing precision as you can see) + + It's implemented as generator from 0..126 with step 2 then a shift + right N times, where N is: + 8 for 0 dB + 3 for 1.4 dB + 1 for 5.9 dB + 0 for 11.8 dB +*/ +static const UINT8 lfo_ams_depth_shift[4] = {8, 3, 1, 0}; + + + +/*There are 8 different LFO PM depths available, they are: + 0, 3.4, 6.7, 10, 14, 20, 40, 80 (cents) + + Modulation level at each depth depends on F-NUMBER bits: 4,5,6,7,8,9,10 + (bits 8,9,10 = FNUM MSB from OCT/FNUM register) + + Here we store only first quarter (positive one) of full waveform. + Full table (lfo_pm_table) containing all 128 waveforms is build + at run (init) time. + + One value in table below represents 4 (four) basic LFO steps + (1 PM step = 4 AM steps). + + For example: + at LFO SPEED=0 (which is 108 samples per basic LFO step) + one value from "lfo_pm_output" table lasts for 432 consecutive + samples (4*108=432) and one full LFO waveform cycle lasts for 13824 + samples (32*432=13824; 32 because we store only a quarter of whole + waveform in the table below) +*/ +static const UINT8 lfo_pm_output[7*8][8]={ +/* 7 bits meaningful (of F-NUMBER), 8 LFO output levels per one depth (out of 32), 8 LFO depths */ +/* FNUM BIT 4: 000 0001xxxx */ +/* DEPTH 0 */ {0, 0, 0, 0, 0, 0, 0, 0}, +/* DEPTH 1 */ {0, 0, 0, 0, 0, 0, 0, 0}, +/* DEPTH 2 */ {0, 0, 0, 0, 0, 0, 0, 0}, +/* DEPTH 3 */ {0, 0, 0, 0, 0, 0, 0, 0}, +/* DEPTH 4 */ {0, 0, 0, 0, 0, 0, 0, 0}, +/* DEPTH 5 */ {0, 0, 0, 0, 0, 0, 0, 0}, +/* DEPTH 6 */ {0, 0, 0, 0, 0, 0, 0, 0}, +/* DEPTH 7 */ {0, 0, 0, 0, 1, 1, 1, 1}, + +/* FNUM BIT 5: 000 0010xxxx */ +/* DEPTH 0 */ {0, 0, 0, 0, 0, 0, 0, 0}, +/* DEPTH 1 */ {0, 0, 0, 0, 0, 0, 0, 0}, +/* DEPTH 2 */ {0, 0, 0, 0, 0, 0, 0, 0}, +/* DEPTH 3 */ {0, 0, 0, 0, 0, 0, 0, 0}, +/* DEPTH 4 */ {0, 0, 0, 0, 0, 0, 0, 0}, +/* DEPTH 5 */ {0, 0, 0, 0, 0, 0, 0, 0}, +/* DEPTH 6 */ {0, 0, 0, 0, 1, 1, 1, 1}, +/* DEPTH 7 */ {0, 0, 1, 1, 2, 2, 2, 3}, + +/* FNUM BIT 6: 000 0100xxxx */ +/* DEPTH 0 */ {0, 0, 0, 0, 0, 0, 0, 0}, +/* DEPTH 1 */ {0, 0, 0, 0, 0, 0, 0, 0}, +/* DEPTH 2 */ {0, 0, 0, 0, 0, 0, 0, 0}, +/* DEPTH 3 */ {0, 0, 0, 0, 0, 0, 0, 0}, +/* DEPTH 4 */ {0, 0, 0, 0, 0, 0, 0, 1}, +/* DEPTH 5 */ {0, 0, 0, 0, 1, 1, 1, 1}, +/* DEPTH 6 */ {0, 0, 1, 1, 2, 2, 2, 3}, +/* DEPTH 7 */ {0, 0, 2, 3, 4, 4, 5, 6}, + +/* FNUM BIT 7: 000 1000xxxx */ +/* DEPTH 0 */ {0, 0, 0, 0, 0, 0, 0, 0}, +/* DEPTH 1 */ {0, 0, 0, 0, 0, 0, 0, 0}, +/* DEPTH 2 */ {0, 0, 0, 0, 0, 0, 1, 1}, +/* DEPTH 3 */ {0, 0, 0, 0, 1, 1, 1, 1}, +/* DEPTH 4 */ {0, 0, 0, 1, 1, 1, 1, 2}, +/* DEPTH 5 */ {0, 0, 1, 1, 2, 2, 2, 3}, +/* DEPTH 6 */ {0, 0, 2, 3, 4, 4, 5, 6}, +/* DEPTH 7 */ {0, 0, 4, 6, 8, 8, 0xa, 0xc}, + +/* FNUM BIT 8: 001 0000xxxx */ +/* DEPTH 0 */ {0, 0, 0, 0, 0, 0, 0, 0}, +/* DEPTH 1 */ {0, 0, 0, 0, 1, 1, 1, 1}, +/* DEPTH 2 */ {0, 0, 0, 1, 1, 1, 2, 2}, +/* DEPTH 3 */ {0, 0, 1, 1, 2, 2, 3, 3}, +/* DEPTH 4 */ {0, 0, 1, 2, 2, 2, 3, 4}, +/* DEPTH 5 */ {0, 0, 2, 3, 4, 4, 5, 6}, +/* DEPTH 6 */ {0, 0, 4, 6, 8, 8, 0xa, 0xc}, +/* DEPTH 7 */ {0, 0, 8, 0xc,0x10,0x10,0x14,0x18}, + +/* FNUM BIT 9: 010 0000xxxx */ +/* DEPTH 0 */ {0, 0, 0, 0, 0, 0, 0, 0}, +/* DEPTH 1 */ {0, 0, 0, 0, 2, 2, 2, 2}, +/* DEPTH 2 */ {0, 0, 0, 2, 2, 2, 4, 4}, +/* DEPTH 3 */ {0, 0, 2, 2, 4, 4, 6, 6}, +/* DEPTH 4 */ {0, 0, 2, 4, 4, 4, 6, 8}, +/* DEPTH 5 */ {0, 0, 4, 6, 8, 8, 0xa, 0xc}, +/* DEPTH 6 */ {0, 0, 8, 0xc,0x10,0x10,0x14,0x18}, +/* DEPTH 7 */ {0, 0,0x10,0x18,0x20,0x20,0x28,0x30}, + +/* FNUM BIT10: 100 0000xxxx */ +/* DEPTH 0 */ {0, 0, 0, 0, 0, 0, 0, 0}, +/* DEPTH 1 */ {0, 0, 0, 0, 4, 4, 4, 4}, +/* DEPTH 2 */ {0, 0, 0, 4, 4, 4, 8, 8}, +/* DEPTH 3 */ {0, 0, 4, 4, 8, 8, 0xc, 0xc}, +/* DEPTH 4 */ {0, 0, 4, 8, 8, 8, 0xc,0x10}, +/* DEPTH 5 */ {0, 0, 8, 0xc,0x10,0x10,0x14,0x18}, +/* DEPTH 6 */ {0, 0,0x10,0x18,0x20,0x20,0x28,0x30}, +/* DEPTH 7 */ {0, 0,0x20,0x30,0x40,0x40,0x50,0x60}, + +}; + +/* all 128 LFO PM waveforms */ +static INT32 lfo_pm_table[128*8*32]; /* 128 combinations of 7 bits meaningful (of F-NUMBER), 8 LFO depths, 32 LFO output levels per one depth */ + +/* register number to channel number , slot offset */ +#define OPN_CHAN(N) (N&3) +#define OPN_SLOT(N) ((N>>2)&3) + +/* slot number */ +#define SLOT1 0 +#define SLOT2 2 +#define SLOT3 1 +#define SLOT4 3 + +/* + * Pan law table + */ + +static const UINT16 panlawtable[] = +{ + 65535, 65529, 65514, 65489, 65454, 65409, 65354, 65289, + 65214, 65129, 65034, 64929, 64814, 64689, 64554, 64410, + 64255, 64091, 63917, 63733, 63540, 63336, 63123, 62901, + 62668, 62426, 62175, 61914, 61644, 61364, 61075, 60776, + 60468, 60151, 59825, 59489, 59145, 58791, 58428, 58057, + 57676, 57287, 56889, 56482, 56067, 55643, 55211, 54770, + 54320, 53863, 53397, 52923, 52441, 51951, 51453, 50947, + 50433, 49912, 49383, 48846, 48302, 47750, 47191, + 46340, /* Center left */ + 46340, /* Center right */ + 45472, 44885, 44291, 43690, 43083, 42469, 41848, 41221, + 40588, 39948, 39303, 38651, 37994, 37330, 36661, 35986, + 35306, 34621, 33930, 33234, 32533, 31827, 31116, 30400, + 29680, 28955, 28225, 27492, 26754, 26012, 25266, 24516, + 23762, 23005, 22244, 21480, 20713, 19942, 19169, 18392, + 17613, 16831, 16046, 15259, 14469, 13678, 12884, 12088, + 11291, 10492, 9691, 8888, 8085, 7280, 6473, 5666, + 4858, 4050, 3240, 2431, 1620, 810, 0 +}; + +/* struct describing a single operator (SLOT) */ +typedef struct +{ + INT32 *DT; /* detune :dt_tab[DT] */ + UINT8 KSR; /* key scale rate :3-KSR */ + UINT32 ar; /* attack rate */ + UINT32 d1r; /* decay rate */ + UINT32 d2r; /* sustain rate */ + UINT32 rr; /* release rate */ + UINT8 ksr; /* key scale rate :kcode>>(3-KSR) */ + UINT32 mul; /* multiple :ML_TABLE[ML] */ + + /* Phase Generator */ + UINT32 phase; /* phase counter */ + INT32 Incr; /* phase step */ + + /* Envelope Generator */ + UINT8 state; /* phase type */ + UINT32 tl; /* total level: TL << 3 */ + INT32 volume; /* envelope counter */ + UINT32 sl; /* sustain level:sl_table[SL] */ + UINT32 vol_out; /* current output from EG circuit (without AM from LFO) */ + + UINT8 eg_sh_ar; /* (attack state) */ + UINT8 eg_sel_ar; /* (attack state) */ + UINT8 eg_sh_d1r; /* (decay state) */ + UINT8 eg_sel_d1r; /* (decay state) */ + UINT8 eg_sh_d2r; /* (sustain state) */ + UINT8 eg_sel_d2r; /* (sustain state) */ + UINT8 eg_sh_rr; /* (release state) */ + UINT8 eg_sel_rr; /* (release state) */ + + UINT8 ssg; /* SSG-EG waveform */ + UINT8 ssgn; /* SSG-EG negated output */ + + UINT8 key; /* 0=last key was KEY OFF, 1=KEY ON */ + + /* LFO */ + UINT32 AMmask; /* AM enable flag */ + +} FM_SLOT; + +typedef struct +{ + FM_SLOT SLOT[4]; /* four SLOTs (operators) */ + + UINT8 ALGO; /* algorithm */ + UINT8 FB; /* feedback shift */ + INT32 op1_out[2]; /* op1 output for feedback */ + + INT32 *connect1; /* SLOT1 output pointer */ + INT32 *connect3; /* SLOT3 output pointer */ + INT32 *connect2; /* SLOT2 output pointer */ + INT32 *connect4; /* SLOT4 output pointer */ + + INT32 *mem_connect; /* where to put the delayed sample (MEM) */ + INT32 mem_value; /* delayed sample (MEM) value */ + + INT32 pms; /* channel PMS */ + UINT8 ams; /* channel AMS */ + + UINT32 fc; /* fnum,blk */ + UINT8 kcode; /* key code */ + UINT32 block_fnum; /* blk/fnum value (for LFO PM calculations) */ + + INT32 pan_volume_l; + INT32 pan_volume_r; +} FM_CH; + + +typedef struct +{ + UINT16 address; /* address register */ + UINT8 status; /* status flag */ + UINT32 mode; /* mode CSM / 3SLOT */ + UINT8 fn_h; /* freq latch */ + INT32 TA; /* timer a value */ + INT32 TAL; /* timer a base */ + INT32 TAC; /* timer a counter */ + INT32 TB; /* timer b value */ + INT32 TBL; /* timer b base */ + INT32 TBC; /* timer b counter */ + INT32 dt_tab[8][32]; /* DeTune table */ + +} FM_ST; + + +/***********************************************************/ +/* OPN unit */ +/***********************************************************/ + +/* OPN 3slot struct */ +typedef struct +{ + UINT32 fc[3]; /* fnum3,blk3: calculated */ + UINT8 fn_h; /* freq3 latch */ + UINT8 kcode[3]; /* key code */ + UINT32 block_fnum[3]; /* current fnum value for this slot (can be different betweeen slots of one channel in 3slot mode) */ + UINT8 key_csm; /* CSM mode Key-ON flag */ + +} FM_3SLOT; + +/* OPN/A/B common state */ +typedef struct +{ + FM_ST ST; /* general state */ + FM_3SLOT SL3; /* 3 slot mode state */ + unsigned int pan[6*2]; /* fm channels output masks (0xffffffff = enable) */ + + /* EG */ + UINT32 eg_cnt; /* global envelope generator counter */ + UINT32 eg_timer; /* global envelope generator counter works at frequency = chipclock/144/3 */ + + /* LFO */ + UINT8 lfo_cnt; /* current LFO phase (out of 128) */ + UINT32 lfo_timer; /* current LFO phase runs at LFO frequency */ + UINT32 lfo_timer_overflow; /* LFO timer overflows every N samples (depends on LFO frequency) */ + UINT32 LFO_AM; /* current LFO AM step */ + UINT32 LFO_PM; /* current LFO PM step */ + +} FM_OPN; + +/***********************************************************/ +/* YM2612 chip */ +/***********************************************************/ +typedef struct YM2612GX +{ + FM_CH CH[6]; /* channel state */ + UINT8 dacen; /* DAC mode */ + INT32 dacout; /* DAC output */ + FM_OPN OPN; /* OPN state */ + + /* current chip state */ + INT32 m2,c1,c2; /* Phase Modulation input for operators 2,3,4 */ + INT32 mem; /* one sample delay memory */ + INT32 out_fm[6]; /* outputs of working channels */ + + /* chip type */ + UINT32 op_mask[8][4]; /* operator output bitmasking (DAC quantization) */ + int chip_type; +} YM2612; + + +INLINE void FM_KEYON(YM2612 *ym2612, FM_CH *CH , int s ) +{ + FM_SLOT *SLOT = &CH->SLOT[s]; + + if (!SLOT->key && !ym2612->OPN.SL3.key_csm) + { + /* restart Phase Generator */ + SLOT->phase = 0; + + /* reset SSG-EG inversion flag */ + SLOT->ssgn = 0; + + if ((SLOT->ar + SLOT->ksr) < 94 /*32+62*/) + { + SLOT->state = (SLOT->volume <= MIN_ATT_INDEX) ? ((SLOT->sl == MIN_ATT_INDEX) ? EG_SUS : EG_DEC) : EG_ATT; + } + else + { + /* force attenuation level to 0 */ + SLOT->volume = MIN_ATT_INDEX; + + /* directly switch to Decay (or Sustain) */ + SLOT->state = (SLOT->sl == MIN_ATT_INDEX) ? EG_SUS : EG_DEC; + } + + /* recalculate EG output */ + if ((SLOT->ssg&0x08) && (SLOT->ssgn ^ (SLOT->ssg&0x04))) + SLOT->vol_out = ((UINT32)(0x200 - SLOT->volume) & MAX_ATT_INDEX) + SLOT->tl; + else + SLOT->vol_out = (UINT32)SLOT->volume + SLOT->tl; + } + + SLOT->key = 1; +} + +INLINE void FM_KEYOFF(YM2612 *ym2612, FM_CH *CH , int s ) +{ + FM_SLOT *SLOT = &CH->SLOT[s]; + + if (SLOT->key && !ym2612->OPN.SL3.key_csm) + { + if (SLOT->state>EG_REL) + { + SLOT->state = EG_REL; /* phase -> Release */ + + /* SSG-EG specific update */ + if (SLOT->ssg&0x08) + { + /* convert EG attenuation level */ + if (SLOT->ssgn ^ (SLOT->ssg&0x04)) + SLOT->volume = (0x200 - SLOT->volume); + + /* force EG attenuation level */ + if (SLOT->volume >= 0x200) + { + SLOT->volume = MAX_ATT_INDEX; + SLOT->state = EG_OFF; + } + + /* recalculate EG output */ + SLOT->vol_out = (UINT32)SLOT->volume + SLOT->tl; + } + } + } + + SLOT->key = 0; +} + +INLINE void FM_KEYON_CSM(YM2612 *ym2612, FM_CH *CH , int s ) +{ + FM_SLOT *SLOT = &CH->SLOT[s]; + + if (!SLOT->key && !ym2612->OPN.SL3.key_csm) + { + /* restart Phase Generator */ + SLOT->phase = 0; + + /* reset SSG-EG inversion flag */ + SLOT->ssgn = 0; + + if ((SLOT->ar + SLOT->ksr) < 94 /*32+62*/) + { + SLOT->state = (SLOT->volume <= MIN_ATT_INDEX) ? ((SLOT->sl == MIN_ATT_INDEX) ? EG_SUS : EG_DEC) : EG_ATT; + } + else + { + /* force attenuation level to 0 */ + SLOT->volume = MIN_ATT_INDEX; + + /* directly switch to Decay (or Sustain) */ + SLOT->state = (SLOT->sl == MIN_ATT_INDEX) ? EG_SUS : EG_DEC; + } + + /* recalculate EG output */ + if ((SLOT->ssg&0x08) && (SLOT->ssgn ^ (SLOT->ssg&0x04))) + SLOT->vol_out = ((UINT32)(0x200 - SLOT->volume) & MAX_ATT_INDEX) + SLOT->tl; + else + SLOT->vol_out = (UINT32)SLOT->volume + SLOT->tl; + } +} + +INLINE void FM_KEYOFF_CSM(FM_CH *CH , int s ) +{ + FM_SLOT *SLOT = &CH->SLOT[s]; + if (!SLOT->key) + { + if (SLOT->state>EG_REL) + { + SLOT->state = EG_REL; /* phase -> Release */ + + /* SSG-EG specific update */ + if (SLOT->ssg&0x08) + { + /* convert EG attenuation level */ + if (SLOT->ssgn ^ (SLOT->ssg&0x04)) + SLOT->volume = (0x200 - SLOT->volume); + + /* force EG attenuation level */ + if (SLOT->volume >= 0x200) + { + SLOT->volume = MAX_ATT_INDEX; + SLOT->state = EG_OFF; + } + + /* recalculate EG output */ + SLOT->vol_out = (UINT32)SLOT->volume + SLOT->tl; + } + } + } +} + +/* CSM Key Controll */ +INLINE void CSMKeyControll(YM2612 *ym2612, FM_CH *CH) +{ + /* all key ON (verified by Nemesis on real hardware) */ + FM_KEYON_CSM(ym2612, CH,SLOT1); + FM_KEYON_CSM(ym2612, CH,SLOT2); + FM_KEYON_CSM(ym2612, CH,SLOT3); + FM_KEYON_CSM(ym2612, CH,SLOT4); + ym2612->OPN.SL3.key_csm = 1; +} + +INLINE void INTERNAL_TIMER_A(YM2612 *ym2612) +{ + if (ym2612->OPN.ST.mode & 0x01) + { + ym2612->OPN.ST.TAC--; + if (ym2612->OPN.ST.TAC <= 0) + { + /* set status (if enabled) */ + if (ym2612->OPN.ST.mode & 0x04) + ym2612->OPN.ST.status |= 0x01; + + /* reload the counter */ + ym2612->OPN.ST.TAC = ym2612->OPN.ST.TAL; + + /* CSM mode auto key on */ + if ((ym2612->OPN.ST.mode & 0xC0) == 0x80) + CSMKeyControll(ym2612, &ym2612->CH[2]); + } + } +} + +INLINE void INTERNAL_TIMER_B(YM2612 *ym2612, int step) +{ + if (ym2612->OPN.ST.mode & 0x02) + { + ym2612->OPN.ST.TBC-=step; + if (ym2612->OPN.ST.TBC <= 0) + { + /* set status (if enabled) */ + if (ym2612->OPN.ST.mode & 0x08) + ym2612->OPN.ST.status |= 0x02; + + /* reload the counter */ + do + { + ym2612->OPN.ST.TBC += ym2612->OPN.ST.TBL; + } + while (ym2612->OPN.ST.TBC <= 0); + } + } +} + +/* OPN Mode Register Write */ +INLINE void set_timers(YM2612 *ym2612, int v ) +{ + /* b7 = CSM MODE */ + /* b6 = 3 slot mode */ + /* b5 = reset b */ + /* b4 = reset a */ + /* b3 = timer enable b */ + /* b2 = timer enable a */ + /* b1 = load b */ + /* b0 = load a */ + + if ((ym2612->OPN.ST.mode ^ v) & 0xC0) + { + /* phase increment need to be recalculated */ + ym2612->CH[2].SLOT[SLOT1].Incr=-1; + + /* CSM mode disabled and CSM key ON active*/ + if (((v & 0xC0) != 0x80) && ym2612->OPN.SL3.key_csm) + { + /* CSM Mode Key OFF (verified by Nemesis on real hardware) */ + FM_KEYOFF_CSM(&ym2612->CH[2],SLOT1); + FM_KEYOFF_CSM(&ym2612->CH[2],SLOT2); + FM_KEYOFF_CSM(&ym2612->CH[2],SLOT3); + FM_KEYOFF_CSM(&ym2612->CH[2],SLOT4); + ym2612->OPN.SL3.key_csm = 0; + } + } + + /* reload Timers */ + if ((v&1) && !(ym2612->OPN.ST.mode&1)) + ym2612->OPN.ST.TAC = ym2612->OPN.ST.TAL; + if ((v&2) && !(ym2612->OPN.ST.mode&2)) + ym2612->OPN.ST.TBC = ym2612->OPN.ST.TBL; + + /* reset Timers flags */ + ym2612->OPN.ST.status &= (~v >> 4); + + ym2612->OPN.ST.mode = v; +} + +/* set algorithm connection */ +INLINE void setup_connection(YM2612 *ym2612, FM_CH *CH, int ch ) +{ + INT32 *carrier = &ym2612->out_fm[ch]; + + INT32 **om1 = &CH->connect1; + INT32 **om2 = &CH->connect3; + INT32 **oc1 = &CH->connect2; + + INT32 **memc = &CH->mem_connect; + + switch( CH->ALGO ){ + case 0: + /* M1---C1---MEM---M2---C2---OUT */ + *om1 = &ym2612->c1; + *oc1 = &ym2612->mem; + *om2 = &ym2612->c2; + *memc= &ym2612->m2; + break; + case 1: + /* M1------+-MEM---M2---C2---OUT */ + /* C1-+ */ + *om1 = &ym2612->mem; + *oc1 = &ym2612->mem; + *om2 = &ym2612->c2; + *memc= &ym2612->m2; + break; + case 2: + /* M1-----------------+-C2---OUT */ + /* C1---MEM---M2-+ */ + *om1 = &ym2612->c2; + *oc1 = &ym2612->mem; + *om2 = &ym2612->c2; + *memc= &ym2612->m2; + break; + case 3: + /* M1---C1---MEM------+-C2---OUT */ + /* M2-+ */ + *om1 = &ym2612->c1; + *oc1 = &ym2612->mem; + *om2 = &ym2612->c2; + *memc= &ym2612->c2; + break; + case 4: + /* M1---C1-+-OUT */ + /* M2---C2-+ */ + /* MEM: not used */ + *om1 = &ym2612->c1; + *oc1 = carrier; + *om2 = &ym2612->c2; + *memc= &ym2612->mem; /* store it anywhere where it will not be used */ + break; + case 5: + /* +----C1----+ */ + /* M1-+-MEM---M2-+-OUT */ + /* +----C2----+ */ + *om1 = 0; /* special mark */ + *oc1 = carrier; + *om2 = carrier; + *memc= &ym2612->m2; + break; + case 6: + /* M1---C1-+ */ + /* M2-+-OUT */ + /* C2-+ */ + /* MEM: not used */ + *om1 = &ym2612->c1; + *oc1 = carrier; + *om2 = carrier; + *memc= &ym2612->mem; /* store it anywhere where it will not be used */ + break; + case 7: + /* M1-+ */ + /* C1-+-OUT */ + /* M2-+ */ + /* C2-+ */ + /* MEM: not used*/ + *om1 = carrier; + *oc1 = carrier; + *om2 = carrier; + *memc= &ym2612->mem; /* store it anywhere where it will not be used */ + break; + } + + CH->connect4 = carrier; +} + +/* set detune & multiple */ +INLINE void set_det_mul(YM2612 *ym2612, FM_CH *CH,FM_SLOT *SLOT,int v) +{ + SLOT->mul = (v&0x0f)? (v&0x0f)*2 : 1; + SLOT->DT = ym2612->OPN.ST.dt_tab[(v>>4)&7]; + CH->SLOT[SLOT1].Incr=-1; +} + +/* set total level */ +INLINE void set_tl(FM_SLOT *SLOT , int v) +{ + SLOT->tl = (v&0x7f)<<(ENV_BITS-7); /* 7bit TL */ + + /* recalculate EG output */ + if ((SLOT->ssg&0x08) && (SLOT->ssgn ^ (SLOT->ssg&0x04)) && (SLOT->state > EG_REL)) + SLOT->vol_out = ((UINT32)(0x200 - SLOT->volume) & MAX_ATT_INDEX) + SLOT->tl; + else + SLOT->vol_out = (UINT32)SLOT->volume + SLOT->tl; +} + +/* set attack rate & key scale */ +INLINE void set_ar_ksr(FM_CH *CH,FM_SLOT *SLOT,int v) +{ + UINT8 old_KSR = SLOT->KSR; + + SLOT->ar = (v&0x1f) ? 32 + ((v&0x1f)<<1) : 0; + + SLOT->KSR = 3-(v>>6); + if (SLOT->KSR != old_KSR) + { + CH->SLOT[SLOT1].Incr=-1; + } + + /* Even if it seems unnecessary to do it here, it could happen that KSR and KC */ + /* are modified but the resulted SLOT->ksr value (kc >> SLOT->KSR) remains unchanged. */ + /* In such case, Attack Rate would not be recalculated by "refresh_fc_eg_slot". */ + /* This actually fixes the intro of "The Adventures of Batman & Robin" (Eke-Eke) */ + if ((SLOT->ar + SLOT->ksr) < (32+62)) + { + SLOT->eg_sh_ar = eg_rate_shift [SLOT->ar + SLOT->ksr ]; + SLOT->eg_sel_ar = eg_rate_select[SLOT->ar + SLOT->ksr ]; + } + else + { + /* verified by Nemesis on real hardware (Attack phase is blocked) */ + SLOT->eg_sh_ar = 0; + SLOT->eg_sel_ar = 18*RATE_STEPS; + } + } + +/* set decay rate */ +INLINE void set_dr(FM_SLOT *SLOT,int v) +{ + SLOT->d1r = (v&0x1f) ? 32 + ((v&0x1f)<<1) : 0; + + SLOT->eg_sh_d1r = eg_rate_shift [SLOT->d1r + SLOT->ksr]; + SLOT->eg_sel_d1r= eg_rate_select[SLOT->d1r + SLOT->ksr]; + +} + +/* set sustain rate */ +INLINE void set_sr(FM_SLOT *SLOT,int v) +{ + SLOT->d2r = (v&0x1f) ? 32 + ((v&0x1f)<<1) : 0; + + SLOT->eg_sh_d2r = eg_rate_shift [SLOT->d2r + SLOT->ksr]; + SLOT->eg_sel_d2r= eg_rate_select[SLOT->d2r + SLOT->ksr]; +} + +/* set release rate */ +INLINE void set_sl_rr(FM_SLOT *SLOT,int v) +{ + SLOT->sl = sl_table[ v>>4 ]; + + /* check EG state changes */ + if ((SLOT->state == EG_DEC) && (SLOT->volume >= (INT32)(SLOT->sl))) + SLOT->state = EG_SUS; + + SLOT->rr = 34 + ((v&0x0f)<<2); + + SLOT->eg_sh_rr = eg_rate_shift [SLOT->rr + SLOT->ksr]; + SLOT->eg_sel_rr = eg_rate_select[SLOT->rr + SLOT->ksr]; +} + +/* advance LFO to next sample */ +INLINE void advance_lfo(YM2612 *ym2612) +{ + if (ym2612->OPN.lfo_timer_overflow) /* LFO enabled ? */ + { + /* increment LFO timer (every samples) */ + ym2612->OPN.lfo_timer ++; + + /* when LFO is enabled, one level will last for 108, 77, 71, 67, 62, 44, 8 or 5 samples */ + if (ym2612->OPN.lfo_timer >= ym2612->OPN.lfo_timer_overflow) + { + ym2612->OPN.lfo_timer = 0; + + /* There are 128 LFO steps */ + ym2612->OPN.lfo_cnt = ( ym2612->OPN.lfo_cnt + 1 ) & 127; + + /* triangle (inverted) */ + /* AM: from 126 to 0 step -2, 0 to 126 step +2 */ + if (ym2612->OPN.lfo_cnt<64) + ym2612->OPN.LFO_AM = (ym2612->OPN.lfo_cnt ^ 63) << 1; + else + ym2612->OPN.LFO_AM = (ym2612->OPN.lfo_cnt & 63) << 1; + + /* PM works with 4 times slower clock */ + ym2612->OPN.LFO_PM = ym2612->OPN.lfo_cnt >> 2; + } + } +} + + +INLINE void advance_eg_channels(FM_CH *CH, unsigned int eg_cnt) +{ + unsigned int i = 6; /* six channels */ + unsigned int j; + FM_SLOT *SLOT; + + do + { + SLOT = &CH->SLOT[SLOT1]; + j = 4; /* four operators per channel */ + do + { + switch(SLOT->state) + { + case EG_ATT: /* attack phase */ + { + if (!(eg_cnt & ((1<eg_sh_ar)-1))) + { + /* update attenuation level */ + SLOT->volume += (~SLOT->volume * (eg_inc[SLOT->eg_sel_ar + ((eg_cnt>>SLOT->eg_sh_ar)&7)]))>>4; + + /* check phase transition*/ + if (SLOT->volume <= MIN_ATT_INDEX) + { + SLOT->volume = MIN_ATT_INDEX; + SLOT->state = (SLOT->sl == MIN_ATT_INDEX) ? EG_SUS : EG_DEC; /* special case where SL=0 */ + } + + /* recalculate EG output */ + if ((SLOT->ssg&0x08) && (SLOT->ssgn ^ (SLOT->ssg&0x04))) /* SSG-EG Output Inversion */ + SLOT->vol_out = ((UINT32)(0x200 - SLOT->volume) & MAX_ATT_INDEX) + SLOT->tl; + else + SLOT->vol_out = (UINT32)SLOT->volume + SLOT->tl; + } + break; + } + + case EG_DEC: /* decay phase */ + { + if (!(eg_cnt & ((1<eg_sh_d1r)-1))) + { + /* SSG EG type */ + if (SLOT->ssg&0x08) + { + /* update attenuation level */ + if (SLOT->volume < 0x200) + { + SLOT->volume += 4 * eg_inc[SLOT->eg_sel_d1r + ((eg_cnt>>SLOT->eg_sh_d1r)&7)]; + + /* recalculate EG output */ + if (SLOT->ssgn ^ (SLOT->ssg&0x04)) /* SSG-EG Output Inversion */ + SLOT->vol_out = ((UINT32)(0x200 - SLOT->volume) & MAX_ATT_INDEX) + SLOT->tl; + else + SLOT->vol_out = (UINT32)SLOT->volume + SLOT->tl; + } + } + else + { + /* update attenuation level */ + SLOT->volume += eg_inc[SLOT->eg_sel_d1r + ((eg_cnt>>SLOT->eg_sh_d1r)&7)]; + + /* recalculate EG output */ + SLOT->vol_out = (UINT32)SLOT->volume + SLOT->tl; + } + + /* check phase transition*/ + if (SLOT->volume >= (INT32)(SLOT->sl)) + SLOT->state = EG_SUS; + } + break; + } + + case EG_SUS: /* sustain phase */ + { + if (!(eg_cnt & ((1<eg_sh_d2r)-1))) + { + /* SSG EG type */ + if (SLOT->ssg&0x08) + { + /* update attenuation level */ + if (SLOT->volume < 0x200) + { + SLOT->volume += 4 * eg_inc[SLOT->eg_sel_d2r + ((eg_cnt>>SLOT->eg_sh_d2r)&7)]; + + /* recalculate EG output */ + if (SLOT->ssgn ^ (SLOT->ssg&0x04)) /* SSG-EG Output Inversion */ + SLOT->vol_out = ((UINT32)(0x200 - SLOT->volume) & MAX_ATT_INDEX) + SLOT->tl; + else + SLOT->vol_out = (UINT32)SLOT->volume + SLOT->tl; + } + } + else + { + /* update attenuation level */ + SLOT->volume += eg_inc[SLOT->eg_sel_d2r + ((eg_cnt>>SLOT->eg_sh_d2r)&7)]; + + /* check phase transition*/ + if ( SLOT->volume >= MAX_ATT_INDEX ) + SLOT->volume = MAX_ATT_INDEX; + /* do not change SLOT->state (verified on real chip) */ + + /* recalculate EG output */ + SLOT->vol_out = (UINT32)SLOT->volume + SLOT->tl; + } + } + break; + } + + case EG_REL: /* release phase */ + { + if (!(eg_cnt & ((1<eg_sh_rr)-1))) + { + /* SSG EG type */ + if (SLOT->ssg&0x08) + { + /* update attenuation level */ + if (SLOT->volume < 0x200) + SLOT->volume += 4 * eg_inc[SLOT->eg_sel_rr + ((eg_cnt>>SLOT->eg_sh_rr)&7)]; + + /* check phase transition */ + if (SLOT->volume >= 0x200) + { + SLOT->volume = MAX_ATT_INDEX; + SLOT->state = EG_OFF; + } + } + else + { + /* update attenuation level */ + SLOT->volume += eg_inc[SLOT->eg_sel_rr + ((eg_cnt>>SLOT->eg_sh_rr)&7)]; + + /* check phase transition*/ + if (SLOT->volume >= MAX_ATT_INDEX) + { + SLOT->volume = MAX_ATT_INDEX; + SLOT->state = EG_OFF; + } + } + + /* recalculate EG output */ + SLOT->vol_out = (UINT32)SLOT->volume + SLOT->tl; + + } + break; + } + } + + /* next slot */ + SLOT++; + } while (--j); + + /* next channel */ + CH++; + } while (--i); +} + +/* SSG-EG update process */ +/* The behavior is based upon Nemesis tests on real hardware */ +/* This is actually executed before each samples */ +INLINE void update_ssg_eg_channels(FM_CH *CH) +{ + unsigned int i = 6; /* six channels */ + unsigned int j; + FM_SLOT *SLOT; + + do + { + j = 4; /* four operators per channel */ + SLOT = &CH->SLOT[SLOT1]; + + do + { + /* detect SSG-EG transition */ + /* this is not required during release phase as the attenuation has been forced to MAX and output invert flag is not used */ + /* if an Attack Phase is programmed, inversion can occur on each sample */ + if ((SLOT->ssg & 0x08) && (SLOT->volume >= 0x200) && (SLOT->state > EG_REL)) + { + if (SLOT->ssg & 0x01) /* bit 0 = hold SSG-EG */ + { + /* set inversion flag */ + if (SLOT->ssg & 0x02) + SLOT->ssgn = 4; + + /* force attenuation level during decay phases */ + if ((SLOT->state != EG_ATT) && !(SLOT->ssgn ^ (SLOT->ssg & 0x04))) + SLOT->volume = MAX_ATT_INDEX; + } + else /* loop SSG-EG */ + { + /* toggle output inversion flag or reset Phase Generator */ + if (SLOT->ssg & 0x02) + SLOT->ssgn ^= 4; + else + SLOT->phase = 0; + + /* same as Key ON */ + if (SLOT->state != EG_ATT) + { + if ((SLOT->ar + SLOT->ksr) < 94 /*32+62*/) + { + SLOT->state = (SLOT->volume <= MIN_ATT_INDEX) ? ((SLOT->sl == MIN_ATT_INDEX) ? EG_SUS : EG_DEC) : EG_ATT; + } + else + { + /* Attack Rate is maximal: directly switch to Decay or Substain */ + SLOT->volume = MIN_ATT_INDEX; + SLOT->state = (SLOT->sl == MIN_ATT_INDEX) ? EG_SUS : EG_DEC; + } + } + } + + /* recalculate EG output */ + if (SLOT->ssgn ^ (SLOT->ssg&0x04)) + SLOT->vol_out = ((UINT32)(0x200 - SLOT->volume) & MAX_ATT_INDEX) + SLOT->tl; + else + SLOT->vol_out = (UINT32)SLOT->volume + SLOT->tl; + } + + /* next slot */ + SLOT++; + } while (--j); + + /* next channel */ + CH++; + } while (--i); +} + +INLINE void update_phase_lfo_slot(FM_SLOT *SLOT, UINT32 pm, UINT8 kc, UINT32 fc) +{ + INT32 lfo_fn_offset = lfo_pm_table[((fc & 0x7f0) << 4) + pm]; + + if (lfo_fn_offset) /* LFO phase modulation active */ + { + /* block is not modified by LFO PM */ + UINT8 blk = fc >> 11; + + /* LFO works with one more bit of a precision (12-bit) */ + fc = ((fc << 1) + lfo_fn_offset) & 0xfff; + + /* (frequency) phase increment counter (17-bit) */ + fc = (((fc << blk) >> 2) + SLOT->DT[kc]) & DT_MASK; + + /* update phase */ + SLOT->phase += ((fc * SLOT->mul) >> 1); + } + else /* LFO phase modulation = zero */ + { + SLOT->phase += SLOT->Incr; + } +} + +INLINE void update_phase_lfo_channel(YM2612 *ym2612, FM_CH *CH) +{ + UINT32 fc = CH->block_fnum; + + INT32 lfo_fn_offset = lfo_pm_table[((fc & 0x7f0) << 4) + CH->pms + ym2612->OPN.LFO_PM]; + + if (lfo_fn_offset) /* LFO phase modulation active */ + { + UINT32 finc; + + /* block & keyscale code are not modified by LFO PM */ + UINT8 blk = fc >> 11; + UINT8 kc = CH->kcode; + + /* LFO works with one more bit of a precision (12-bit) */ + fc = ((fc << 1) + lfo_fn_offset) & 0xfff; + + /* (frequency) phase increment counter (17-bit) */ + fc = (fc << blk) >> 2; + + /* apply DETUNE & MUL operator specific values */ + finc = (fc + CH->SLOT[SLOT1].DT[kc]) & DT_MASK; + CH->SLOT[SLOT1].phase += ((finc * CH->SLOT[SLOT1].mul) >> 1); + + finc = (fc + CH->SLOT[SLOT2].DT[kc]) & DT_MASK; + CH->SLOT[SLOT2].phase += ((finc * CH->SLOT[SLOT2].mul) >> 1); + + finc = (fc + CH->SLOT[SLOT3].DT[kc]) & DT_MASK; + CH->SLOT[SLOT3].phase += ((finc * CH->SLOT[SLOT3].mul) >> 1); + + finc = (fc + CH->SLOT[SLOT4].DT[kc]) & DT_MASK; + CH->SLOT[SLOT4].phase += ((finc * CH->SLOT[SLOT4].mul) >> 1); + } + else /* LFO phase modulation = zero */ + { + CH->SLOT[SLOT1].phase += CH->SLOT[SLOT1].Incr; + CH->SLOT[SLOT2].phase += CH->SLOT[SLOT2].Incr; + CH->SLOT[SLOT3].phase += CH->SLOT[SLOT3].Incr; + CH->SLOT[SLOT4].phase += CH->SLOT[SLOT4].Incr; + } +} + +/* update phase increment and envelope generator */ +INLINE void refresh_fc_eg_slot(FM_SLOT *SLOT , unsigned int fc , unsigned int kc ) +{ + /* add detune value */ + fc += SLOT->DT[kc]; + + /* (frequency) phase overflow (credits to Nemesis) */ + fc &= DT_MASK; + + /* (frequency) phase increment counter */ + SLOT->Incr = (fc * SLOT->mul) >> 1; + + /* ksr */ + kc = kc >> SLOT->KSR; + + if( SLOT->ksr != kc ) + { + SLOT->ksr = kc; + + /* recalculate envelope generator rates */ + if ((SLOT->ar + kc) < (32+62)) + { + SLOT->eg_sh_ar = eg_rate_shift [SLOT->ar + kc ]; + SLOT->eg_sel_ar = eg_rate_select[SLOT->ar + kc ]; + } + else + { + /* verified by Nemesis on real hardware (Attack phase is blocked) */ + SLOT->eg_sh_ar = 0; + SLOT->eg_sel_ar = 18*RATE_STEPS; + } + + SLOT->eg_sh_d1r = eg_rate_shift [SLOT->d1r + kc]; + SLOT->eg_sel_d1r= eg_rate_select[SLOT->d1r + kc]; + + SLOT->eg_sh_d2r = eg_rate_shift [SLOT->d2r + kc]; + SLOT->eg_sel_d2r= eg_rate_select[SLOT->d2r + kc]; + + SLOT->eg_sh_rr = eg_rate_shift [SLOT->rr + kc]; + SLOT->eg_sel_rr = eg_rate_select[SLOT->rr + kc]; + } +} + +/* update phase increment counters */ +INLINE void refresh_fc_eg_chan(FM_CH *CH ) +{ + if( CH->SLOT[SLOT1].Incr==-1) + { + int fc = CH->fc; + int kc = CH->kcode; + refresh_fc_eg_slot(&CH->SLOT[SLOT1] , fc , kc ); + refresh_fc_eg_slot(&CH->SLOT[SLOT2] , fc , kc ); + refresh_fc_eg_slot(&CH->SLOT[SLOT3] , fc , kc ); + refresh_fc_eg_slot(&CH->SLOT[SLOT4] , fc , kc ); + } +} + +#define volume_calc(OP) ((OP)->vol_out + (AM & (OP)->AMmask)) + +INLINE signed int op_calc(UINT32 phase, unsigned int env, unsigned int pm, unsigned int opmask) +{ + UINT32 p = (env<<3) + sin_tab[ ( (phase >> SIN_BITS) + (pm >> 1) ) & SIN_MASK ]; + + if (p >= TL_TAB_LEN) + return 0; + return (tl_tab[p] & opmask); +} + +INLINE signed int op_calc1(UINT32 phase, unsigned int env, unsigned int pm, unsigned int opmask) +{ + UINT32 p = (env<<3) + sin_tab[ ( ( phase >> SIN_BITS ) + pm ) & SIN_MASK ]; + + if (p >= TL_TAB_LEN) + return 0; + return (tl_tab[p] & opmask); +} + +INLINE void chan_calc(YM2612 *ym2612, FM_CH *CH, int num) +{ + do + { + INT32 out = 0; + UINT32 AM = ym2612->OPN.LFO_AM >> CH->ams; + unsigned int eg_out = volume_calc(&CH->SLOT[SLOT1]); + UINT32 *mask = ym2612->op_mask[CH->ALGO]; + + ym2612->m2 = ym2612->c1 = ym2612->c2 = ym2612->mem = 0; + + *CH->mem_connect = CH->mem_value; /* restore delayed sample (MEM) value to m2 or c2 */ + + if( eg_out < ENV_QUIET ) /* SLOT 1 */ + { + if (CH->FB < SIN_BITS) + out = (CH->op1_out[0] + CH->op1_out[1]) >> CH->FB; + + out = op_calc1(CH->SLOT[SLOT1].phase, eg_out, out, mask[0]); + } + + CH->op1_out[0] = CH->op1_out[1]; + CH->op1_out[1] = out; + + if( !CH->connect1 ){ + /* algorithm 5 */ + ym2612->mem = ym2612->c1 = ym2612->c2 = out; + }else{ + /* other algorithms */ + *CH->connect1 = out; + } + + eg_out = volume_calc(&CH->SLOT[SLOT3]); + if( eg_out < ENV_QUIET ) /* SLOT 3 */ + *CH->connect3 += op_calc(CH->SLOT[SLOT3].phase, eg_out, ym2612->m2, mask[2]); + + eg_out = volume_calc(&CH->SLOT[SLOT2]); + if( eg_out < ENV_QUIET ) /* SLOT 2 */ + *CH->connect2 += op_calc(CH->SLOT[SLOT2].phase, eg_out, ym2612->c1, mask[1]); + + eg_out = volume_calc(&CH->SLOT[SLOT4]); + if( eg_out < ENV_QUIET ) /* SLOT 4 */ + *CH->connect4 += op_calc(CH->SLOT[SLOT4].phase, eg_out, ym2612->c2, mask[3]); + + /* store current MEM */ + CH->mem_value = ym2612->mem; + + /* update phase counters AFTER output calculations */ + if (CH->pms) + { + /* 3-slot mode */ + if ((ym2612->OPN.ST.mode & 0xC0) && (CH == &ym2612->CH[2])) + { + /* keyscale code is not modifiedby LFO */ + UINT8 kc = ym2612->CH[2].kcode; + UINT32 pm = ym2612->CH[2].pms + ym2612->OPN.LFO_PM; + update_phase_lfo_slot(&ym2612->CH[2].SLOT[SLOT1], pm, kc, ym2612->OPN.SL3.block_fnum[1]); + update_phase_lfo_slot(&ym2612->CH[2].SLOT[SLOT2], pm, kc, ym2612->OPN.SL3.block_fnum[2]); + update_phase_lfo_slot(&ym2612->CH[2].SLOT[SLOT3], pm, kc, ym2612->OPN.SL3.block_fnum[0]); + update_phase_lfo_slot(&ym2612->CH[2].SLOT[SLOT4], pm, kc, ym2612->CH[2].block_fnum); + } + else + { + update_phase_lfo_channel(ym2612, CH); + } + } + else /* no LFO phase modulation */ + { + CH->SLOT[SLOT1].phase += CH->SLOT[SLOT1].Incr; + CH->SLOT[SLOT2].phase += CH->SLOT[SLOT2].Incr; + CH->SLOT[SLOT3].phase += CH->SLOT[SLOT3].Incr; + CH->SLOT[SLOT4].phase += CH->SLOT[SLOT4].Incr; + } + + /* next channel */ + CH++; + } while (--num); +} + +/* write a OPN mode register 0x20-0x2f */ +INLINE void OPNWriteMode(YM2612 *ym2612, int r, int v) +{ + UINT8 c; + FM_CH *CH; + + switch(r){ + case 0x21: /* Test */ + break; + + case 0x22: /* LFO FREQ */ + if (v&8) /* LFO enabled ? */ + { + ym2612->OPN.lfo_timer_overflow = lfo_samples_per_step[v&7]; + } + else + { + /* hold LFO waveform in reset state */ + ym2612->OPN.lfo_timer_overflow = 0; + ym2612->OPN.lfo_timer = 0; + ym2612->OPN.lfo_cnt = 0; + ym2612->OPN.LFO_PM = 0; + ym2612->OPN.LFO_AM = 126; + } + break; + case 0x24: /* timer A High */ + ym2612->OPN.ST.TA = (ym2612->OPN.ST.TA & 0x03)|(((int)v)<<2); + ym2612->OPN.ST.TAL = 1024 - ym2612->OPN.ST.TA; + break; + case 0x25: /* timer A Low */ + ym2612->OPN.ST.TA = (ym2612->OPN.ST.TA & 0x3fc)|(v&3); + ym2612->OPN.ST.TAL = 1024 - ym2612->OPN.ST.TA; + break; + case 0x26: /* timer B */ + ym2612->OPN.ST.TB = v; + ym2612->OPN.ST.TBL = (256 - v) << 4; + break; + case 0x27: /* mode, timer control */ + set_timers(ym2612, v); + break; + case 0x28: /* key on / off */ + c = v & 0x03; + if( c == 3 ) break; + if (v&0x04) c+=3; /* CH 4-6 */ + CH = &ym2612->CH[c]; + if (v&0x10) FM_KEYON(ym2612,CH,SLOT1); else FM_KEYOFF(ym2612,CH,SLOT1); + if (v&0x20) FM_KEYON(ym2612,CH,SLOT2); else FM_KEYOFF(ym2612,CH,SLOT2); + if (v&0x40) FM_KEYON(ym2612,CH,SLOT3); else FM_KEYOFF(ym2612,CH,SLOT3); + if (v&0x80) FM_KEYON(ym2612,CH,SLOT4); else FM_KEYOFF(ym2612,CH,SLOT4); + break; + } +} + +/* write a OPN register (0x30-0xff) */ +INLINE void OPNWriteReg(YM2612 *ym2612, int r, int v) +{ + FM_CH *CH; + FM_SLOT *SLOT; + + UINT8 c = OPN_CHAN(r); + + if (c == 3) return; /* 0xX3,0xX7,0xXB,0xXF */ + + if (r >= 0x100) c+=3; + + CH = &ym2612->CH[c]; + + SLOT = &(CH->SLOT[OPN_SLOT(r)]); + + switch( r & 0xf0 ) { + case 0x30: /* DET , MUL */ + set_det_mul(ym2612,CH,SLOT,v); + break; + + case 0x40: /* TL */ + set_tl(SLOT,v); + break; + + case 0x50: /* KS, AR */ + set_ar_ksr(CH,SLOT,v); + break; + + case 0x60: /* bit7 = AM ENABLE, DR */ + set_dr(SLOT,v); + SLOT->AMmask = (v&0x80) ? ~0 : 0; + break; + + case 0x70: /* SR */ + set_sr(SLOT,v); + break; + + case 0x80: /* SL, RR */ + set_sl_rr(SLOT,v); + break; + + case 0x90: /* SSG-EG */ + SLOT->ssg = v&0x0f; + + /* recalculate EG output */ + if (SLOT->state > EG_REL) + { + if ((SLOT->ssg&0x08) && (SLOT->ssgn ^ (SLOT->ssg&0x04))) + SLOT->vol_out = ((UINT32)(0x200 - SLOT->volume) & MAX_ATT_INDEX) + SLOT->tl; + else + SLOT->vol_out = (UINT32)SLOT->volume + SLOT->tl; + } + + /* SSG-EG envelope shapes : + + E AtAlH + 1 0 0 0 \\\\ + + 1 0 0 1 \___ + + 1 0 1 0 \/\/ + ___ + 1 0 1 1 \ + + 1 1 0 0 //// + ___ + 1 1 0 1 / + + 1 1 1 0 /\/\ + + 1 1 1 1 /___ + + + E = SSG-EG enable + + + The shapes are generated using Attack, Decay and Sustain phases. + + Each single character in the diagrams above represents this whole + sequence: + + - when KEY-ON = 1, normal Attack phase is generated (*without* any + difference when compared to normal mode), + + - later, when envelope level reaches minimum level (max volume), + the EG switches to Decay phase (which works with bigger steps + when compared to normal mode - see below), + + - later when envelope level passes the SL level, + the EG swithes to Sustain phase (which works with bigger steps + when compared to normal mode - see below), + + - finally when envelope level reaches maximum level (min volume), + the EG switches to Attack phase again (depends on actual waveform). + + Important is that when switch to Attack phase occurs, the phase counter + of that operator will be zeroed-out (as in normal KEY-ON) but not always. + (I havent found the rule for that - perhaps only when the output level is low) + + The difference (when compared to normal Envelope Generator mode) is + that the resolution in Decay and Sustain phases is 4 times lower; + this results in only 256 steps instead of normal 1024. + In other words: + when SSG-EG is disabled, the step inside of the EG is one, + when SSG-EG is enabled, the step is four (in Decay and Sustain phases). + + Times between the level changes are the same in both modes. + + + Important: + Decay 1 Level (so called SL) is compared to actual SSG-EG output, so + it is the same in both SSG and no-SSG modes, with this exception: + + when the SSG-EG is enabled and is generating raising levels + (when the EG output is inverted) the SL will be found at wrong level !!! + For example, when SL=02: + 0 -6 = -6dB in non-inverted EG output + 96-6 = -90dB in inverted EG output + Which means that EG compares its level to SL as usual, and that the + output is simply inverted afterall. + + + The Yamaha's manuals say that AR should be set to 0x1f (max speed). + That is not necessary, but then EG will be generating Attack phase. + + */ + break; + + case 0xa0: + switch( OPN_SLOT(r) ){ + case 0: /* 0xa0-0xa2 : FNUM1 */ + { + UINT32 fn = (((UINT32)((ym2612->OPN.ST.fn_h)&7))<<8) + v; + UINT8 blk = ym2612->OPN.ST.fn_h>>3; + /* keyscale code */ + CH->kcode = (blk<<2) | opn_fktable[fn >> 7]; + /* phase increment counter */ + CH->fc = (fn<>1; + + /* store fnum in clear form for LFO PM calculations */ + CH->block_fnum = (blk<<11) | fn; + + CH->SLOT[SLOT1].Incr=-1; + break; + } + case 1: /* 0xa4-0xa6 : FNUM2,BLK */ + ym2612->OPN.ST.fn_h = v&0x3f; + break; + case 2: /* 0xa8-0xaa : 3CH FNUM1 */ + if(r < 0x100) + { + UINT32 fn = (((UINT32)(ym2612->OPN.SL3.fn_h&7))<<8) + v; + UINT8 blk = ym2612->OPN.SL3.fn_h>>3; + /* keyscale code */ + ym2612->OPN.SL3.kcode[c]= (blk<<2) | opn_fktable[fn >> 7]; + /* phase increment counter */ + ym2612->OPN.SL3.fc[c] = (fn<>1; + ym2612->OPN.SL3.block_fnum[c] = (blk<<11) | fn; + ym2612->CH[2].SLOT[SLOT1].Incr=-1; + } + break; + case 3: /* 0xac-0xae : 3CH FNUM2,BLK */ + if(r < 0x100) + ym2612->OPN.SL3.fn_h = v&0x3f; + break; + } + break; + + case 0xb0: + switch( OPN_SLOT(r) ){ + case 0: /* 0xb0-0xb2 : FB,ALGO */ + { + CH->ALGO = v&7; + CH->FB = SIN_BITS - ((v>>3)&7); + setup_connection(ym2612, CH, c ); + break; + } + case 1: /* 0xb4-0xb6 : L , R , AMS , PMS */ + /* b0-2 PMS */ + CH->pms = (v & 7) * 32; /* CH->pms = PM depth * 32 (index in lfo_pm_table) */ + + /* b4-5 AMS */ + CH->ams = lfo_ams_depth_shift[(v>>4) & 0x03]; + + /* PAN : b7 = L, b6 = R */ + ym2612->OPN.pan[ c*2 ] = (v & 0x80) ? 0xffffffff : 0; + ym2612->OPN.pan[ c*2+1 ] = (v & 0x40) ? 0xffffffff : 0; + break; + } + break; + } +} + +static void reset_channels(FM_CH *CH , int num ) +{ + int c,s; + + for( c = 0 ; c < num ; c++ ) + { + CH[c].mem_value = 0; + CH[c].op1_out[0] = 0; + CH[c].op1_out[1] = 0; + for(s = 0 ; s < 4 ; s++ ) + { + CH[c].SLOT[s].Incr = -1; + CH[c].SLOT[s].key = 0; + CH[c].SLOT[s].phase = 0; + CH[c].SLOT[s].ssgn = 0; + CH[c].SLOT[s].state = EG_OFF; + CH[c].SLOT[s].volume = MAX_ATT_INDEX; + CH[c].SLOT[s].vol_out = MAX_ATT_INDEX; + } + } +} + +/* initialize generic tables */ +static int tables_ready = 0; +static void init_tables() +{ + signed int i,x; + signed int n; + double o,m; + + if (tables_ready) + return; + + /* build Linear Power Table */ + for (x=0; x>= 4; /* 12 bits here */ + if (n&1) /* round to nearest */ + n = (n>>1)+1; + else + n = n>>1; + /* 11 bits here (rounded) */ + n <<= 2; /* 13 bits here (as in real chip) */ + + /* 14 bits (with sign bit) */ + tl_tab[ x*2 + 0 ] = n; + tl_tab[ x*2 + 1 ] = -tl_tab[ x*2 + 0 ]; + + /* one entry in the 'Power' table use the following format, xxxxxyyyyyyyys with: */ + /* s = sign bit */ + /* yyyyyyyy = 8-bits decimal part (0-TL_RES_LEN) */ + /* xxxxx = 5-bits integer 'shift' value (0-31) but, since Power table output is 13 bits, */ + /* any value above 13 (included) would be discarded. */ + for (i=1; i<13; i++) + { + tl_tab[ x*2+0 + i*2*TL_RES_LEN ] = tl_tab[ x*2+0 ]>>i; + tl_tab[ x*2+1 + i*2*TL_RES_LEN ] = -tl_tab[ x*2+0 + i*2*TL_RES_LEN ]; + } + } + + /* build Logarithmic Sinus table */ + for (i=0; i0.0) + o = 8*log(1.0/m)/log(2); /* convert to 'decibels' */ + else + o = 8*log(-1.0/m)/log(2); /* convert to 'decibels' */ + + o = o / (ENV_STEP/4); + + n = (int)(2.0*o); + if (n&1) /* round to nearest */ + n = (n>>1)+1; + else + n = n>>1; + + /* 13-bits (8.5) value is formatted for above 'Power' table */ + sin_tab[ i ] = n*2 + (m>=0.0? 0: 1 ); + } + + /* build LFO PM modulation table */ + for(i = 0; i < 8; i++) /* 8 PM depths */ + { + UINT8 fnum; + for (fnum=0; fnum<128; fnum++) /* 7 bits meaningful of F-NUMBER */ + { + UINT8 value; + UINT8 step; + UINT32 offset_depth = i; + UINT32 offset_fnum_bit; + UINT32 bit_tmp; + + for (step=0; step<8; step++) + { + value = 0; + for (bit_tmp=0; bit_tmp<7; bit_tmp++) /* 7 bits */ + { + if (fnum & (1<OPN.ST.dt_tab[d][i] = (INT32) dt_tab[d*32 + i]; + ym2612->OPN.ST.dt_tab[d+4][i] = -ym2612->OPN.ST.dt_tab[d][i]; + } + } + + /* build default OP mask table */ + for (i = 0;i < 8;i++) + { + for (d = 0;d < 4;d++) + { + ym2612->op_mask[i][d] = 0xffffffff; + } + } + + for (i = 0; i < 6; i++) + { + ym2612->CH[i].pan_volume_l = 46340; + ym2612->CH[i].pan_volume_r = 46340; + } + + init_tables(); +} + +/* reset OPN registers */ +void YM2612GXResetChip(YM2612 *ym2612) +{ + int i; + + ym2612->OPN.eg_timer = 0; + ym2612->OPN.eg_cnt = 0; + + ym2612->OPN.lfo_timer_overflow = 0; + ym2612->OPN.lfo_timer = 0; + ym2612->OPN.lfo_cnt = 0; + ym2612->OPN.LFO_AM = 126; + ym2612->OPN.LFO_PM = 0; + + ym2612->OPN.ST.TAC = 0; + ym2612->OPN.ST.TBC = 0; + + ym2612->OPN.SL3.key_csm = 0; + + ym2612->dacen = 0; + ym2612->dacout = 0; + + set_timers(ym2612, 0x30); + ym2612->OPN.ST.TB = 0; + ym2612->OPN.ST.TBL = 256 << 4; + ym2612->OPN.ST.TA = 0; + ym2612->OPN.ST.TAL = 1024; + + reset_channels(&ym2612->CH[0] , 6 ); + + for(i = 0xb6 ; i >= 0xb4 ; i-- ) + { + OPNWriteReg(ym2612, i ,0xc0); + OPNWriteReg(ym2612, i|0x100,0xc0); + } + for(i = 0xb2 ; i >= 0x30 ; i-- ) + { + OPNWriteReg(ym2612, i ,0); + OPNWriteReg(ym2612, i|0x100,0); + } +} + +/* ym2612 write */ +/* n = number */ +/* a = address */ +/* v = value */ +void YM2612GXWrite(YM2612 *ym2612, unsigned int a, unsigned int v) +{ + v &= 0xff; /* adjust to 8 bit bus */ + + switch( a ) + { + case 0: /* address port 0 */ + ym2612->OPN.ST.address = v; + break; + + case 2: /* address port 1 */ + ym2612->OPN.ST.address = v | 0x100; + break; + + default: /* data port */ + { + int addr = ym2612->OPN.ST.address; /* verified by Nemesis on real YM2612 */ + switch( addr & 0x1f0 ) + { + case 0x20: /* 0x20-0x2f Mode */ + switch( addr ) + { + case 0x2a: /* DAC data (ym2612) */ + ym2612->dacout = ((int)v - 0x80) << 6; /* convert to 14-bit output */ + break; + case 0x2b: /* DAC Sel (ym2612) */ + /* b7 = dac enable */ + ym2612->dacen = v & 0x80; + break; + default: /* OPN section */ + /* write register */ + OPNWriteMode(ym2612,addr,v); + } + break; + default: /* 0x30-0xff OPN section */ + /* write register */ + OPNWriteReg(ym2612,addr,v); + } + break; + } + } +} + +void YM2612GXWritePan(YM2612GX *chip, int c, unsigned char v) +{ + chip->CH[c].pan_volume_l = panlawtable[v & 0x7F]; + chip->CH[c].pan_volume_r = panlawtable[0x7F - (v & 0x7F)]; +} + +unsigned int YM2612GXRead(YM2612 *ym2612) +{ + return ym2612->OPN.ST.status; +} + +void YM2612GXPreGenerate(YM2612GX *ym2612) +{ + /* refresh PG increments and EG rates if required */ + refresh_fc_eg_chan(&ym2612->CH[0]); + refresh_fc_eg_chan(&ym2612->CH[1]); + + if (!(ym2612->OPN.ST.mode & 0xC0)) + { + refresh_fc_eg_chan(&ym2612->CH[2]); + } + else + { + /* 3SLOT MODE (operator order is 0,1,3,2) */ + if(ym2612->CH[2].SLOT[SLOT1].Incr==-1) + { + refresh_fc_eg_slot(&ym2612->CH[2].SLOT[SLOT1] , ym2612->OPN.SL3.fc[1] , ym2612->OPN.SL3.kcode[1] ); + refresh_fc_eg_slot(&ym2612->CH[2].SLOT[SLOT2] , ym2612->OPN.SL3.fc[2] , ym2612->OPN.SL3.kcode[2] ); + refresh_fc_eg_slot(&ym2612->CH[2].SLOT[SLOT3] , ym2612->OPN.SL3.fc[0] , ym2612->OPN.SL3.kcode[0] ); + refresh_fc_eg_slot(&ym2612->CH[2].SLOT[SLOT4] , ym2612->CH[2].fc , ym2612->CH[2].kcode ); + } + } + + refresh_fc_eg_chan(&ym2612->CH[3]); + refresh_fc_eg_chan(&ym2612->CH[4]); + refresh_fc_eg_chan(&ym2612->CH[5]); +} + +void YM2612GXPostGenerate(YM2612GX *ym2612, unsigned int count) +{ + /* timer B control */ + INTERNAL_TIMER_B(ym2612, count); +} + +void YM2612GXGenerateOneNative(YM2612GX *ym2612, FMSAMPLE *frame) +{ + int lt,rt; + INT32 *out_fm = ym2612->out_fm; + + /* clear outputs */ + out_fm[0] = 0; + out_fm[1] = 0; + out_fm[2] = 0; + out_fm[3] = 0; + out_fm[4] = 0; + out_fm[5] = 0; + + /* update SSG-EG output */ + update_ssg_eg_channels(&ym2612->CH[0]); + + /* calculate FM */ + if (!ym2612->dacen) + { + chan_calc(ym2612, &ym2612->CH[0],6); + } + else + { + /* DAC Mode */ + out_fm[5] = ym2612->dacout; + chan_calc(ym2612,&ym2612->CH[0],5); + } + + /* advance LFO */ + advance_lfo(ym2612); + + /* EG is updated every 3 samples */ + ym2612->OPN.eg_timer++; + if (ym2612->OPN.eg_timer >= 3) + { + /* reset EG timer */ + ym2612->OPN.eg_timer = 0; + + /* increment EG counter */ + ym2612->OPN.eg_cnt++; + + /* EG counter is 12-bit only and zero value is skipped (verified on real hardware) */ + if (ym2612->OPN.eg_cnt == 4096) + ym2612->OPN.eg_cnt = 1; + + /* advance envelope generator */ + advance_eg_channels(&ym2612->CH[0], ym2612->OPN.eg_cnt); + } + + /* channels accumulator output clipping (14-bit max) */ + if (out_fm[0] > 8191) out_fm[0] = 8191; + else if (out_fm[0] < -8192) out_fm[0] = -8192; + if (out_fm[1] > 8191) out_fm[1] = 8191; + else if (out_fm[1] < -8192) out_fm[1] = -8192; + if (out_fm[2] > 8191) out_fm[2] = 8191; + else if (out_fm[2] < -8192) out_fm[2] = -8192; + if (out_fm[3] > 8191) out_fm[3] = 8191; + else if (out_fm[3] < -8192) out_fm[3] = -8192; + if (out_fm[4] > 8191) out_fm[4] = 8191; + else if (out_fm[4] < -8192) out_fm[4] = -8192; + if (out_fm[5] > 8191) out_fm[5] = 8191; + else if (out_fm[5] < -8192) out_fm[5] = -8192; + +#define PANLAW_L(ch, chpan) ((out_fm[ch] * ym2612->CH[ch].pan_volume_l / 65535) & ym2612->OPN.pan[chpan]); +#define PANLAW_R(ch, chpan) ((out_fm[ch] * ym2612->CH[ch].pan_volume_r / 65535) & ym2612->OPN.pan[chpan]); + + /* stereo DAC output panning & mixing */ + lt = PANLAW_L(0, 0); + rt = PANLAW_R(0, 1); + lt += PANLAW_L(1, 2); + rt += PANLAW_R(1, 3); + lt += PANLAW_L(2, 4); + rt += PANLAW_R(2, 5); + lt += PANLAW_L(3, 6); + rt += PANLAW_R(3, 7); + lt += PANLAW_L(4, 8); + rt += PANLAW_R(4, 9); + lt += PANLAW_L(5, 10); + rt += PANLAW_R(5, 11); + +#undef PANLAW_L +#undef PANLAW_R + + /* discrete YM2612 DAC */ + if (ym2612->chip_type == YM2612_DISCRETE) + { + int i; + + /* DAC 'ladder effect' */ + for (i=0; i<6; i++) + { + if (out_fm[i] < 0) + { + /* -4 offset (-3 when not muted) on negative channel output (9-bit) */ + lt -= ((4 - (ym2612->OPN.pan[(2*i)+0] & 1)) << 5); + rt -= ((4 - (ym2612->OPN.pan[(2*i)+1] & 1)) << 5); + } + else + { + /* +4 offset (when muted or not) on positive channel output (9-bit) */ + lt += (4 << 5); + rt += (4 << 5); + } + } + } + + /* buffering */ + frame[0] = lt / 2; + frame[1] = rt / 2; + + /* CSM mode: if CSM Key ON has occurred, CSM Key OFF need to be sent */ + /* only if Timer A does not overflow again (i.e CSM Key ON not set again) */ + ym2612->OPN.SL3.key_csm <<= 1; + + /* timer A control */ + INTERNAL_TIMER_A(ym2612); + + /* CSM Mode Key ON still disabled */ + if (ym2612->OPN.SL3.key_csm & 2) + { + /* CSM Mode Key OFF (verified by Nemesis on real hardware) */ + FM_KEYOFF_CSM(&ym2612->CH[2],SLOT1); + FM_KEYOFF_CSM(&ym2612->CH[2],SLOT2); + FM_KEYOFF_CSM(&ym2612->CH[2],SLOT3); + FM_KEYOFF_CSM(&ym2612->CH[2],SLOT4); + ym2612->OPN.SL3.key_csm = 0; + } +} + +void YM2612GXConfig(YM2612 *ym2612, int type) +{ + /* YM2612 chip type */ + ym2612->chip_type = type; + + /* carrier operator outputs bitmask */ + if (ym2612->chip_type < YM2612_ENHANCED) + { + /* 9-bit DAC */ + ym2612->op_mask[0][3] = 0xffffffe0; + ym2612->op_mask[1][3] = 0xffffffe0; + ym2612->op_mask[2][3] = 0xffffffe0; + ym2612->op_mask[3][3] = 0xffffffe0; + ym2612->op_mask[4][1] = 0xffffffe0; + ym2612->op_mask[4][3] = 0xffffffe0; + ym2612->op_mask[5][1] = 0xffffffe0; + ym2612->op_mask[5][2] = 0xffffffe0; + ym2612->op_mask[5][3] = 0xffffffe0; + ym2612->op_mask[6][1] = 0xffffffe0; + ym2612->op_mask[6][2] = 0xffffffe0; + ym2612->op_mask[6][3] = 0xffffffe0; + ym2612->op_mask[7][0] = 0xffffffe0; + ym2612->op_mask[7][1] = 0xffffffe0; + ym2612->op_mask[7][2] = 0xffffffe0; + ym2612->op_mask[7][3] = 0xffffffe0; + } + else + { + /* 14-bit DAC */ + ym2612->op_mask[0][3] = 0xffffffff; + ym2612->op_mask[1][3] = 0xffffffff; + ym2612->op_mask[2][3] = 0xffffffff; + ym2612->op_mask[3][3] = 0xffffffff; + ym2612->op_mask[4][1] = 0xffffffff; + ym2612->op_mask[4][3] = 0xffffffff; + ym2612->op_mask[5][1] = 0xffffffff; + ym2612->op_mask[5][2] = 0xffffffff; + ym2612->op_mask[5][3] = 0xffffffff; + ym2612->op_mask[6][1] = 0xffffffff; + ym2612->op_mask[6][2] = 0xffffffff; + ym2612->op_mask[6][3] = 0xffffffff; + ym2612->op_mask[7][0] = 0xffffffff; + ym2612->op_mask[7][1] = 0xffffffff; + ym2612->op_mask[7][2] = 0xffffffff; + ym2612->op_mask[7][3] = 0xffffffff; + } +} diff --git a/thirdparty/opnmidi/chips/gx/gx_ym2612.h b/thirdparty/opnmidi/chips/gx/gx_ym2612.h new file mode 100644 index 0000000..1f499d2 --- /dev/null +++ b/thirdparty/opnmidi/chips/gx/gx_ym2612.h @@ -0,0 +1,53 @@ +/* +** +** software implementation of Yamaha FM sound generator (YM2612/YM3438) +** +** Original code (MAME fm.c) +** +** Copyright (C) 2001, 2002, 2003 Jarek Burczynski (bujar at mame dot net) +** Copyright (C) 1998 Tatsuyuki Satoh , MultiArcadeMachineEmulator development +** +** Version 1.4 (final beta) +** +** Additional code & fixes by Eke-Eke for Genesis Plus GX +** Adaptations by Jean Pierre Cimalando for use in libOPNMIDI. +** (based on fee2bc8 dated Jan 7th, 2018) +** +*/ + +#ifndef _H_YM2612_ +#define _H_YM2612_ + +#if defined(__cplusplus) +extern "C" { +#endif + +enum { + YM2612_DISCRETE = 0, + YM2612_INTEGRATED, + YM2612_ENHANCED +}; + +struct YM2612GX; +typedef struct YM2612GX YM2612GX; + +/* typedef signed int FMSAMPLE; */ +typedef signed short FMSAMPLE; + +extern YM2612GX *YM2612GXAlloc(); +extern void YM2612GXFree(YM2612GX *ym2612); +extern void YM2612GXInit(YM2612GX *ym2612); +extern void YM2612GXConfig(YM2612GX *ym2612, int type); +extern void YM2612GXResetChip(YM2612GX *ym2612); +extern void YM2612GXPreGenerate(YM2612GX *ym2612); +extern void YM2612GXPostGenerate(YM2612GX *ym2612, unsigned int count); +extern void YM2612GXGenerateOneNative(YM2612GX *ym2612, FMSAMPLE *frame); +extern void YM2612GXWrite(YM2612GX *ym2612, unsigned int a, unsigned int v); +extern void YM2612GXWritePan(YM2612GX *chip, int c, unsigned char v); +extern unsigned int YM2612GXRead(YM2612GX *ym2612); + +#if defined(__cplusplus) +} /* extern "C" */ +#endif + +#endif /* _YM2612_ */ diff --git a/thirdparty/opnmidi/chips/gx_opn2.cpp b/thirdparty/opnmidi/chips/gx_opn2.cpp new file mode 100644 index 0000000..e40df72 --- /dev/null +++ b/thirdparty/opnmidi/chips/gx_opn2.cpp @@ -0,0 +1,84 @@ +/* + * Interfaces over Yamaha OPN2 (YM2612) chip emulators + * + * Copyright (c) 2017-2020 Vitaly Novichkov (Wohlstand) + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#include "gx_opn2.h" +#include + +#include "gx/gx_ym2612.h" + +GXOPN2::GXOPN2(OPNFamily f) + : OPNChipBaseT(f), + m_chip(YM2612GXAlloc()), + m_framecount(0) +{ + YM2612GXInit(m_chip); + YM2612GXConfig(m_chip, YM2612_DISCRETE); + setRate(m_rate, m_clock); +} + +GXOPN2::~GXOPN2() +{ + YM2612GXFree(m_chip); +} + +void GXOPN2::setRate(uint32_t rate, uint32_t clock) +{ + OPNChipBaseT::setRate(rate, clock); + YM2612GXResetChip(m_chip); +} + +void GXOPN2::reset() +{ + OPNChipBaseT::reset(); + YM2612GXResetChip(m_chip); +} + +void GXOPN2::writeReg(uint32_t port, uint16_t addr, uint8_t data) +{ + YM2612GXWrite(m_chip, 0 + port * 2, addr); + YM2612GXWrite(m_chip, 1 + port * 2, data); +} + +void GXOPN2::writePan(uint16_t chan, uint8_t data) +{ + YM2612GXWritePan(m_chip, chan, data); +} + +void GXOPN2::nativePreGenerate() +{ + YM2612GXPreGenerate(m_chip); + m_framecount = 0; +} + +void GXOPN2::nativePostGenerate() +{ + YM2612GXPostGenerate(m_chip, m_framecount); +} + +void GXOPN2::nativeGenerate(int16_t *frame) +{ + YM2612GXGenerateOneNative(m_chip, frame); + ++m_framecount; +} + +const char *GXOPN2::emulatorName() +{ + return "Genesis Plus GX"; +} diff --git a/thirdparty/opnmidi/chips/gx_opn2.h b/thirdparty/opnmidi/chips/gx_opn2.h new file mode 100644 index 0000000..ac0fbb5 --- /dev/null +++ b/thirdparty/opnmidi/chips/gx_opn2.h @@ -0,0 +1,46 @@ +/* + * Interfaces over Yamaha OPN2 (YM2612) chip emulators + * + * Copyright (c) 2017-2020 Vitaly Novichkov (Wohlstand) + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#ifndef GX_OPN2_H +#define GX_OPN2_H + +#include "opn_chip_base.h" + +struct YM2612GX; +class GXOPN2 final : public OPNChipBaseT +{ + YM2612GX *m_chip; + unsigned int m_framecount; +public: + explicit GXOPN2(OPNFamily f); + ~GXOPN2() override; + + bool canRunAtPcmRate() const override { return false; } + void setRate(uint32_t rate, uint32_t clock) override; + void reset() override; + void writeReg(uint32_t port, uint16_t addr, uint8_t data) override; + void writePan(uint16_t chan, uint8_t data) override; + void nativePreGenerate() override; + void nativePostGenerate() override; + void nativeGenerate(int16_t *frame) override; + const char *emulatorName() override; +}; + +#endif // GX_OPN2_H diff --git a/thirdparty/opnmidi/chips/mame/mame_ym2612fm.c b/thirdparty/opnmidi/chips/mame/mame_ym2612fm.c index 46d1b01..133b62a 100644 --- a/thirdparty/opnmidi/chips/mame/mame_ym2612fm.c +++ b/thirdparty/opnmidi/chips/mame/mame_ym2612fm.c @@ -133,6 +133,9 @@ /* YM2610B : PSG:3ch FM:6ch ADPCM(18.5KHz):6ch DeltaT ADPCM:1ch */ /************************************************************************/ +#define RSM_ENABLE 0 +#define RSM_FRAC 10 + #include #include /* for memset */ #include /* for NULL */ @@ -147,9 +150,6 @@ static stream_sample_t *DUMMYBUF = NULL; #define BUILD_OPN (BUILD_YM2203||BUILD_YM2608||BUILD_YM2610||BUILD_YM2610B||BUILD_YM2612||BUILD_YM3438) #define BUILD_OPN_PRESCALER (BUILD_YM2203||BUILD_YM2608) -#define RSM_ENABLE 0 -#define RSM_FRAC 10 - /* globals */ #define TYPE_SSG 0x01 /* SSG support */ #define TYPE_LFOPAN 0x02 /* OPN type LFO and PAN */ @@ -2043,7 +2043,7 @@ static void OPNWriteReg(FM_OPN *OPN, int r, int v) case 1: /* 0xa4-0xa6 : FNUM2,BLK */ OPN->ST.fn_h = v&0x3f; #ifdef USE_VGM_INIT_SWITCH - if (IsVGMInit) // workaround for stupid Kega Fusion init block + if (IsVGMInit) /* workaround for stupid Kega Fusion init block */ CH->block_fnum = (OPN->ST.fn_h << 8) | (CH->block_fnum & 0xFF); #endif break; diff --git a/thirdparty/opnmidi/chips/mame/mamedef.h b/thirdparty/opnmidi/chips/mame/mamedef.h index efed080..bbe0d36 100644 --- a/thirdparty/opnmidi/chips/mame/mamedef.h +++ b/thirdparty/opnmidi/chips/mame/mamedef.h @@ -17,14 +17,19 @@ typedef signed int INT32; #endif /* 64-bit values */ -#ifndef _WINDOWS_H -#ifdef _MSC_VER +#if !defined(_WINDOWS_H) && defined(RSM_ENABLE) +# ifdef _MSC_VER typedef signed __int64 INT64; typedef unsigned __int64 UINT64; -#else -__extension__ typedef unsigned long long UINT64; -__extension__ typedef signed long long INT64; -#endif +# else +# if (__WORDSIZE == 64) || defined(_WIN64) +typedef signed long int INT64; +typedef unsigned long int UINT64; +# else +__extension__ typedef signed long long int INT64; +__extension__ typedef unsigned long long int UINT64; +# endif +# endif #endif /* offsets and addresses are 32-bit (for now...) */ @@ -42,7 +47,7 @@ typedef INT16 stream_sample_t; #endif #if defined(_MSC_VER) -//#define INLINE static __forceinline +/* #define INLINE static __forceinline */ #define INLINE static __inline #elif defined(__GNUC__) #define INLINE static __inline__ diff --git a/thirdparty/opnmidi/chips/mame_opn2.cpp b/thirdparty/opnmidi/chips/mame_opn2.cpp index 6119889..6ee475b 100644 --- a/thirdparty/opnmidi/chips/mame_opn2.cpp +++ b/thirdparty/opnmidi/chips/mame_opn2.cpp @@ -1,7 +1,7 @@ /* * Interfaces over Yamaha OPN2 (YM2612) chip emulators * - * Copyright (C) 2017-2018 Vitaly Novichkov (Wohlstand) + * Copyright (c) 2017-2020 Vitaly Novichkov (Wohlstand) * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public @@ -23,7 +23,8 @@ #include #include -MameOPN2::MameOPN2() +MameOPN2::MameOPN2(OPNFamily f) + : OPNChipBaseT(f) { chip = NULL; setRate(m_rate, m_clock); @@ -39,7 +40,7 @@ void MameOPN2::setRate(uint32_t rate, uint32_t clock) OPNChipBaseT::setRate(rate, clock); if(chip) ym2612_shutdown(chip); - uint32_t chipRate = isRunningAtPcmRate() ? rate : static_cast(nativeRate); + uint32_t chipRate = isRunningAtPcmRate() ? rate : nativeRate(); chip = ym2612_init(NULL, (int)clock, (int)chipRate, NULL, NULL); ym2612_reset_chip(chip); } diff --git a/thirdparty/opnmidi/chips/mame_opn2.h b/thirdparty/opnmidi/chips/mame_opn2.h index 2fe5e03..cb1ff36 100644 --- a/thirdparty/opnmidi/chips/mame_opn2.h +++ b/thirdparty/opnmidi/chips/mame_opn2.h @@ -1,7 +1,7 @@ /* * Interfaces over Yamaha OPN2 (YM2612) chip emulators * - * Copyright (C) 2017-2018 Vitaly Novichkov (Wohlstand) + * Copyright (c) 2017-2020 Vitaly Novichkov (Wohlstand) * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public @@ -27,7 +27,7 @@ class MameOPN2 final : public OPNChipBaseT { void *chip; public: - MameOPN2(); + explicit MameOPN2(OPNFamily f); ~MameOPN2() override; bool canRunAtPcmRate() const override { return true; } diff --git a/thirdparty/opnmidi/chips/mame_opna.cpp b/thirdparty/opnmidi/chips/mame_opna.cpp new file mode 100644 index 0000000..fb9783f --- /dev/null +++ b/thirdparty/opnmidi/chips/mame_opna.cpp @@ -0,0 +1,202 @@ +/* + * Interfaces over Yamaha OPN2 (YM2612) chip emulators + * + * Copyright (c) 2018-2020 Vitaly Novichkov (Wohlstand) + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#include "mame_opna.h" +#include "mamefm/fm.h" +#include "mamefm/fmopn_2608rom.h" +#include "mamefm/2608intf.h" +#include "mamefm/resampler.hpp" + +struct MameOPNA::Impl { + ym2608_device dev; + void *chip; + + // typedef chip::SincResampler Resampler; + typedef chip::LinearResampler Resampler; + + Resampler *psgrsm; + int32_t *psgbuffer; + + static const ssg_callbacks cbssg; + + // callbacks + static uint8_t cbInternalReadByte(device_t *, offs_t); + static uint8_t cbExternalReadByte(device_t *, offs_t) { return 0; } + static void cbExternalWriteByte(device_t *, offs_t, uint8_t) {} + static void cbHandleTimer(device_t *, int, int, int) {} + static void cbHandleIRQ(device_t *, int) {} + + static void cbSsgSetClock(device_t *dev, int clock); + static void cbSsgWrite(device_t *dev, int addr, int data); + static int cbSsgRead(device_t *dev); + static void cbSsgReset(device_t *dev); +}; + +const ssg_callbacks MameOPNA::Impl::cbssg = +{ + &cbSsgSetClock, + &cbSsgWrite, + &cbSsgRead, + &cbSsgReset, +}; + + +MameOPNA::MameOPNA(OPNFamily f) + : OPNChipBaseBufferedT(f), impl(new Impl) +{ + impl->chip = NULL; + impl->psgrsm = NULL; + impl->psgbuffer = NULL; + setRate(m_rate, m_clock); +} + +MameOPNA::~MameOPNA() +{ + delete impl->psgrsm; + delete[] impl->psgbuffer; + ym2608_shutdown(impl->chip); + delete impl; +} + +void MameOPNA::setRate(uint32_t rate, uint32_t clock) +{ + OPNChipBaseBufferedT::setRate(rate, clock); + if(impl->chip) + ym2608_shutdown(impl->chip); + + uint32_t chipRate = isRunningAtPcmRate() ? rate : nativeRate(); + ym2608_device *device = &impl->dev; + void *chip = impl->chip = ym2608_init( + device, (int)clock, (int)chipRate, + &Impl::cbInternalReadByte, &Impl::cbExternalReadByte, + &Impl::cbExternalWriteByte, + &Impl::cbHandleTimer, &Impl::cbHandleIRQ, &Impl::cbssg); + + PSG *psg = &device->m_psg; + memset(psg, 0, sizeof(PSG)); + + uint32_t psgRate = clock / 32; + PSG_init(psg, clock / 4, psgRate); // TODO libOPNMIDI verify clocks + PSG_setVolumeMode(psg, 1); // YM2149 volume mode + + delete impl->psgrsm; + Impl::Resampler *psgrsm = impl->psgrsm = new Impl::Resampler; + psgrsm->init(psgRate, chipRate, 40); + + delete[] impl->psgbuffer; + impl->psgbuffer = new int32_t[2 * psgrsm->calculateInternalSampleSize(buffer_size)]; + + ym2608_reset_chip(chip); + ym2608_write(chip, 0, 0x29); + ym2608_write(chip, 1, 0x9f); +} + +void MameOPNA::reset() +{ + OPNChipBaseBufferedT::reset(); + void *chip = impl->chip; + ym2608_reset_chip(chip); + ym2608_write(chip, 0, 0x29); + ym2608_write(chip, 1, 0x9f); +} + +void MameOPNA::writeReg(uint32_t port, uint16_t addr, uint8_t data) +{ + void *chip = impl->chip; + ym2608_write(chip, 0 + (int)(port) * 2, (uint8_t)addr); + ym2608_write(chip, 1 + (int)(port) * 2, data); +} + +void MameOPNA::writePan(uint16_t chan, uint8_t data) +{ + void *chip = impl->chip; + ym2608_write_pan(chip, (int)chan, data); +} + +void MameOPNA::nativeGenerateN(int16_t *output, size_t frames) +{ + void *chip = impl->chip; + + FMSAMPLE fmLR[2 * buffer_size]; + FMSAMPLE *fmR = fmLR + buffer_size; + FMSAMPLE *fmbufs[2] = { fmLR, fmR }; + + ym2608_update_one(chip, fmbufs, (int)frames); + + PSG *psg = &impl->dev.m_psg; + Impl::Resampler *psgrsm = impl->psgrsm; + size_t psgframes = psgrsm->calculateInternalSampleSize(frames); + + int32_t *rawpsgLR = impl->psgbuffer; + int32_t *rawpsgR = rawpsgLR + psgframes; + int32_t *rawpsgbufs[2] = { rawpsgLR, rawpsgR }; + PSG_calc_stereo(psg, rawpsgbufs, (int32_t)psgframes); + + int32_t **psgbufs = psgrsm->interpolate(rawpsgbufs, frames, psgframes); + int32_t *psgL = psgbufs[0]; + int32_t *psgR = psgbufs[1]; + + for(size_t i = 0; i < frames; ++i) + { + int32_t l = fmLR[i] + psgL[i]; + l = (l > -32768) ? l : -32768; + l = (l < 32767) ? l : 32767; + int32_t r = fmR[i] + psgR[i]; + r = (r > -32768) ? r : -32768; + r = (r < 32767) ? r : 32767; + output[2 * i] = l; + output[2 * i + 1] = r; + } +} + +const char *MameOPNA::emulatorName() +{ + return "MAME YM2608"; // git 2018-12-15 rev 8ab05c0 +} + +uint8_t MameOPNA::Impl::cbInternalReadByte(device_t *dev, offs_t off) +{ + (void)dev; + return YM2608_ADPCM_ROM[off & 0x1fff]; +} + +void MameOPNA::Impl::cbSsgSetClock(device_t *dev, int clock) +{ + ym2608_device *ym = static_cast(dev); + PSG_set_clock(&ym->m_psg, (uint32_t)clock); +} + +void MameOPNA::Impl::cbSsgWrite(device_t *dev, int addr, int data) +{ + ym2608_device *ym = static_cast(dev); + PSG_writeIO(&ym->m_psg, (uint32_t)addr, (uint32_t)data); +} + +int MameOPNA::Impl::cbSsgRead(device_t *dev) +{ + ym2608_device *ym = static_cast(dev); + return PSG_readIO(&ym->m_psg); +} + +void MameOPNA::Impl::cbSsgReset(device_t *dev) +{ + ym2608_device *ym = static_cast(dev); + return PSG_reset(&ym->m_psg); +} diff --git a/thirdparty/opnmidi/chips/mame_opna.h b/thirdparty/opnmidi/chips/mame_opna.h new file mode 100644 index 0000000..202caf7 --- /dev/null +++ b/thirdparty/opnmidi/chips/mame_opna.h @@ -0,0 +1,45 @@ +/* + * Interfaces over Yamaha OPN2 (YM2612) chip emulators + * + * Copyright (c) 2018-2020 Vitaly Novichkov (Wohlstand) + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#ifndef MAME_OPNA_H +#define MAME_OPNA_H + +#include "opn_chip_base.h" + +class MameOPNA final : public OPNChipBaseBufferedT +{ + struct Impl; + Impl *impl; +public: + explicit MameOPNA(OPNFamily f); + ~MameOPNA() override; + + bool canRunAtPcmRate() const override { return true; } + void setRate(uint32_t rate, uint32_t clock) override; + void reset() override; + void writeReg(uint32_t port, uint16_t addr, uint8_t data) override; + void writePan(uint16_t chan, uint8_t data) override; + void nativePreGenerate() override {} + void nativePostGenerate() override {} + void nativeGenerateN(int16_t *output, size_t frames) override; + const char *emulatorName() override; +}; + +#endif diff --git a/thirdparty/opnmidi/chips/mamefm/2608intf.h b/thirdparty/opnmidi/chips/mamefm/2608intf.h new file mode 100644 index 0000000..9bb7d9e --- /dev/null +++ b/thirdparty/opnmidi/chips/mamefm/2608intf.h @@ -0,0 +1,48 @@ +/* + * libOPNMIDI is a free Software MIDI synthesizer library with OPN2 (YM2612) emulation + * + * MIDI parser and player (Original code from ADLMIDI): Copyright (c) 2010-2014 Joel Yliluoma + * OPNMIDI Library and YM2612 support: Copyright (c) 2017-2020 Vitaly Novichkov + * + * Library is based on the ADLMIDI, a MIDI player for Linux and Windows with OPL3 emulation: + * http://iki.fi/bisqwit/source/adlmidi.html + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +#ifndef OPNMIDI_MAMEFM_2608INTF_H +#define OPNMIDI_MAMEFM_2608INTF_H + +#include "emu.h" +#include "emu2149.h" + +struct ym2608_device : device_t +{ + void update_request(); + static void update_request(device_t *dev); + + PSG m_psg; +}; + +inline void ym2608_device::update_request() +{ + // libOPNMIDI: use this callback maybe +} + +inline void ym2608_device::update_request(device_t *dev) +{ + static_cast(dev)->update_request(); +} + +#endif diff --git a/thirdparty/opnmidi/chips/mamefm/emu.h b/thirdparty/opnmidi/chips/mamefm/emu.h new file mode 100644 index 0000000..2dee4fb --- /dev/null +++ b/thirdparty/opnmidi/chips/mamefm/emu.h @@ -0,0 +1,104 @@ +/* + * libOPNMIDI is a free Software MIDI synthesizer library with OPN2 (YM2612) emulation + * + * MIDI parser and player (Original code from ADLMIDI): Copyright (c) 2010-2014 Joel Yliluoma + * OPNMIDI Library and YM2612 support: Copyright (c) 2017-2020 Vitaly Novichkov + * + * Library is based on the ADLMIDI, a MIDI player for Linux and Windows with OPL3 emulation: + * http://iki.fi/bisqwit/source/adlmidi.html + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +#ifndef OPNMIDI_MAMEFM_EMU_H +#define OPNMIDI_MAMEFM_EMU_H + +#include +#include +#include +#include +#include +#include +#include +#include + +#if !defined(M_PI) +# define M_PI 3.14159265358979323846 +#endif + +#if __cplusplus <= 199711L +#define CONSTEXPR +#else +#define CONSTEXPR constexpr +#endif + +#if __cplusplus <= 199711L +#define NULLPTR NULL +#else +#define NULLPTR nullptr +#endif + +typedef uint32_t offs_t; + +inline void vlogerror(const char *fmt, va_list ap) +{ +#if defined(OPNMIDI_MAMEFM_EMU_VERBOSE) + vfprintf(stderr, fmt, ap); +#else + (void)fmt; + (void)ap; +#endif +} + +inline void logerror(const char *fmt, ...) +{ +#if defined(OPNMIDI_MAMEFM_EMU_VERBOSE) + va_list ap; + va_start(ap, fmt); + vlogerror(fmt, ap); + va_end(ap); +#else + (void)fmt; +#endif +} + +struct device_t +{ + void logerror(const char *fmt, ...); + void vlogerror(const char *fmt, va_list ap); +}; + +inline void device_t::logerror(const char *fmt, ...) +{ +#if defined(OPNMIDI_MAMEFM_EMU_VERBOSE) + va_list ap; + va_start(ap, fmt); + vlogerror(fmt, ap); + va_end(ap); +#else + (void)fmt; +#endif +} + +inline void device_t::vlogerror(const char *fmt, va_list ap) +{ +#if defined(OPNMIDI_MAMEFM_EMU_VERBOSE) + ::vlogerror(fmt, ap); +#else + (void)fmt; + (void)ap; +#endif +} + +#endif diff --git a/thirdparty/opnmidi/chips/mamefm/emu2149.c b/thirdparty/opnmidi/chips/mamefm/emu2149.c new file mode 100644 index 0000000..d05f7c6 --- /dev/null +++ b/thirdparty/opnmidi/chips/mamefm/emu2149.c @@ -0,0 +1,529 @@ +/* SPDX-License-Identifier: MIT */ +/**************************************************************************** + + emu2149.c -- YM2149/AY-3-8910 emulator by Mitsutaka Okazaki 2001 + + 2001 04-28 : Version 1.00beta -- 1st Beta Release. + 2001 08-14 : Version 1.10 + 2001 10-03 : Version 1.11 -- Added PSG_set_quality(). + 2002 03-02 : Version 1.12 -- Removed PSG_init & PSG_close. + 2002 10-13 : Version 1.14 -- Fixed the envelope unit. + 2003 09-19 : Version 1.15 -- Added PSG_setMask and PSG_toggleMask + 2004 01-11 : Version 1.16 -- Fixed an envelope problem where the envelope + frequency register is written before key-on. + + References: + psg.vhd -- 2000 written by Kazuhiro Tsujikawa. + s_fme7.c -- 1999,2000 written by Mamiya (NEZplug). + ay8910.c -- 1998-2001 Author unknown (MAME). + MSX-Datapack -- 1991 ASCII Corp. + AY-3-8910 data sheet + +*****************************************************************************/ +#include +#include +#include +#include "emu2149.h" + +static UINT32 voltbl[2][32] = { + {0x00, 0x01, 0x01, 0x02, 0x02, 0x03, 0x03, 0x04, 0x05, 0x06, 0x07, 0x09, + 0x0B, 0x0D, 0x0F, 0x12, + 0x16, 0x1A, 0x1F, 0x25, 0x2D, 0x35, 0x3F, 0x4C, 0x5A, 0x6A, 0x7F, 0x97, + 0xB4, 0xD6, 0xEB, 0xFF}, + {0x00, 0x00, 0x01, 0x01, 0x02, 0x02, 0x03, 0x03, 0x05, 0x05, 0x07, 0x07, + 0x0B, 0x0B, 0x0F, 0x0F, + 0x16, 0x16, 0x1F, 0x1F, 0x2D, 0x2D, 0x3F, 0x3F, 0x5A, 0x5A, 0x7F, 0x7F, + 0xB4, 0xB4, 0xFF, 0xFF} +}; + +#define GETA_BITS 24 + +static void +internal_refresh (PSG * psg) +{ + if (psg->quality) + { + psg->base_incr = 1 << GETA_BITS; + psg->realstep = (UINT32) ((1 << 31) / psg->rate); + psg->psgstep = (UINT32) ((1 << 31) / (psg->clk / 8)); + psg->psgtime = 0; + } + else + { + psg->base_incr = + (UINT32) ((double) psg->clk * (1 << GETA_BITS) / (8.0 * psg->rate)); + } +} + +EMU2149_API void +PSG_set_clock(PSG * psg, UINT32 c) +{ + psg->clk = c; + internal_refresh(psg); +} + +EMU2149_API void +PSG_set_rate (PSG * psg, UINT32 r) +{ + psg->rate = r ? r : 44100; + internal_refresh (psg); +} + +EMU2149_API void +PSG_set_quality (PSG * psg, UINT32 q) +{ + psg->quality = q; + internal_refresh (psg); +} + +EMU2149_API void +PSG_init (PSG * psg, UINT32 c, UINT32 r) +{ + memset(psg, 0x00, sizeof(PSG)); + + PSG_setVolumeMode (psg, EMU2149_VOL_DEFAULT); + psg->clk = c; + psg->rate = r ? r : 44100; + PSG_set_quality (psg, 0); + psg->stereo_mask[0] = 0x03; + psg->stereo_mask[1] = 0x03; + psg->stereo_mask[2] = 0x03; +} + +EMU2149_API void +PSG_setFlags (PSG * psg, UINT8 flags) +{ + if (flags & EMU2149_ZX_STEREO) + { + /* ABC Stereo */ + psg->stereo_mask[0] = 0x01; + psg->stereo_mask[1] = 0x03; + psg->stereo_mask[2] = 0x02; + } + else + { + psg->stereo_mask[0] = 0x03; + psg->stereo_mask[1] = 0x03; + psg->stereo_mask[2] = 0x03; + } + + return; +} + +EMU2149_API void +PSG_setVolumeMode (PSG * psg, int type) +{ + switch (type) + { + case 1: + psg->voltbl = voltbl[EMU2149_VOL_YM2149]; + break; + case 2: + psg->voltbl = voltbl[EMU2149_VOL_AY_3_8910]; + break; + default: + psg->voltbl = voltbl[EMU2149_VOL_DEFAULT]; + break; + } +} + +EMU2149_API UINT32 +PSG_setMask (PSG *psg, UINT32 mask) +{ + UINT32 ret = 0; + if(psg) + { + ret = psg->mask; + psg->mask = mask; + } + return ret; +} + +EMU2149_API void +PSG_setStereoMask (PSG *psg, UINT32 mask) +{ + if(psg) + { + psg->stereo_mask[0] = (mask >>0) &3; + psg->stereo_mask[1] = (mask >>2) &3; + psg->stereo_mask[2] = (mask >>4) &3; + } +} + +EMU2149_API UINT32 +PSG_toggleMask (PSG *psg, UINT32 mask) +{ + UINT32 ret = 0; + if(psg) + { + ret = psg->mask; + psg->mask ^= mask; + } + return ret; +} + +EMU2149_API void +PSG_reset (PSG * psg) +{ + int i; + + psg->base_count = 0; + + for (i = 0; i < 3; i++) + { + psg->cout[i] = 0; + psg->count[i] = 0x1000; + psg->freq[i] = 0; + psg->edge[i] = 0; + psg->volume[i] = 0; + } + + psg->mask = 0; + + for (i = 0; i < 16; i++) + psg->reg[i] = 0; + psg->adr = 0; + + psg->noise_seed = 0xffff; + psg->noise_count = 0x40; + psg->noise_freq = 0; + + psg->env_volume = 0; + psg->env_ptr = 0; + psg->env_freq = 0; + psg->env_count = 0; + psg->env_pause = 1; + + psg->out = 0; +} + +EMU2149_API void +PSG_delete (PSG * psg) +{ + free (psg); +} + +EMU2149_API UINT8 +PSG_readIO (PSG * psg) +{ + return (UINT8) (psg->reg[psg->adr]); +} + +EMU2149_API UINT8 +PSG_readReg (PSG * psg, UINT32 reg) +{ + return (UINT8) (psg->reg[reg & 0x1f]); + +} + +EMU2149_API void +PSG_writeIO (PSG * psg, UINT32 adr, UINT32 val) +{ + if (adr & 1) + PSG_writeReg (psg, psg->adr, val); + else + psg->adr = val & 0x1f; +} + +/*INLINE*/ static INT16 +calc (PSG * psg) +{ + + int i, noise; + UINT32 incr; + INT32 mix = 0; + + psg->base_count += psg->base_incr; + incr = (psg->base_count >> GETA_BITS); + psg->base_count &= (1 << GETA_BITS) - 1; + + /* Envelope */ + psg->env_count += incr; + while (psg->env_count>=0x10000 && psg->env_freq!=0) + { + if (!psg->env_pause) + { + if(psg->env_face) + psg->env_ptr = (psg->env_ptr + 1) & 0x3f ; + else + psg->env_ptr = (psg->env_ptr + 0x3f) & 0x3f; + } + + if (psg->env_ptr & 0x20) /* if carry or borrow */ + { + if (psg->env_continue) + { + if (psg->env_alternate^psg->env_hold) psg->env_face ^= 1; + if (psg->env_hold) psg->env_pause = 1; + psg->env_ptr = psg->env_face?0:0x1f; + } + else + { + psg->env_pause = 1; + psg->env_ptr = 0; + } + } + + psg->env_count -= psg->env_freq; + } + + /* Noise */ + psg->noise_count += incr; + if (psg->noise_count & 0x40) + { + if (psg->noise_seed & 1) + psg->noise_seed ^= 0x24000; + psg->noise_seed >>= 1; + psg->noise_count -= psg->noise_freq; + } + noise = psg->noise_seed & 1; + + /* Tone */ + for (i = 0; i < 3; i++) + { + psg->count[i] += incr; + if (psg->count[i] & 0x1000) + { + if (psg->freq[i] > 1) + { + psg->edge[i] = !psg->edge[i]; + psg->count[i] -= psg->freq[i]; + } + else + { + psg->edge[i] = 1; + } + } + + psg->cout[i] = 0; /* BS maintaining cout for stereo mix */ + + if (psg->mask&PSG_MASK_CH(i)) + continue; + + if ((psg->tmask[i] || psg->edge[i]) && (psg->nmask[i] || noise)) + { + if (!(psg->volume[i] & 32)) + psg->cout[i] = psg->voltbl[psg->volume[i] & 31]; + else + psg->cout[i] = psg->voltbl[psg->env_ptr]; + + mix += psg->cout[i]; + } + } + + return (INT16) mix; +} + +EMU2149_API INT16 +PSG_calc (PSG * psg) +{ + if (!psg->quality) + return (INT16) (calc (psg) << 4); + + /* Simple rate converter */ + while (psg->realstep > psg->psgtime) + { + psg->psgtime += psg->psgstep; + psg->out += calc (psg); + psg->out >>= 1; + } + + psg->psgtime = psg->psgtime - psg->realstep; + + return (INT16) (psg->out << 4); +} + +/*INLINE*/ static void +calc_stereo (PSG * psg, INT32 out[2]) +{ + int i, noise; + UINT32 incr; + INT32 l = 0, r = 0; + + psg->base_count += psg->base_incr; + incr = (psg->base_count >> GETA_BITS); + psg->base_count &= (1 << GETA_BITS) - 1; + + /* Envelope */ + psg->env_count += incr; + while (psg->env_count>=0x10000 && psg->env_freq!=0) + { + if (!psg->env_pause) + { + if(psg->env_face) + psg->env_ptr = (psg->env_ptr + 1) & 0x3f ; + else + psg->env_ptr = (psg->env_ptr + 0x3f) & 0x3f; + } + + if (psg->env_ptr & 0x20) /* if carry or borrow */ + { + if (psg->env_continue) + { + if (psg->env_alternate^psg->env_hold) psg->env_face ^= 1; + if (psg->env_hold) psg->env_pause = 1; + psg->env_ptr = psg->env_face?0:0x1f; + } + else + { + psg->env_pause = 1; + psg->env_ptr = 0; + } + } + + psg->env_count -= psg->env_freq; + } + + /* Noise */ + psg->noise_count += incr; + if (psg->noise_count & 0x40) + { + if (psg->noise_seed & 1) + psg->noise_seed ^= 0x24000; + psg->noise_seed >>= 1; + psg->noise_count -= psg->noise_freq; + } + noise = psg->noise_seed & 1; + + /* Tone */ + for (i = 0; i < 3; i++) + { + psg->count[i] += incr; + if (psg->count[i] & 0x1000) + { + if (psg->freq[i] > 1) + { + psg->edge[i] = !psg->edge[i]; + psg->count[i] -= psg->freq[i]; + } + else + { + psg->edge[i] = 1; + } + } + + psg->cout[i] = 0; /* BS maintaining cout for stereo mix */ + + if (psg->mask&PSG_MASK_CH(i)) + continue; + + if ((psg->tmask[i] || psg->edge[i]) && (psg->nmask[i] || noise)) + { + if (!(psg->volume[i] & 32)) + psg->cout[i] = psg->voltbl[psg->volume[i] & 31]; + else + psg->cout[i] = psg->voltbl[psg->env_ptr]; + + if (psg->stereo_mask[i] & 0x01) + l += psg->cout[i]; + if (psg->stereo_mask[i] & 0x02) + r += psg->cout[i]; + } + } + + out[0] = l << 5; + out[1] = r << 5; + + return; +} + +EMU2149_API void +PSG_calc_stereo (PSG * psg, INT32 **out, INT32 samples) +{ + INT32 *bufMO = out[0]; + INT32 *bufRO = out[1]; + INT32 buffers[2]; + + int i; + + for (i = 0; i < samples; i ++) + { + if (!psg->quality) + { + calc_stereo (psg, buffers); + bufMO[i] = buffers[0]; + bufRO[i] = buffers[1]; + } + else + { + while (psg->realstep > psg->psgtime) + { + psg->psgtime += psg->psgstep; + psg->sprev[0] = psg->snext[0]; + psg->sprev[1] = psg->snext[1]; + calc_stereo (psg, psg->snext); + } + + psg->psgtime -= psg->realstep; + bufMO[i] = (INT32) (((double) psg->snext[0] * (psg->psgstep - psg->psgtime) + + (double) psg->sprev[0] * psg->psgtime) / psg->psgstep); + bufRO[i] = (INT32) (((double) psg->snext[1] * (psg->psgstep - psg->psgtime) + + (double) psg->sprev[1] * psg->psgtime) / psg->psgstep); + } + } +} + +EMU2149_API void +PSG_writeReg (PSG * psg, UINT32 reg, UINT32 val) +{ + int c; + + if (reg > 15) return; + + psg->reg[reg] = (UINT8) (val & 0xff); + switch (reg) + { + case 0: + case 2: + case 4: + case 1: + case 3: + case 5: + c = reg >> 1; + psg->freq[c] = ((psg->reg[c * 2 + 1] & 15) << 8) + psg->reg[c * 2]; + break; + + case 6: + psg->noise_freq = (val == 0) ? 1 : ((val & 31) << 1); + break; + + case 7: + psg->tmask[0] = (val & 1); + psg->tmask[1] = (val & 2); + psg->tmask[2] = (val & 4); + psg->nmask[0] = (val & 8); + psg->nmask[1] = (val & 16); + psg->nmask[2] = (val & 32); + break; + + case 8: + case 9: + case 10: + psg->volume[reg - 8] = val << 1; + + break; + + case 11: + case 12: + psg->env_freq = (psg->reg[12] << 8) + psg->reg[11]; + break; + + case 13: + psg->env_continue = (val >> 3) & 1; + psg->env_attack = (val >> 2) & 1; + psg->env_alternate = (val >> 1) & 1; + psg->env_hold = val & 1; + psg->env_face = psg->env_attack; + psg->env_pause = 0; + psg->env_count = 0x10000 - psg->env_freq; + psg->env_ptr = psg->env_face?0:0x1f; + break; + + case 14: + case 15: + default: + break; + } + + return; +} diff --git a/thirdparty/opnmidi/chips/mamefm/emu2149.h b/thirdparty/opnmidi/chips/mamefm/emu2149.h new file mode 100644 index 0000000..4e41df8 --- /dev/null +++ b/thirdparty/opnmidi/chips/mamefm/emu2149.h @@ -0,0 +1,98 @@ +/* SPDX-License-Identifier: MIT */ +/* emu2149.h */ +#ifndef EMU2149_H_ +#define EMU2149_H_ +#include "emutypes.h" + +#define EMU2149_API + +#define EMU2149_VOL_DEFAULT 1 +#define EMU2149_VOL_YM2149 0 +#define EMU2149_VOL_AY_3_8910 1 + +#define EMU2149_ZX_STEREO 0x80 + +#define PSG_MASK_CH(x) (1<<(x)) + +#ifdef __cplusplus +extern "C" +{ +#endif + + typedef struct __PSG + { + + /* Volume Table */ + UINT32 *voltbl; + + UINT8 reg[0x20]; + INT32 out; + INT32 cout[3]; + + UINT32 clk, rate, base_incr, quality; + + UINT32 count[3]; + UINT32 volume[3]; + UINT32 freq[3]; + UINT32 edge[3]; + UINT32 tmask[3]; + UINT32 nmask[3]; + UINT32 mask; + UINT32 stereo_mask[3]; + + UINT32 base_count; + + UINT32 env_volume; + UINT32 env_ptr; + UINT32 env_face; + + UINT32 env_continue; + UINT32 env_attack; + UINT32 env_alternate; + UINT32 env_hold; + UINT32 env_pause; + UINT32 env_reset; + + UINT32 env_freq; + UINT32 env_count; + + UINT32 noise_seed; + UINT32 noise_count; + UINT32 noise_freq; + + /* rate converter */ + UINT32 realstep; + UINT32 psgtime; + UINT32 psgstep; + INT32 prev, next; + INT32 sprev[2], snext[2]; + + /* I/O Ctrl */ + UINT32 adr; + + } + PSG; + + EMU2149_API void PSG_set_quality (PSG * psg, UINT32 q); + EMU2149_API void PSG_set_clock(PSG * psg, UINT32 c); + EMU2149_API void PSG_set_rate (PSG * psg, UINT32 r); + EMU2149_API void PSG_init (PSG * psg, UINT32 clk, UINT32 rate); + EMU2149_API void PSG_reset (PSG *); + EMU2149_API void PSG_delete (PSG *); + EMU2149_API void PSG_writeReg (PSG *, UINT32 reg, UINT32 val); + EMU2149_API void PSG_writeIO (PSG * psg, UINT32 adr, UINT32 val); + EMU2149_API UINT8 PSG_readReg (PSG * psg, UINT32 reg); + EMU2149_API UINT8 PSG_readIO (PSG * psg); + EMU2149_API INT16 PSG_calc (PSG *); + EMU2149_API void PSG_calc_stereo (PSG * psg, INT32 **out, INT32 samples); + EMU2149_API void PSG_setFlags (PSG * psg, UINT8 flags); + EMU2149_API void PSG_setVolumeMode (PSG * psg, int type); + EMU2149_API UINT32 PSG_setMask (PSG *, UINT32 mask); + EMU2149_API UINT32 PSG_toggleMask (PSG *, UINT32 mask); + EMU2149_API void PSG_setStereoMask (PSG *psg, UINT32 mask); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/thirdparty/opnmidi/chips/mamefm/emutypes.h b/thirdparty/opnmidi/chips/mamefm/emutypes.h new file mode 100644 index 0000000..28fc3bc --- /dev/null +++ b/thirdparty/opnmidi/chips/mamefm/emutypes.h @@ -0,0 +1,38 @@ +/* + * libOPNMIDI is a free MIDI to WAV conversion library with OPN2 (YM2612) emulation + * + * MIDI parser and player (Original code from ADLMIDI): Copyright (c) 2010-2014 Joel Yliluoma + * OPNMIDI Library and YM2612 support: Copyright (c) 2017-2020 Vitaly Novichkov + * + * Library is based on the ADLMIDI, a MIDI player for Linux and Windows with OPL3 emulation: + * http://iki.fi/bisqwit/source/adlmidi.html + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +#ifndef LIBOPNMIDI_EMUTYPES_H +#define LIBOPNMIDI_EMUTYPES_H + +#include + +typedef uint8_t UINT8; +typedef uint16_t UINT16; +typedef uint32_t UINT32; +typedef uint64_t UINT64; +typedef int8_t INT8; +typedef int16_t INT16; +typedef int32_t INT32; +typedef int64_t INT64; + +#endif /* LIBOPNMIDI_EMUTYPES_H */ diff --git a/thirdparty/opnmidi/chips/mamefm/fm.cpp b/thirdparty/opnmidi/chips/mamefm/fm.cpp new file mode 100644 index 0000000..fa9b16e --- /dev/null +++ b/thirdparty/opnmidi/chips/mamefm/fm.cpp @@ -0,0 +1,3987 @@ +// license:GPL-2.0+ +// copyright-holders:Jarek Burczynski,Tatsuyuki Satoh +/* +** +** File: fm.c -- software implementation of Yamaha FM sound generator +** +** Copyright Jarek Burczynski (bujar at mame dot net) +** Copyright Tatsuyuki Satoh , MultiArcadeMachineEmulator development +** +** Version 1.4.2 (final beta) +** +*/ + +/* +** History: +** +** 2018 Jean Pierre Cimalando (libOPNMIDI) +** - rewrote pooled memory allocations as ordinary new and delete +** +** 2006-2008 Eke-Eke (Genesis Plus GX), MAME backport by R. Belmont. +** - implemented PG overflow, aka "detune bug" (Ariel, Comix Zone, Shaq Fu, Spiderman,...), credits to Nemesis +** - fixed SSG-EG support, credits to Nemesis and additional fixes from Alone Coder +** - modified EG rates and frequency, tested by Nemesis on real hardware +** - implemented LFO phase update for CH3 special mode (Warlock birds, Alladin bug sound) +** - fixed Attack Rate update (Batman & Robin intro) +** - fixed attenuation level at the start of Substain (Gynoug explosions) +** - fixed EG decay->substain transition to handle special cases, like SL=0 and Decay rate is very slow (Mega Turrican tracks 03,09...) +** +** 06-23-2007 Zsolt Vasvari: +** - changed the timing not to require the use of floating point calculations +** +** 03-08-2003 Jarek Burczynski: +** - fixed YM2608 initial values (after the reset) +** - fixed flag and irqmask handling (YM2608) +** - fixed BUFRDY flag handling (YM2608) +** +** 14-06-2003 Jarek Burczynski: +** - implemented all of the YM2608 status register flags +** - implemented support for external memory read/write via YM2608 +** - implemented support for deltat memory limit register in YM2608 emulation +** +** 22-05-2003 Jarek Burczynski: +** - fixed LFO PM calculations (copy&paste bugfix) +** +** 08-05-2003 Jarek Burczynski: +** - fixed SSG support +** +** 22-04-2003 Jarek Burczynski: +** - implemented 100% correct LFO generator (verified on real YM2610 and YM2608) +** +** 15-04-2003 Jarek Burczynski: +** - added support for YM2608's register 0x110 - status mask +** +** 01-12-2002 Jarek Burczynski: +** - fixed register addressing in YM2608, YM2610, YM2610B chips. (verified on real YM2608) +** The addressing patch used for early Neo-Geo games can be removed now. +** +** 26-11-2002 Jarek Burczynski, Nicola Salmoria: +** - recreated YM2608 ADPCM ROM using data from real YM2608's output which leads to: +** - added emulation of YM2608 drums. +** - output of YM2608 is two times lower now - same as YM2610 (verified on real YM2608) +** +** 16-08-2002 Jarek Burczynski: +** - binary exact Envelope Generator (verified on real YM2203); +** identical to YM2151 +** - corrected 'off by one' error in feedback calculations (when feedback is off) +** - corrected connection (algorithm) calculation (verified on real YM2203 and YM2610) +** +** 18-12-2001 Jarek Burczynski: +** - added SSG-EG support (verified on real YM2203) +** +** 12-08-2001 Jarek Burczynski: +** - corrected sin_tab and tl_tab data (verified on real chip) +** - corrected feedback calculations (verified on real chip) +** - corrected phase generator calculations (verified on real chip) +** - corrected envelope generator calculations (verified on real chip) +** - corrected FM volume level (YM2610 and YM2610B). +** - changed YMxxxUpdateOne() functions (YM2203, YM2608, YM2610, YM2610B, YM2612) : +** this was needed to calculate YM2610 FM channels output correctly. +** (Each FM channel is calculated as in other chips, but the output of the channel +** gets shifted right by one *before* sending to accumulator. That was impossible to do +** with previous implementation). +** +** 23-07-2001 Jarek Burczynski, Nicola Salmoria: +** - corrected YM2610 ADPCM type A algorithm and tables (verified on real chip) +** +** 11-06-2001 Jarek Burczynski: +** - corrected end of sample bug in ADPCMA_calc_cha(). +** Real YM2610 checks for equality between current and end addresses (only 20 LSB bits). +** +** 08-12-98 hiro-shi: +** rename ADPCMA -> ADPCMB, ADPCMB -> ADPCMA +** move ROM limit check.(CALC_CH? -> 2610Write1/2) +** test program (ADPCMB_TEST) +** move ADPCM A/B end check. +** ADPCMB repeat flag(no check) +** change ADPCM volume rate (8->16) (32->48). +** +** 09-12-98 hiro-shi: +** change ADPCM volume. (8->16, 48->64) +** replace ym2610 ch0/3 (YM-2610B) +** change ADPCM_SHIFT (10->8) missing bank change 0x4000-0xffff. +** add ADPCM_SHIFT_MASK +** change ADPCMA_DECODE_MIN/MAX. +*/ + + + + +/************************************************************************/ +/* comment of hiro-shi(Hiromitsu Shioya) */ +/* YM2610(B) = OPN-B */ +/* YM2610 : PSG:3ch FM:4ch ADPCM(18.5KHz):6ch DeltaT ADPCM:1ch */ +/* YM2610B : PSG:3ch FM:6ch ADPCM(18.5KHz):6ch DeltaT ADPCM:1ch */ +/************************************************************************/ + +#include "emu.h" + +#define YM2610B_WARNING +#include "fm.h" + + +/* include external DELTA-T unit (when needed) */ +#if (BUILD_YM2608||BUILD_YM2610||BUILD_YM2610B) + #include "ymdeltat.h" +#endif + + +#if BUILD_YM2203 +#include "2203intf.h" +#endif /* BUILD_YM2203 */ + +#if BUILD_YM2608 +#include "2608intf.h" +#endif /* BUILD_YM2608 */ + +#if (BUILD_YM2610||BUILD_YM2610B) +#include "2610intf.h" +#endif /* (BUILD_YM2610||BUILD_YM2610B) */ + + +/* shared function building option */ +#define BUILD_OPN (BUILD_YM2203||BUILD_YM2608||BUILD_YM2610||BUILD_YM2610B) +#define BUILD_OPN_PRESCALER (BUILD_YM2203||BUILD_YM2608) + + +/* globals */ +#define TYPE_SSG 0x01 /* SSG support */ +#define TYPE_LFOPAN 0x02 /* OPN type LFO and PAN */ +#define TYPE_6CH 0x04 /* FM 6CH / 3CH */ +#define TYPE_DAC 0x08 /* YM2612's DAC device */ +#define TYPE_ADPCM 0x10 /* two ADPCM units */ +#define TYPE_2610 0x20 /* bogus flag to differentiate 2608 from 2610 */ + + +#define TYPE_YM2203 (TYPE_SSG) +#define TYPE_YM2608 (TYPE_SSG |TYPE_LFOPAN |TYPE_6CH |TYPE_ADPCM) +#define TYPE_YM2610 (TYPE_SSG |TYPE_LFOPAN |TYPE_6CH |TYPE_ADPCM |TYPE_2610) + + + +#define FREQ_SH 16 /* 16.16 fixed point (frequency calculations) */ +#define EG_SH 16 /* 16.16 fixed point (envelope generator timing) */ +#define LFO_SH 24 /* 8.24 fixed point (LFO calculations) */ +#define TIMER_SH 16 /* 16.16 fixed point (timers calculations) */ + +#define FREQ_MASK ((1<>3) + +/* sin waveform table in 'decibel' scale */ +static unsigned int sin_tab[SIN_LEN]; + +/* sustain level table (3dB per step) */ +/* bit0, bit1, bit2, bit3, bit4, bit5, bit6 */ +/* 1, 2, 4, 8, 16, 32, 64 (value)*/ +/* 0.75, 1.5, 3, 6, 12, 24, 48 (dB)*/ + +/* 0 - 15: 0, 3, 6, 9,12,15,18,21,24,27,30,33,36,39,42,93 (dB)*/ +#define SC(db) (uint32_t) ( db * (4.0/ENV_STEP) ) +static const uint32_t sl_table[16]={ + SC( 0),SC( 1),SC( 2),SC(3 ),SC(4 ),SC(5 ),SC(6 ),SC( 7), + SC( 8),SC( 9),SC(10),SC(11),SC(12),SC(13),SC(14),SC(31) +}; +#undef SC + + +#define RATE_STEPS (8) +static const uint8_t eg_inc[19*RATE_STEPS]={ +/*cycle:0 1 2 3 4 5 6 7*/ + +/* 0 */ 0,1, 0,1, 0,1, 0,1, /* rates 00..11 0 (increment by 0 or 1) */ +/* 1 */ 0,1, 0,1, 1,1, 0,1, /* rates 00..11 1 */ +/* 2 */ 0,1, 1,1, 0,1, 1,1, /* rates 00..11 2 */ +/* 3 */ 0,1, 1,1, 1,1, 1,1, /* rates 00..11 3 */ + +/* 4 */ 1,1, 1,1, 1,1, 1,1, /* rate 12 0 (increment by 1) */ +/* 5 */ 1,1, 1,2, 1,1, 1,2, /* rate 12 1 */ +/* 6 */ 1,2, 1,2, 1,2, 1,2, /* rate 12 2 */ +/* 7 */ 1,2, 2,2, 1,2, 2,2, /* rate 12 3 */ + +/* 8 */ 2,2, 2,2, 2,2, 2,2, /* rate 13 0 (increment by 2) */ +/* 9 */ 2,2, 2,4, 2,2, 2,4, /* rate 13 1 */ +/*10 */ 2,4, 2,4, 2,4, 2,4, /* rate 13 2 */ +/*11 */ 2,4, 4,4, 2,4, 4,4, /* rate 13 3 */ + +/*12 */ 4,4, 4,4, 4,4, 4,4, /* rate 14 0 (increment by 4) */ +/*13 */ 4,4, 4,8, 4,4, 4,8, /* rate 14 1 */ +/*14 */ 4,8, 4,8, 4,8, 4,8, /* rate 14 2 */ +/*15 */ 4,8, 8,8, 4,8, 8,8, /* rate 14 3 */ + +/*16 */ 8,8, 8,8, 8,8, 8,8, /* rates 15 0, 15 1, 15 2, 15 3 (increment by 8) */ +/*17 */ 16,16,16,16,16,16,16,16, /* rates 15 2, 15 3 for attack */ +/*18 */ 0,0, 0,0, 0,0, 0,0, /* infinity rates for attack and decay(s) */ +}; + + +#define O(a) (a*RATE_STEPS) + +/*note that there is no O(17) in this table - it's directly in the code */ +static const uint8_t eg_rate_select[32+64+32]={ /* Envelope Generator rates (32 + 64 rates + 32 RKS) */ +/* 32 infinite time rates */ +O(18),O(18),O(18),O(18),O(18),O(18),O(18),O(18), +O(18),O(18),O(18),O(18),O(18),O(18),O(18),O(18), +O(18),O(18),O(18),O(18),O(18),O(18),O(18),O(18), +O(18),O(18),O(18),O(18),O(18),O(18),O(18),O(18), + +/* rates 00-11 */ +O( 0),O( 1),O( 2),O( 3), +O( 0),O( 1),O( 2),O( 3), +O( 0),O( 1),O( 2),O( 3), +O( 0),O( 1),O( 2),O( 3), +O( 0),O( 1),O( 2),O( 3), +O( 0),O( 1),O( 2),O( 3), +O( 0),O( 1),O( 2),O( 3), +O( 0),O( 1),O( 2),O( 3), +O( 0),O( 1),O( 2),O( 3), +O( 0),O( 1),O( 2),O( 3), +O( 0),O( 1),O( 2),O( 3), +O( 0),O( 1),O( 2),O( 3), + +/* rate 12 */ +O( 4),O( 5),O( 6),O( 7), + +/* rate 13 */ +O( 8),O( 9),O(10),O(11), + +/* rate 14 */ +O(12),O(13),O(14),O(15), + +/* rate 15 */ +O(16),O(16),O(16),O(16), + +/* 32 dummy rates (same as 15 3) */ +O(16),O(16),O(16),O(16),O(16),O(16),O(16),O(16), +O(16),O(16),O(16),O(16),O(16),O(16),O(16),O(16), +O(16),O(16),O(16),O(16),O(16),O(16),O(16),O(16), +O(16),O(16),O(16),O(16),O(16),O(16),O(16),O(16) + +}; + +#undef O + +/*rate 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15*/ +/*shift 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 0, 0, 0, 0 */ +/*mask 2047, 1023, 511, 255, 127, 63, 31, 15, 7, 3, 1, 0, 0, 0, 0, 0 */ + +#define O(a) (a*1) +static const uint8_t eg_rate_shift[32+64+32]={ /* Envelope Generator counter shifts (32 + 64 rates + 32 RKS) */ +/* 32 infinite time rates */ +O(0),O(0),O(0),O(0),O(0),O(0),O(0),O(0), +O(0),O(0),O(0),O(0),O(0),O(0),O(0),O(0), +O(0),O(0),O(0),O(0),O(0),O(0),O(0),O(0), +O(0),O(0),O(0),O(0),O(0),O(0),O(0),O(0), + +/* rates 00-11 */ +O(11),O(11),O(11),O(11), +O(10),O(10),O(10),O(10), +O( 9),O( 9),O( 9),O( 9), +O( 8),O( 8),O( 8),O( 8), +O( 7),O( 7),O( 7),O( 7), +O( 6),O( 6),O( 6),O( 6), +O( 5),O( 5),O( 5),O( 5), +O( 4),O( 4),O( 4),O( 4), +O( 3),O( 3),O( 3),O( 3), +O( 2),O( 2),O( 2),O( 2), +O( 1),O( 1),O( 1),O( 1), +O( 0),O( 0),O( 0),O( 0), + +/* rate 12 */ +O( 0),O( 0),O( 0),O( 0), + +/* rate 13 */ +O( 0),O( 0),O( 0),O( 0), + +/* rate 14 */ +O( 0),O( 0),O( 0),O( 0), + +/* rate 15 */ +O( 0),O( 0),O( 0),O( 0), + +/* 32 dummy rates (same as 15 3) */ +O( 0),O( 0),O( 0),O( 0),O( 0),O( 0),O( 0),O( 0), +O( 0),O( 0),O( 0),O( 0),O( 0),O( 0),O( 0),O( 0), +O( 0),O( 0),O( 0),O( 0),O( 0),O( 0),O( 0),O( 0), +O( 0),O( 0),O( 0),O( 0),O( 0),O( 0),O( 0),O( 0) + +}; +#undef O + +static const uint8_t dt_tab[4 * 32]={ +/* this is YM2151 and YM2612 phase increment data (in 10.10 fixed point format)*/ +/* FD=0 */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, +/* FD=1 */ + 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, + 2, 3, 3, 3, 4, 4, 4, 5, 5, 6, 6, 7, 8, 8, 8, 8, +/* FD=2 */ + 1, 1, 1, 1, 2, 2, 2, 2, 2, 3, 3, 3, 4, 4, 4, 5, + 5, 6, 6, 7, 8, 8, 9,10,11,12,13,14,16,16,16,16, +/* FD=3 */ + 2, 2, 2, 2, 2, 3, 3, 3, 4, 4, 4, 5, 5, 6, 6, 7, + 8 , 8, 9,10,11,12,13,14,16,17,19,20,22,22,22,22 +}; + + +/* OPN key frequency number -> key code follow table */ +/* fnum higher 4bit -> keycode lower 2bit */ +static const uint8_t opn_fktable[16] = {0,0,0,0,0,0,0,1,2,3,3,3,3,3,3,3}; + + +/* 8 LFO speed parameters */ +/* each value represents number of samples that one LFO level will last for */ +static const uint32_t lfo_samples_per_step[8] = {108, 77, 71, 67, 62, 44, 8, 5}; + + + +/*There are 4 different LFO AM depths available, they are: + 0 dB, 1.4 dB, 5.9 dB, 11.8 dB + Here is how it is generated (in EG steps): + + 11.8 dB = 0, 2, 4, 6, 8, 10,12,14,16...126,126,124,122,120,118,....4,2,0 + 5.9 dB = 0, 1, 2, 3, 4, 5, 6, 7, 8....63, 63, 62, 61, 60, 59,.....2,1,0 + 1.4 dB = 0, 0, 0, 0, 1, 1, 1, 1, 2,...15, 15, 15, 15, 14, 14,.....0,0,0 + + (1.4 dB is losing precision as you can see) + + It's implemented as generator from 0..126 with step 2 then a shift + right N times, where N is: + 8 for 0 dB + 3 for 1.4 dB + 1 for 5.9 dB + 0 for 11.8 dB +*/ +static const uint8_t lfo_ams_depth_shift[4] = {8, 3, 1, 0}; + + + +/*There are 8 different LFO PM depths available, they are: + 0, 3.4, 6.7, 10, 14, 20, 40, 80 (cents) + + Modulation level at each depth depends on F-NUMBER bits: 4,5,6,7,8,9,10 + (bits 8,9,10 = FNUM MSB from OCT/FNUM register) + + Here we store only first quarter (positive one) of full waveform. + Full table (lfo_pm_table) containing all 128 waveforms is build + at run (init) time. + + One value in table below represents 4 (four) basic LFO steps + (1 PM step = 4 AM steps). + + For example: + at LFO SPEED=0 (which is 108 samples per basic LFO step) + one value from "lfo_pm_output" table lasts for 432 consecutive + samples (4*108=432) and one full LFO waveform cycle lasts for 13824 + samples (32*432=13824; 32 because we store only a quarter of whole + waveform in the table below) +*/ +static const uint8_t lfo_pm_output[7*8][8]={ /* 7 bits meaningful (of F-NUMBER), 8 LFO output levels per one depth (out of 32), 8 LFO depths */ +/* FNUM BIT 4: 000 0001xxxx */ +/* DEPTH 0 */ {0, 0, 0, 0, 0, 0, 0, 0}, +/* DEPTH 1 */ {0, 0, 0, 0, 0, 0, 0, 0}, +/* DEPTH 2 */ {0, 0, 0, 0, 0, 0, 0, 0}, +/* DEPTH 3 */ {0, 0, 0, 0, 0, 0, 0, 0}, +/* DEPTH 4 */ {0, 0, 0, 0, 0, 0, 0, 0}, +/* DEPTH 5 */ {0, 0, 0, 0, 0, 0, 0, 0}, +/* DEPTH 6 */ {0, 0, 0, 0, 0, 0, 0, 0}, +/* DEPTH 7 */ {0, 0, 0, 0, 1, 1, 1, 1}, + +/* FNUM BIT 5: 000 0010xxxx */ +/* DEPTH 0 */ {0, 0, 0, 0, 0, 0, 0, 0}, +/* DEPTH 1 */ {0, 0, 0, 0, 0, 0, 0, 0}, +/* DEPTH 2 */ {0, 0, 0, 0, 0, 0, 0, 0}, +/* DEPTH 3 */ {0, 0, 0, 0, 0, 0, 0, 0}, +/* DEPTH 4 */ {0, 0, 0, 0, 0, 0, 0, 0}, +/* DEPTH 5 */ {0, 0, 0, 0, 0, 0, 0, 0}, +/* DEPTH 6 */ {0, 0, 0, 0, 1, 1, 1, 1}, +/* DEPTH 7 */ {0, 0, 1, 1, 2, 2, 2, 3}, + +/* FNUM BIT 6: 000 0100xxxx */ +/* DEPTH 0 */ {0, 0, 0, 0, 0, 0, 0, 0}, +/* DEPTH 1 */ {0, 0, 0, 0, 0, 0, 0, 0}, +/* DEPTH 2 */ {0, 0, 0, 0, 0, 0, 0, 0}, +/* DEPTH 3 */ {0, 0, 0, 0, 0, 0, 0, 0}, +/* DEPTH 4 */ {0, 0, 0, 0, 0, 0, 0, 1}, +/* DEPTH 5 */ {0, 0, 0, 0, 1, 1, 1, 1}, +/* DEPTH 6 */ {0, 0, 1, 1, 2, 2, 2, 3}, +/* DEPTH 7 */ {0, 0, 2, 3, 4, 4, 5, 6}, + +/* FNUM BIT 7: 000 1000xxxx */ +/* DEPTH 0 */ {0, 0, 0, 0, 0, 0, 0, 0}, +/* DEPTH 1 */ {0, 0, 0, 0, 0, 0, 0, 0}, +/* DEPTH 2 */ {0, 0, 0, 0, 0, 0, 1, 1}, +/* DEPTH 3 */ {0, 0, 0, 0, 1, 1, 1, 1}, +/* DEPTH 4 */ {0, 0, 0, 1, 1, 1, 1, 2}, +/* DEPTH 5 */ {0, 0, 1, 1, 2, 2, 2, 3}, +/* DEPTH 6 */ {0, 0, 2, 3, 4, 4, 5, 6}, +/* DEPTH 7 */ {0, 0, 4, 6, 8, 8, 0xa, 0xc}, + +/* FNUM BIT 8: 001 0000xxxx */ +/* DEPTH 0 */ {0, 0, 0, 0, 0, 0, 0, 0}, +/* DEPTH 1 */ {0, 0, 0, 0, 1, 1, 1, 1}, +/* DEPTH 2 */ {0, 0, 0, 1, 1, 1, 2, 2}, +/* DEPTH 3 */ {0, 0, 1, 1, 2, 2, 3, 3}, +/* DEPTH 4 */ {0, 0, 1, 2, 2, 2, 3, 4}, +/* DEPTH 5 */ {0, 0, 2, 3, 4, 4, 5, 6}, +/* DEPTH 6 */ {0, 0, 4, 6, 8, 8, 0xa, 0xc}, +/* DEPTH 7 */ {0, 0, 8, 0xc,0x10,0x10,0x14,0x18}, + +/* FNUM BIT 9: 010 0000xxxx */ +/* DEPTH 0 */ {0, 0, 0, 0, 0, 0, 0, 0}, +/* DEPTH 1 */ {0, 0, 0, 0, 2, 2, 2, 2}, +/* DEPTH 2 */ {0, 0, 0, 2, 2, 2, 4, 4}, +/* DEPTH 3 */ {0, 0, 2, 2, 4, 4, 6, 6}, +/* DEPTH 4 */ {0, 0, 2, 4, 4, 4, 6, 8}, +/* DEPTH 5 */ {0, 0, 4, 6, 8, 8, 0xa, 0xc}, +/* DEPTH 6 */ {0, 0, 8, 0xc,0x10,0x10,0x14,0x18}, +/* DEPTH 7 */ {0, 0,0x10,0x18,0x20,0x20,0x28,0x30}, + +/* FNUM BIT10: 100 0000xxxx */ +/* DEPTH 0 */ {0, 0, 0, 0, 0, 0, 0, 0}, +/* DEPTH 1 */ {0, 0, 0, 0, 4, 4, 4, 4}, +/* DEPTH 2 */ {0, 0, 0, 4, 4, 4, 8, 8}, +/* DEPTH 3 */ {0, 0, 4, 4, 8, 8, 0xc, 0xc}, +/* DEPTH 4 */ {0, 0, 4, 8, 8, 8, 0xc,0x10}, +/* DEPTH 5 */ {0, 0, 8, 0xc,0x10,0x10,0x14,0x18}, +/* DEPTH 6 */ {0, 0,0x10,0x18,0x20,0x20,0x28,0x30}, +/* DEPTH 7 */ {0, 0,0x20,0x30,0x40,0x40,0x50,0x60}, + +}; + +/* all 128 LFO PM waveforms */ +static int32_t lfo_pm_table[128*8*32]; /* 128 combinations of 7 bits meaningful (of F-NUMBER), 8 LFO depths, 32 LFO output levels per one depth */ + + +// libOPNMIDI: pan law table +static const uint16_t panlawtable[] = +{ + 65535, 65529, 65514, 65489, 65454, 65409, 65354, 65289, + 65214, 65129, 65034, 64929, 64814, 64689, 64554, 64410, + 64255, 64091, 63917, 63733, 63540, 63336, 63123, 62901, + 62668, 62426, 62175, 61914, 61644, 61364, 61075, 60776, + 60468, 60151, 59825, 59489, 59145, 58791, 58428, 58057, + 57676, 57287, 56889, 56482, 56067, 55643, 55211, 54770, + 54320, 53863, 53397, 52923, 52441, 51951, 51453, 50947, + 50433, 49912, 49383, 48846, 48302, 47750, 47191, + 46340, /* Center left */ + 46340, /* Center right */ + 45472, 44885, 44291, 43690, 43083, 42469, 41848, 41221, + 40588, 39948, 39303, 38651, 37994, 37330, 36661, 35986, + 35306, 34621, 33930, 33234, 32533, 31827, 31116, 30400, + 29680, 28955, 28225, 27492, 26754, 26012, 25266, 24516, + 23762, 23005, 22244, 21480, 20713, 19942, 19169, 18392, + 17613, 16831, 16046, 15259, 14469, 13678, 12884, 12088, + 11291, 10492, 9691, 8888, 8085, 7280, 6473, 5666, + 4858, 4050, 3240, 2431, 1620, 810, 0 +}; + + +/* register number to channel number , slot offset */ +#define OPN_CHAN(N) (N&3) +#define OPN_SLOT(N) ((N>>2)&3) + +/* slot number */ +#define SLOT1 0 +#define SLOT2 2 +#define SLOT3 1 +#define SLOT4 3 + +/* bit0 = Right enable , bit1 = Left enable */ +#define OUTD_RIGHT 1 +#define OUTD_LEFT 2 +#define OUTD_CENTER 3 + + +/* save output as raw 16-bit sample */ +/* #define SAVE_SAMPLE */ + +#ifdef SAVE_SAMPLE +static FILE *sample[1]; + #if 1 /*save to MONO file */ + #define SAVE_ALL_CHANNELS \ + { signed int pom = lt; \ + fputc((unsigned short)pom&0xff,sample[0]); \ + fputc(((unsigned short)pom>>8)&0xff,sample[0]); \ + } + #else /*save to STEREO file */ + #define SAVE_ALL_CHANNELS \ + { signed int pom = lt; \ + fputc((unsigned short)pom&0xff,sample[0]); \ + fputc(((unsigned short)pom>>8)&0xff,sample[0]); \ + pom = rt; \ + fputc((unsigned short)pom&0xff,sample[0]); \ + fputc(((unsigned short)pom>>8)&0xff,sample[0]); \ + } + #endif +#endif + + +/* struct describing a single operator (SLOT) */ +struct FM_SLOT +{ + int32_t *DT; /* detune :dt_tab[DT] */ + uint8_t KSR; /* key scale rate :3-KSR */ + uint32_t ar; /* attack rate */ + uint32_t d1r; /* decay rate */ + uint32_t d2r; /* sustain rate */ + uint32_t rr; /* release rate */ + uint8_t ksr; /* key scale rate :kcode>>(3-KSR) */ + uint32_t mul; /* multiple :ML_TABLE[ML] */ + + /* Phase Generator */ + uint32_t phase; /* phase counter */ + int32_t Incr; /* phase step */ + + /* Envelope Generator */ + uint8_t state; /* phase type */ + uint32_t tl; /* total level: TL << 3 */ + int32_t volume; /* envelope counter */ + uint32_t sl; /* sustain level:sl_table[SL] */ + uint32_t vol_out; /* current output from EG circuit (without AM from LFO) */ + + uint8_t eg_sh_ar; /* (attack state) */ + uint8_t eg_sel_ar; /* (attack state) */ + uint8_t eg_sh_d1r; /* (decay state) */ + uint8_t eg_sel_d1r; /* (decay state) */ + uint8_t eg_sh_d2r; /* (sustain state) */ + uint8_t eg_sel_d2r; /* (sustain state) */ + uint8_t eg_sh_rr; /* (release state) */ + uint8_t eg_sel_rr; /* (release state) */ + + uint8_t ssg; /* SSG-EG waveform */ + uint8_t ssgn; /* SSG-EG negated output */ + + uint32_t key; /* 0=last key was KEY OFF, 1=KEY ON */ + + /* LFO */ + uint32_t AMmask; /* AM enable flag */ + +}; + +struct FM_CH +{ + FM_SLOT SLOT[4]; /* four SLOTs (operators) */ + + uint8_t ALGO; /* algorithm */ + uint8_t FB; /* feedback shift */ + int32_t op1_out[2]; /* op1 output for feedback */ + + int32_t *connect1; /* SLOT1 output pointer */ + int32_t *connect3; /* SLOT3 output pointer */ + int32_t *connect2; /* SLOT2 output pointer */ + int32_t *connect4; /* SLOT4 output pointer */ + + int32_t *mem_connect;/* where to put the delayed sample (MEM) */ + int32_t mem_value; /* delayed sample (MEM) value */ + + int32_t pms; /* channel PMS */ + uint8_t ams; /* channel AMS */ + + uint32_t fc; /* fnum,blk:adjusted to sample rate */ + uint8_t kcode; /* key code: */ + uint32_t block_fnum; /* current blk/fnum value for this slot (can be different betweeen slots of one channel in 3slot mode) */ + + int32_t pan_volume_l; /* libOPNMIDI: left panning amount */ + int32_t pan_volume_r; /* libOPNMIDI: right panning amount */ +}; + + +struct FM_ST +{ + device_t *device; + int clock; /* master clock (Hz) */ + int rate; /* sampling rate (Hz) */ + double freqbase; /* frequency base */ + int timer_prescaler; /* timer prescaler */ +#if FM_BUSY_FLAG_SUPPORT + TIME_TYPE busy_expiry_time; /* expiry time of the busy status */ +#endif + uint8_t address; /* address register */ + uint8_t irq; /* interrupt level */ + uint8_t irqmask; /* irq mask */ + uint8_t status; /* status flag */ + uint32_t mode; /* mode CSM / 3SLOT */ + uint8_t prescaler_sel; /* prescaler selector */ + uint8_t fn_h; /* freq latch */ + int32_t TA; /* timer a */ + int32_t TAC; /* timer a counter */ + uint8_t TB; /* timer b */ + int32_t TBC; /* timer b counter */ + /* local time tables */ + int32_t dt_tab[8][32]; /* DeTune table */ + /* Extention Timer and IRQ handler */ + FM_TIMERHANDLER timer_handler; + FM_IRQHANDLER IRQ_Handler; + const ssg_callbacks *SSG; +}; + + + +/***********************************************************/ +/* OPN unit */ +/***********************************************************/ + +/* OPN 3slot struct */ +struct FM_3SLOT +{ + uint32_t fc[3]; /* fnum3,blk3: calculated */ + uint8_t fn_h; /* freq3 latch */ + uint8_t kcode[3]; /* key code */ + uint32_t block_fnum[3]; /* current fnum value for this slot (can be different betweeen slots of one channel in 3slot mode) */ +}; + +/* OPN/A/B common state */ +struct FM_OPN +{ + uint8_t type; /* chip type */ + FM_ST ST; /* general state */ + FM_3SLOT SL3; /* 3 slot mode state */ + FM_CH *P_CH; /* pointer of CH */ + unsigned int pan[6*2]; /* fm channels output masks (0xffffffff = enable) */ + + uint32_t eg_cnt; /* global envelope generator counter */ + uint32_t eg_timer; /* global envelope generator counter works at frequency = chipclock/64/3 */ + uint32_t eg_timer_add; /* step of eg_timer */ + uint32_t eg_timer_overflow;/* envelope generator timer overflows every 3 samples (on real chip) */ + + + /* there are 2048 FNUMs that can be generated using FNUM/BLK registers + but LFO works with one more bit of a precision so we really need 4096 elements */ + + uint32_t fn_table[4096]; /* fnumber->increment counter */ + uint32_t fn_max; /* maximal phase increment (used for phase overflow) */ + + /* LFO */ + uint32_t LFO_AM; /* runtime LFO calculations helper */ + int32_t LFO_PM; /* runtime LFO calculations helper */ + + uint32_t lfo_cnt; + uint32_t lfo_inc; + + uint32_t lfo_freq[8]; /* LFO FREQ table */ + + int32_t m2,c1,c2; /* Phase Modulation input for operators 2,3,4 */ + int32_t mem; /* one sample delay memory */ + + int32_t out_fm[8]; /* outputs of working channels */ + +#if (BUILD_YM2608||BUILD_YM2610||BUILD_YM2610B) + int32_t out_adpcm[4]; /* channel output NONE,LEFT,RIGHT or CENTER for YM2608/YM2610 ADPCM */ + int32_t out_delta[4]; /* channel output NONE,LEFT,RIGHT or CENTER for YM2608/YM2610 DELTAT*/ +#endif +}; + + + +/* current chip state */ + +/* log output level */ +#define LOG_ERR 3 /* ERROR */ +#define LOG_WAR 2 /* WARNING */ +#define LOG_INF 1 /* INFORMATION */ +#define LOG_LEVEL LOG_INF + +#ifndef __RAINE__ +#define LOG(d,n,x) do { if( (n)>=LOG_LEVEL ) d->logerror x; } while (0) +#endif + +/* limitter */ +#define Limit(val, max,min) { \ + if ( val > max ) val = max; \ + else if ( val < min ) val = min; \ +} + + +/* status set and IRQ handling */ +static inline void FM_STATUS_SET(FM_ST *ST,int flag) +{ + /* set status flag */ + ST->status |= flag; + if ( !(ST->irq) && (ST->status & ST->irqmask) ) + { + ST->irq = 1; + /* callback user interrupt handler (IRQ is OFF to ON) */ + if(ST->IRQ_Handler) (ST->IRQ_Handler)(ST->device,1); + } +} + +/* status reset and IRQ handling */ +static inline void FM_STATUS_RESET(FM_ST *ST,int flag) +{ + /* reset status flag */ + ST->status &=~flag; + if ( (ST->irq) && !(ST->status & ST->irqmask) ) + { + ST->irq = 0; + /* callback user interrupt handler (IRQ is ON to OFF) */ + if(ST->IRQ_Handler) (ST->IRQ_Handler)(ST->device,0); + } +} + +/* IRQ mask set */ +static inline void FM_IRQMASK_SET(FM_ST *ST,int flag) +{ + ST->irqmask = flag; + /* IRQ handling check */ + FM_STATUS_SET(ST,0); + FM_STATUS_RESET(ST,0); +} + +/* OPN Mode Register Write */ +static inline void set_timers( FM_ST *ST, device_t *n, int v ) +{ + /* b7 = CSM MODE */ + /* b6 = 3 slot mode */ + /* b5 = reset b */ + /* b4 = reset a */ + /* b3 = timer enable b */ + /* b2 = timer enable a */ + /* b1 = load b */ + /* b0 = load a */ + ST->mode = v; + + /* reset Timer b flag */ + if( v & 0x20 ) + FM_STATUS_RESET(ST,0x02); + /* reset Timer a flag */ + if( v & 0x10 ) + FM_STATUS_RESET(ST,0x01); + /* load b */ + if( v & 0x02 ) + { + if( ST->TBC == 0 ) + { + ST->TBC = ( 256-ST->TB)<<4; + /* External timer handler */ + if (ST->timer_handler) (ST->timer_handler)(n,1,ST->TBC * ST->timer_prescaler,ST->clock); + } + } + else + { /* stop timer b */ + if( ST->TBC != 0 ) + { + ST->TBC = 0; + if (ST->timer_handler) (ST->timer_handler)(n,1,0,ST->clock); + } + } + /* load a */ + if( v & 0x01 ) + { + if( ST->TAC == 0 ) + { + ST->TAC = (1024-ST->TA); + /* External timer handler */ + if (ST->timer_handler) (ST->timer_handler)(n,0,ST->TAC * ST->timer_prescaler,ST->clock); + } + } + else + { /* stop timer a */ + if( ST->TAC != 0 ) + { + ST->TAC = 0; + if (ST->timer_handler) (ST->timer_handler)(n,0,0,ST->clock); + } + } +} + + +/* Timer A Overflow */ +static inline void TimerAOver(FM_ST *ST) +{ + /* set status (if enabled) */ + if(ST->mode & 0x04) FM_STATUS_SET(ST,0x01); + /* clear or reload the counter */ + ST->TAC = (1024-ST->TA); + if (ST->timer_handler) (ST->timer_handler)(ST->device,0,ST->TAC * ST->timer_prescaler,ST->clock); +} +/* Timer B Overflow */ +static inline void TimerBOver(FM_ST *ST) +{ + /* set status (if enabled) */ + if(ST->mode & 0x08) FM_STATUS_SET(ST,0x02); + /* clear or reload the counter */ + ST->TBC = ( 256-ST->TB)<<4; + if (ST->timer_handler) (ST->timer_handler)(ST->device,1,ST->TBC * ST->timer_prescaler,ST->clock); +} + + +#if FM_INTERNAL_TIMER +/* ----- internal timer mode , update timer */ + +/* ---------- calculate timer A ---------- */ + #define INTERNAL_TIMER_A(ST,CSM_CH) \ + { \ + if( ST->TAC && (ST->timer_handler==0) ) \ + if( (ST->TAC -= (int)(ST->freqbase*4096)) <= 0 ) \ + { \ + TimerAOver( ST ); \ + /* CSM mode total level latch and auto key on */ \ + if( ST->mode & 0x80 ) \ + CSMKeyControll( CSM_CH ); \ + } \ + } +/* ---------- calculate timer B ---------- */ + #define INTERNAL_TIMER_B(ST,step) \ + { \ + if( ST->TBC && (ST->timer_handler==0) ) \ + if( (ST->TBC -= (int)(ST->freqbase*4096*step)) <= 0 ) \ + TimerBOver( ST ); \ + } +#else /* FM_INTERNAL_TIMER */ +/* external timer mode */ +#define INTERNAL_TIMER_A(ST,CSM_CH) +#define INTERNAL_TIMER_B(ST,step) +#endif /* FM_INTERNAL_TIMER */ + + + +#if FM_BUSY_FLAG_SUPPORT +#define FM_BUSY_CLEAR(ST) ((ST)->busy_expiry_time = UNDEFINED_TIME) +static inline uint8_t FM_STATUS_FLAG(FM_ST *ST) +{ + if( COMPARE_TIMES(ST->busy_expiry_time, UNDEFINED_TIME) != 0 ) + { + if (COMPARE_TIMES(ST->busy_expiry_time, FM_GET_TIME_NOW(&ST->device->machine())) > 0) + return ST->status | 0x80; /* with busy */ + /* expire */ + FM_BUSY_CLEAR(ST); + } + return ST->status; +} +static inline void FM_BUSY_SET(FM_ST *ST,int busyclock ) +{ + TIME_TYPE expiry_period = MULTIPLY_TIME_BY_INT(attotime::from_hz(ST->clock), busyclock * ST->timer_prescaler); + ST->busy_expiry_time = ADD_TIMES(FM_GET_TIME_NOW(&ST->device->machine()), expiry_period); +} +#else +#define FM_STATUS_FLAG(ST) ((ST)->status) +#define FM_BUSY_SET(ST,bclock) {} +#define FM_BUSY_CLEAR(ST) {} +#endif + + + + +static inline void FM_KEYON(uint8_t type, FM_CH *CH , int s ) +{ + FM_SLOT *SLOT = &CH->SLOT[s]; + (void)type; + if( !SLOT->key ) + { + SLOT->key = 1; + SLOT->phase = 0; /* restart Phase Generator */ + SLOT->ssgn = (SLOT->ssg & 0x04) >> 1; + SLOT->state = EG_ATT; + } +} + +static inline void FM_KEYOFF(FM_CH *CH , int s ) +{ + FM_SLOT *SLOT = &CH->SLOT[s]; + if( SLOT->key ) + { + SLOT->key = 0; + if (SLOT->state>EG_REL) + SLOT->state = EG_REL;/* phase -> Release */ + } +} + +/* set algorithm connection */ +static void setup_connection( FM_OPN *OPN, FM_CH *CH, int ch ) +{ + int32_t *carrier = &OPN->out_fm[ch]; + + int32_t **om1 = &CH->connect1; + int32_t **om2 = &CH->connect3; + int32_t **oc1 = &CH->connect2; + + int32_t **memc = &CH->mem_connect; + + switch( CH->ALGO ) + { + case 0: + /* M1---C1---MEM---M2---C2---OUT */ + *om1 = &OPN->c1; + *oc1 = &OPN->mem; + *om2 = &OPN->c2; + *memc= &OPN->m2; + break; + case 1: + /* M1------+-MEM---M2---C2---OUT */ + /* C1-+ */ + *om1 = &OPN->mem; + *oc1 = &OPN->mem; + *om2 = &OPN->c2; + *memc= &OPN->m2; + break; + case 2: + /* M1-----------------+-C2---OUT */ + /* C1---MEM---M2-+ */ + *om1 = &OPN->c2; + *oc1 = &OPN->mem; + *om2 = &OPN->c2; + *memc= &OPN->m2; + break; + case 3: + /* M1---C1---MEM------+-C2---OUT */ + /* M2-+ */ + *om1 = &OPN->c1; + *oc1 = &OPN->mem; + *om2 = &OPN->c2; + *memc= &OPN->c2; + break; + case 4: + /* M1---C1-+-OUT */ + /* M2---C2-+ */ + /* MEM: not used */ + *om1 = &OPN->c1; + *oc1 = carrier; + *om2 = &OPN->c2; + *memc= &OPN->mem; /* store it anywhere where it will not be used */ + break; + case 5: + /* +----C1----+ */ + /* M1-+-MEM---M2-+-OUT */ + /* +----C2----+ */ + *om1 = NULLPTR; /* special mark */ + *oc1 = carrier; + *om2 = carrier; + *memc= &OPN->m2; + break; + case 6: + /* M1---C1-+ */ + /* M2-+-OUT */ + /* C2-+ */ + /* MEM: not used */ + *om1 = &OPN->c1; + *oc1 = carrier; + *om2 = carrier; + *memc= &OPN->mem; /* store it anywhere where it will not be used */ + break; + case 7: + /* M1-+ */ + /* C1-+-OUT */ + /* M2-+ */ + /* C2-+ */ + /* MEM: not used*/ + *om1 = carrier; + *oc1 = carrier; + *om2 = carrier; + *memc= &OPN->mem; /* store it anywhere where it will not be used */ + break; + } + + CH->connect4 = carrier; +} + +/* set detune & multiple */ +static inline void set_det_mul(FM_ST *ST,FM_CH *CH,FM_SLOT *SLOT,int v) +{ + SLOT->mul = (v&0x0f)? (v&0x0f)*2 : 1; + SLOT->DT = ST->dt_tab[(v>>4)&7]; + CH->SLOT[SLOT1].Incr=-1; +} + +/* set total level */ +static inline void set_tl(FM_CH *CH,FM_SLOT *SLOT , int v) +{ + (void)CH; + SLOT->tl = (v&0x7f)<<(ENV_BITS-7); /* 7bit TL */ +} + +/* set attack rate & key scale */ +static inline void set_ar_ksr(uint8_t type, FM_CH *CH,FM_SLOT *SLOT,int v) +{ + uint8_t old_KSR = SLOT->KSR; + (void)type; + + SLOT->ar = (v&0x1f) ? 32 + ((v&0x1f)<<1) : 0; + + SLOT->KSR = 3-(v>>6); + if (SLOT->KSR != old_KSR) + { + CH->SLOT[SLOT1].Incr=-1; + } + + /* refresh Attack rate */ + if ((SLOT->ar + SLOT->ksr) < 32+62) + { + SLOT->eg_sh_ar = eg_rate_shift [SLOT->ar + SLOT->ksr ]; + SLOT->eg_sel_ar = eg_rate_select[SLOT->ar + SLOT->ksr ]; + } + else + { + SLOT->eg_sh_ar = 0; + SLOT->eg_sel_ar = 17*RATE_STEPS; + } +} + +/* set decay rate */ +static inline void set_dr(uint8_t type, FM_SLOT *SLOT,int v) +{ + (void)type; + SLOT->d1r = (v&0x1f) ? 32 + ((v&0x1f)<<1) : 0; + + SLOT->eg_sh_d1r = eg_rate_shift [SLOT->d1r + SLOT->ksr]; + SLOT->eg_sel_d1r= eg_rate_select[SLOT->d1r + SLOT->ksr]; +} + +/* set sustain rate */ +static inline void set_sr(uint8_t type, FM_SLOT *SLOT,int v) +{ + (void)type; + SLOT->d2r = (v&0x1f) ? 32 + ((v&0x1f)<<1) : 0; + + SLOT->eg_sh_d2r = eg_rate_shift [SLOT->d2r + SLOT->ksr]; + SLOT->eg_sel_d2r= eg_rate_select[SLOT->d2r + SLOT->ksr]; +} + +/* set release rate */ +static inline void set_sl_rr(uint8_t type, FM_SLOT *SLOT,int v) +{ + (void)type; + SLOT->sl = sl_table[ v>>4 ]; + + SLOT->rr = 34 + ((v&0x0f)<<2); + + SLOT->eg_sh_rr = eg_rate_shift [SLOT->rr + SLOT->ksr]; + SLOT->eg_sel_rr = eg_rate_select[SLOT->rr + SLOT->ksr]; +} + + + +static inline signed int op_calc(uint32_t phase, unsigned int env, signed int pm) +{ + uint32_t p; + + p = (env<<3) + sin_tab[ ( ((signed int)((phase & ~FREQ_MASK) + (pm<<15))) >> FREQ_SH ) & SIN_MASK ]; + + if (p >= TL_TAB_LEN) + return 0; + return tl_tab[p]; +} + +static inline signed int op_calc1(uint32_t phase, unsigned int env, signed int pm) +{ + uint32_t p; + + p = (env<<3) + sin_tab[ ( ((signed int)((phase & ~FREQ_MASK) + pm )) >> FREQ_SH ) & SIN_MASK ]; + + if (p >= TL_TAB_LEN) + return 0; + return tl_tab[p]; +} + +/* advance LFO to next sample */ +static inline void advance_lfo(FM_OPN *OPN) +{ + uint8_t pos; + + if (OPN->lfo_inc) /* LFO enabled ? */ + { + OPN->lfo_cnt += OPN->lfo_inc; + + pos = (OPN->lfo_cnt >> LFO_SH) & 127; + + + /* update AM when LFO output changes */ + + /* actually I can't optimize is this way without rewriting chan_calc() + to use chip->lfo_am instead of global lfo_am */ + { + /* triangle */ + /* AM: 0 to 126 step +2, 126 to 0 step -2 */ + if (pos<64) + OPN->LFO_AM = (pos&63) * 2; + else + OPN->LFO_AM = 126 - ((pos&63) * 2); + } + + /* PM works with 4 times slower clock */ + pos >>= 2; + /* update PM when LFO output changes */ + /*if (prev_pos != pos)*/ /* can't use global lfo_pm for this optimization, must be chip->lfo_pm instead*/ + { + OPN->LFO_PM = pos; + } + + } + else + { + OPN->LFO_AM = 0; + OPN->LFO_PM = 0; + } +} + +/* changed from static inline to static here to work around gcc 4.2.1 codegen bug */ +static void advance_eg_channel(FM_OPN *OPN, FM_SLOT *SLOT) +{ + unsigned int out; + unsigned int swap_flag; + unsigned int i; + + + i = 4; /* four operators per channel */ + do + { + /* reset SSG-EG swap flag */ + swap_flag = 0; + + switch(SLOT->state) + { + case EG_ATT: /* attack phase */ + if ( !(OPN->eg_cnt & ((1<eg_sh_ar)-1) ) ) + { + SLOT->volume += (~SLOT->volume * + (eg_inc[SLOT->eg_sel_ar + ((OPN->eg_cnt>>SLOT->eg_sh_ar)&7)]) + ) >>4; + + if (SLOT->volume <= MIN_ATT_INDEX) + { + SLOT->volume = MIN_ATT_INDEX; + SLOT->state = EG_DEC; + } + } + break; + + case EG_DEC: /* decay phase */ + { + if (SLOT->ssg&0x08) /* SSG EG type envelope selected */ + { + if ( !(OPN->eg_cnt & ((1<eg_sh_d1r)-1) ) ) + { + SLOT->volume += 4 * eg_inc[SLOT->eg_sel_d1r + ((OPN->eg_cnt>>SLOT->eg_sh_d1r)&7)]; + + if ( SLOT->volume >= (int32_t)(SLOT->sl) ) + SLOT->state = EG_SUS; + } + } + else + { + if ( !(OPN->eg_cnt & ((1<eg_sh_d1r)-1) ) ) + { + SLOT->volume += eg_inc[SLOT->eg_sel_d1r + ((OPN->eg_cnt>>SLOT->eg_sh_d1r)&7)]; + + if ( SLOT->volume >= (int32_t)(SLOT->sl) ) + SLOT->state = EG_SUS; + } + } + } + break; + + case EG_SUS: /* sustain phase */ + if (SLOT->ssg&0x08) /* SSG EG type envelope selected */ + { + if ( !(OPN->eg_cnt & ((1<eg_sh_d2r)-1) ) ) + { + SLOT->volume += 4 * eg_inc[SLOT->eg_sel_d2r + ((OPN->eg_cnt>>SLOT->eg_sh_d2r)&7)]; + + if ( SLOT->volume >= ENV_QUIET ) + { + SLOT->volume = MAX_ATT_INDEX; + + if (SLOT->ssg&0x01) /* bit 0 = hold */ + { + if (SLOT->ssgn&1) /* have we swapped once ??? */ + { + /* yes, so do nothing, just hold current level */ + } + else + swap_flag = (SLOT->ssg&0x02) | 1 ; /* bit 1 = alternate */ + + } + else + { + /* same as KEY-ON operation */ + + /* restart of the Phase Generator should be here */ + SLOT->phase = 0; + + { + /* phase -> Attack */ + SLOT->volume = 511; + SLOT->state = EG_ATT; + } + + swap_flag = (SLOT->ssg&0x02); /* bit 1 = alternate */ + } + } + } + } + else + { + if ( !(OPN->eg_cnt & ((1<eg_sh_d2r)-1) ) ) + { + SLOT->volume += eg_inc[SLOT->eg_sel_d2r + ((OPN->eg_cnt>>SLOT->eg_sh_d2r)&7)]; + + if ( SLOT->volume >= MAX_ATT_INDEX ) + { + SLOT->volume = MAX_ATT_INDEX; + /* do not change SLOT->state (verified on real chip) */ + } + } + + } + break; + + case EG_REL: /* release phase */ + if ( !(OPN->eg_cnt & ((1<eg_sh_rr)-1) ) ) + { + /* SSG-EG affects Release phase also (Nemesis) */ + SLOT->volume += eg_inc[SLOT->eg_sel_rr + ((OPN->eg_cnt>>SLOT->eg_sh_rr)&7)]; + + if ( SLOT->volume >= MAX_ATT_INDEX ) + { + SLOT->volume = MAX_ATT_INDEX; + SLOT->state = EG_OFF; + } + } + break; + + } + + + out = ((uint32_t)SLOT->volume); + + /* negate output (changes come from alternate bit, init comes from attack bit) */ + if ((SLOT->ssg&0x08) && (SLOT->ssgn&2) && (SLOT->state > EG_REL)) + out ^= MAX_ATT_INDEX; + + /* we need to store the result here because we are going to change ssgn + in next instruction */ + SLOT->vol_out = out + SLOT->tl; + + /* reverse SLOT inversion flag */ + SLOT->ssgn ^= swap_flag; + + SLOT++; + i--; + }while (i); + +} + + + +#define volume_calc(OP) ((OP)->vol_out + (AM & (OP)->AMmask)) + +static inline void update_phase_lfo_slot(FM_OPN *OPN, FM_SLOT *SLOT, int32_t pms, uint32_t block_fnum) +{ + uint32_t fnum_lfo = ((block_fnum & 0x7f0) >> 4) * 32 * 8; + int32_t lfo_fn_table_index_offset = lfo_pm_table[ fnum_lfo + pms + OPN->LFO_PM ]; + + if (lfo_fn_table_index_offset) /* LFO phase modulation active */ + { + uint8_t blk; + uint32_t fn; + int kc, fc; + + block_fnum = block_fnum*2 + lfo_fn_table_index_offset; + + blk = (block_fnum&0x7000) >> 12; + fn = block_fnum & 0xfff; + + /* keyscale code */ + kc = (blk<<2) | opn_fktable[fn >> 8]; + + /* phase increment counter */ + fc = (OPN->fn_table[fn]>>(7-blk)) + SLOT->DT[kc]; + + /* detects frequency overflow (credits to Nemesis) */ + if (fc < 0) fc += OPN->fn_max; + + /* update phase */ + SLOT->phase += (fc * SLOT->mul) >> 1; + } + else /* LFO phase modulation = zero */ + { + SLOT->phase += SLOT->Incr; + } +} + +static inline void update_phase_lfo_channel(FM_OPN *OPN, FM_CH *CH) +{ + uint32_t block_fnum = CH->block_fnum; + + uint32_t fnum_lfo = ((block_fnum & 0x7f0) >> 4) * 32 * 8; + int32_t lfo_fn_table_index_offset = lfo_pm_table[ fnum_lfo + CH->pms + OPN->LFO_PM ]; + + if (lfo_fn_table_index_offset) /* LFO phase modulation active */ + { + uint8_t blk; + uint32_t fn; + int kc, fc, finc; + + block_fnum = block_fnum*2 + lfo_fn_table_index_offset; + + blk = (block_fnum&0x7000) >> 12; + fn = block_fnum & 0xfff; + + /* keyscale code */ + kc = (blk<<2) | opn_fktable[fn >> 8]; + + /* phase increment counter */ + fc = (OPN->fn_table[fn]>>(7-blk)); + + /* detects frequency overflow (credits to Nemesis) */ + finc = fc + CH->SLOT[SLOT1].DT[kc]; + + if (finc < 0) finc += OPN->fn_max; + CH->SLOT[SLOT1].phase += (finc*CH->SLOT[SLOT1].mul) >> 1; + + finc = fc + CH->SLOT[SLOT2].DT[kc]; + if (finc < 0) finc += OPN->fn_max; + CH->SLOT[SLOT2].phase += (finc*CH->SLOT[SLOT2].mul) >> 1; + + finc = fc + CH->SLOT[SLOT3].DT[kc]; + if (finc < 0) finc += OPN->fn_max; + CH->SLOT[SLOT3].phase += (finc*CH->SLOT[SLOT3].mul) >> 1; + + finc = fc + CH->SLOT[SLOT4].DT[kc]; + if (finc < 0) finc += OPN->fn_max; + CH->SLOT[SLOT4].phase += (finc*CH->SLOT[SLOT4].mul) >> 1; + } + else /* LFO phase modulation = zero */ + { + CH->SLOT[SLOT1].phase += CH->SLOT[SLOT1].Incr; + CH->SLOT[SLOT2].phase += CH->SLOT[SLOT2].Incr; + CH->SLOT[SLOT3].phase += CH->SLOT[SLOT3].Incr; + CH->SLOT[SLOT4].phase += CH->SLOT[SLOT4].Incr; + } +} + +static inline void chan_calc(FM_OPN *OPN, FM_CH *CH, int chnum) +{ + unsigned int eg_out; + + uint32_t AM = OPN->LFO_AM >> CH->ams; + + + OPN->m2 = OPN->c1 = OPN->c2 = OPN->mem = 0; + + *CH->mem_connect = CH->mem_value; /* restore delayed sample (MEM) value to m2 or c2 */ + + eg_out = volume_calc(&CH->SLOT[SLOT1]); + { + int32_t out = CH->op1_out[0] + CH->op1_out[1]; + CH->op1_out[0] = CH->op1_out[1]; + + if( !CH->connect1 ) + { + /* algorithm 5 */ + OPN->mem = OPN->c1 = OPN->c2 = CH->op1_out[0]; + } + else + { + /* other algorithms */ + *CH->connect1 += CH->op1_out[0]; + } + + CH->op1_out[1] = 0; + if( eg_out < ENV_QUIET ) /* SLOT 1 */ + { + if (!CH->FB) + out=0; + + CH->op1_out[1] = op_calc1(CH->SLOT[SLOT1].phase, eg_out, (out<FB) ); + } + } + + eg_out = volume_calc(&CH->SLOT[SLOT3]); + if( eg_out < ENV_QUIET ) /* SLOT 3 */ + *CH->connect3 += op_calc(CH->SLOT[SLOT3].phase, eg_out, OPN->m2); + + eg_out = volume_calc(&CH->SLOT[SLOT2]); + if( eg_out < ENV_QUIET ) /* SLOT 2 */ + *CH->connect2 += op_calc(CH->SLOT[SLOT2].phase, eg_out, OPN->c1); + + eg_out = volume_calc(&CH->SLOT[SLOT4]); + if( eg_out < ENV_QUIET ) /* SLOT 4 */ + *CH->connect4 += op_calc(CH->SLOT[SLOT4].phase, eg_out, OPN->c2); + + + /* store current MEM */ + CH->mem_value = OPN->mem; + + /* update phase counters AFTER output calculations */ + if(CH->pms) + { + /* add support for 3 slot mode */ + if ((OPN->ST.mode & 0xC0) && (chnum == 2)) + { + update_phase_lfo_slot(OPN, &CH->SLOT[SLOT1], CH->pms, OPN->SL3.block_fnum[1]); + update_phase_lfo_slot(OPN, &CH->SLOT[SLOT2], CH->pms, OPN->SL3.block_fnum[2]); + update_phase_lfo_slot(OPN, &CH->SLOT[SLOT3], CH->pms, OPN->SL3.block_fnum[0]); + update_phase_lfo_slot(OPN, &CH->SLOT[SLOT4], CH->pms, CH->block_fnum); + } + else update_phase_lfo_channel(OPN, CH); + } + else /* no LFO phase modulation */ + { + CH->SLOT[SLOT1].phase += CH->SLOT[SLOT1].Incr; + CH->SLOT[SLOT2].phase += CH->SLOT[SLOT2].Incr; + CH->SLOT[SLOT3].phase += CH->SLOT[SLOT3].Incr; + CH->SLOT[SLOT4].phase += CH->SLOT[SLOT4].Incr; + } +} + +/* update phase increment and envelope generator */ +static inline void refresh_fc_eg_slot(FM_OPN *OPN, FM_SLOT *SLOT , int fc , int kc ) +{ + int ksr = kc >> SLOT->KSR; + + fc += SLOT->DT[kc]; + + /* detects frequency overflow (credits to Nemesis) */ + if (fc < 0) fc += OPN->fn_max; + + /* (frequency) phase increment counter */ + SLOT->Incr = (fc * SLOT->mul) >> 1; + + if( SLOT->ksr != ksr ) + { + SLOT->ksr = ksr; + + /* calculate envelope generator rates */ + if ((SLOT->ar + SLOT->ksr) < 32+62) + { + SLOT->eg_sh_ar = eg_rate_shift [SLOT->ar + SLOT->ksr ]; + SLOT->eg_sel_ar = eg_rate_select[SLOT->ar + SLOT->ksr ]; + } + else + { + SLOT->eg_sh_ar = 0; + SLOT->eg_sel_ar = 17*RATE_STEPS; + } + + SLOT->eg_sh_d1r = eg_rate_shift [SLOT->d1r + SLOT->ksr]; + SLOT->eg_sh_d2r = eg_rate_shift [SLOT->d2r + SLOT->ksr]; + SLOT->eg_sh_rr = eg_rate_shift [SLOT->rr + SLOT->ksr]; + + SLOT->eg_sel_d1r= eg_rate_select[SLOT->d1r + SLOT->ksr]; + SLOT->eg_sel_d2r= eg_rate_select[SLOT->d2r + SLOT->ksr]; + SLOT->eg_sel_rr = eg_rate_select[SLOT->rr + SLOT->ksr]; + } +} + +/* update phase increment counters */ +/* Changed from static inline to static to work around gcc 4.2.1 codegen bug */ +static void refresh_fc_eg_chan(FM_OPN *OPN, FM_CH *CH ) +{ + if( CH->SLOT[SLOT1].Incr==-1) + { + int fc = CH->fc; + int kc = CH->kcode; + refresh_fc_eg_slot(OPN, &CH->SLOT[SLOT1] , fc , kc ); + refresh_fc_eg_slot(OPN, &CH->SLOT[SLOT2] , fc , kc ); + refresh_fc_eg_slot(OPN, &CH->SLOT[SLOT3] , fc , kc ); + refresh_fc_eg_slot(OPN, &CH->SLOT[SLOT4] , fc , kc ); + } +} + +/* initialize time tables */ +static void init_timetables( FM_ST *ST , const uint8_t *dttable ) +{ + int i,d; + double rate; + +#if 0 + logerror("FM.C: samplerate=%8i chip clock=%8i freqbase=%f \n", + ST->rate, ST->clock, ST->freqbase ); +#endif + + /* DeTune table */ + for (d = 0;d <= 3;d++) + { + for (i = 0;i <= 31;i++) + { + rate = ((double)dttable[d*32 + i]) * SIN_LEN * ST->freqbase * (1<dt_tab[d][i] = (int32_t) rate; + ST->dt_tab[d+4][i] = -ST->dt_tab[d][i]; +#if 0 + logerror("FM.C: DT [%2i %2i] = %8x \n", d, i, ST->dt_tab[d][i] ); +#endif + } + } + +} + + +static void reset_channels( FM_ST *ST , FM_CH *CH , int num ) +{ + int c,s; + + ST->mode = 0; /* normal mode */ + ST->TA = 0; + ST->TAC = 0; + ST->TB = 0; + ST->TBC = 0; + + for( c = 0 ; c < num ; c++ ) + { + CH[c].fc = 0; + for(s = 0 ; s < 4 ; s++ ) + { + CH[c].SLOT[s].ssg = 0; + CH[c].SLOT[s].ssgn = 0; + CH[c].SLOT[s].state= EG_OFF; + CH[c].SLOT[s].volume = MAX_ATT_INDEX; + CH[c].SLOT[s].vol_out= MAX_ATT_INDEX; + } + } +} + +/* initialize generic tables */ +static int init_tables(void) +{ + signed int i,x; + signed int n; + double o,m; + + for (x=0; x>= 4; /* 12 bits here */ + if (n&1) /* round to nearest */ + n = (n>>1)+1; + else + n = n>>1; + /* 11 bits here (rounded) */ + n <<= 2; /* 13 bits here (as in real chip) */ + tl_tab[ x*2 + 0 ] = n; + tl_tab[ x*2 + 1 ] = -tl_tab[ x*2 + 0 ]; + + for (i=1; i<13; i++) + { + tl_tab[ x*2+0 + i*2*TL_RES_LEN ] = tl_tab[ x*2+0 ]>>i; + tl_tab[ x*2+1 + i*2*TL_RES_LEN ] = -tl_tab[ x*2+0 + i*2*TL_RES_LEN ]; + } + #if 0 + logerror("tl %04i", x); + for (i=0; i<13; i++) + logerror(", [%02i] %4x", i*2, tl_tab[ x*2 /*+1*/ + i*2*TL_RES_LEN ]); + logerror("\n"); + #endif + } + /*logerror("FM.C: TL_TAB_LEN = %i elements (%i bytes)\n",TL_TAB_LEN, (int)sizeof(tl_tab));*/ + + + for (i=0; i0.0) + o = 8*log(1.0/m)/log(2.0); /* convert to 'decibels' */ + else + o = 8*log(-1.0/m)/log(2.0); /* convert to 'decibels' */ + + o = o / (ENV_STEP/4); + + n = (int)(2.0*o); + if (n&1) /* round to nearest */ + n = (n>>1)+1; + else + n = n>>1; + + sin_tab[ i ] = n*2 + (m>=0.0? 0: 1 ); + /*logerror("FM.C: sin [%4i]= %4i (tl_tab value=%5i)\n", i, sin_tab[i],tl_tab[sin_tab[i]]);*/ + } + + /*logerror("FM.C: ENV_QUIET= %08x\n",ENV_QUIET );*/ + + + /* build LFO PM modulation table */ + for(i = 0; i < 8; i++) /* 8 PM depths */ + { + uint8_t fnum; + for (fnum=0; fnum<128; fnum++) /* 7 bits meaningful of F-NUMBER */ + { + uint8_t value; + uint8_t step; + uint32_t offset_depth = i; + uint32_t offset_fnum_bit; + uint32_t bit_tmp; + + for (step=0; step<8; step++) + { + value = 0; + for (bit_tmp=0; bit_tmp<7; bit_tmp++) /* 7 bits */ + { + if (fnum & (1<SLOT[SLOT1].key) + { + FM_KEYON(type, CH,SLOT1); + FM_KEYOFF(CH, SLOT1); + } + if (!CH->SLOT[SLOT2].key) + { + FM_KEYON(type, CH,SLOT2); + FM_KEYOFF(CH, SLOT2); + } + if (!CH->SLOT[SLOT3].key) + { + FM_KEYON(type, CH,SLOT3); + FM_KEYOFF(CH, SLOT3); + } + if (!CH->SLOT[SLOT4].key) + { + FM_KEYON(type, CH,SLOT4); + FM_KEYOFF(CH, SLOT4); + } +} + +#ifdef MAME_EMU_SAVE_H +/* FM channel save , internal state only */ +static void FMsave_state_channel(device_t *device,FM_CH *CH,int num_ch) +{ + int slot , ch; + + for(ch=0;chsave_item(NAME(CH->op1_out), ch); + device->save_item(NAME(CH->fc), ch); + /* slots */ + for(slot=0;slot<4;slot++) + { + FM_SLOT *SLOT = &CH->SLOT[slot]; + device->save_item(NAME(SLOT->phase), ch * 4 + slot); + device->save_item(NAME(SLOT->state), ch * 4 + slot); + device->save_item(NAME(SLOT->volume), ch * 4 + slot); + } + } +} + +static void FMsave_state_st(device_t *device,FM_ST *ST) +{ +#if FM_BUSY_FLAG_SUPPORT + device->save_item(NAME(ST->busy_expiry_time) ); +#endif + device->save_item(NAME(ST->address) ); + device->save_item(NAME(ST->irq) ); + device->save_item(NAME(ST->irqmask) ); + device->save_item(NAME(ST->status) ); + device->save_item(NAME(ST->mode) ); + device->save_item(NAME(ST->prescaler_sel) ); + device->save_item(NAME(ST->fn_h) ); + device->save_item(NAME(ST->TA) ); + device->save_item(NAME(ST->TAC) ); + device->save_item(NAME(ST->TB) ); + device->save_item(NAME(ST->TBC) ); +} +#endif /* MAME_EMU_SAVE_H */ + +#if BUILD_OPN + + + +/* prescaler set (and make time tables) */ +static void OPNSetPres(FM_OPN *OPN, int pres, int timer_prescaler, int SSGpres) +{ + int i; + + /* frequency base */ + OPN->ST.freqbase = (OPN->ST.rate) ? ((double)OPN->ST.clock / OPN->ST.rate) / pres : 0; + +#if 0 + OPN->ST.rate = (double)OPN->ST.clock / pres; + OPN->ST.freqbase = 1.0; +#endif + + OPN->eg_timer_add = (uint32_t)((1<ST.freqbase); + OPN->eg_timer_overflow = ( 3 ) * (1<ST.timer_prescaler = timer_prescaler; + + /* SSG part prescaler set */ + if( SSGpres ) (*OPN->ST.SSG->set_clock)( OPN->ST.device, OPN->ST.clock * 2 / SSGpres ); + + /* make time tables */ + init_timetables( &OPN->ST, dt_tab ); + + /* there are 2048 FNUMs that can be generated using FNUM/BLK registers + but LFO works with one more bit of a precision so we really need 4096 elements */ + /* calculate fnumber -> increment counter table */ + for(i = 0; i < 4096; i++) + { + /* freq table for octave 7 */ + /* OPN phase increment counter = 20bit */ + OPN->fn_table[i] = (uint32_t)( (double)i * 32 * OPN->ST.freqbase * (1<<(FREQ_SH-10)) ); /* -10 because chip works with 10.10 fixed point, while we use 16.16 */ +#if 0 + logerror("FM.C: fn_table[%4i] = %08x (dec=%8i)\n", + i, OPN->fn_table[i]>>6,OPN->fn_table[i]>>6 ); +#endif + } + + /* maximal frequency is required for Phase overflow calculation, register size is 17 bits (Nemesis) */ + OPN->fn_max = (uint32_t)( (double)0x20000 * OPN->ST.freqbase * (1<<(FREQ_SH-10)) ); + + /* LFO freq. table */ + for(i = 0; i < 8; i++) + { + /* Amplitude modulation: 64 output levels (triangle waveform); 1 level lasts for one of "lfo_samples_per_step" samples */ + /* Phase modulation: one entry from lfo_pm_output lasts for one of 4 * "lfo_samples_per_step" samples */ + OPN->lfo_freq[i] = (uint32_t)((1.0 / lfo_samples_per_step[i]) * (1<ST.freqbase); +#if 0 + logerror("FM.C: lfo_freq[%i] = %08x (dec=%8i)\n", + i, OPN->lfo_freq[i],OPN->lfo_freq[i] ); +#endif + } +} + + + +/* write a OPN mode register 0x20-0x2f */ +static void OPNWriteMode(FM_OPN *OPN, int r, int v) +{ + uint8_t c; + FM_CH *CH; + + switch(r) + { + case 0x21: /* Test */ + break; + case 0x22: /* LFO FREQ (YM2608/YM2610/YM2610B/YM2612) */ + if( OPN->type & TYPE_LFOPAN ) + { + if (v&0x08) /* LFO enabled ? */ + { + OPN->lfo_inc = OPN->lfo_freq[v&7]; + } + else + { + OPN->lfo_inc = 0; + } + } + break; + case 0x24: /* timer A High 8*/ + OPN->ST.TA = (OPN->ST.TA & 0x03)|(((int)v)<<2); + break; + case 0x25: /* timer A Low 2*/ + OPN->ST.TA = (OPN->ST.TA & 0x3fc)|(v&3); + break; + case 0x26: /* timer B */ + OPN->ST.TB = v; + break; + case 0x27: /* mode, timer control */ + set_timers( &(OPN->ST),OPN->ST.device,v ); + break; + case 0x28: /* key on / off */ + c = v & 0x03; + if( c == 3 ) break; + if( (v&0x04) && (OPN->type & TYPE_6CH) ) c+=3; + CH = OPN->P_CH; + CH = &CH[c]; + if(v&0x10) FM_KEYON(OPN->type,CH,SLOT1); else FM_KEYOFF(CH,SLOT1); + if(v&0x20) FM_KEYON(OPN->type,CH,SLOT2); else FM_KEYOFF(CH,SLOT2); + if(v&0x40) FM_KEYON(OPN->type,CH,SLOT3); else FM_KEYOFF(CH,SLOT3); + if(v&0x80) FM_KEYON(OPN->type,CH,SLOT4); else FM_KEYOFF(CH,SLOT4); + break; + } +} + +/* write a OPN register (0x30-0xff) */ +static void OPNWriteReg(FM_OPN *OPN, int r, int v) +{ + FM_CH *CH; + FM_SLOT *SLOT; + + uint8_t c = OPN_CHAN(r); + + if (c == 3) return; /* 0xX3,0xX7,0xXB,0xXF */ + + if (r >= 0x100) c+=3; + + CH = OPN->P_CH; + CH = &CH[c]; + + SLOT = &(CH->SLOT[OPN_SLOT(r)]); + + switch( r & 0xf0 ) + { + case 0x30: /* DET , MUL */ + set_det_mul(&OPN->ST,CH,SLOT,v); + break; + + case 0x40: /* TL */ + set_tl(CH,SLOT,v); + break; + + case 0x50: /* KS, AR */ + set_ar_ksr(OPN->type,CH,SLOT,v); + break; + + case 0x60: /* bit7 = AM ENABLE, DR */ + set_dr(OPN->type, SLOT,v); + + if(OPN->type & TYPE_LFOPAN) /* YM2608/2610/2610B/2612 */ + { + SLOT->AMmask = (v&0x80) ? ~0 : 0; + } + break; + + case 0x70: /* SR */ + set_sr(OPN->type,SLOT,v); + break; + + case 0x80: /* SL, RR */ + set_sl_rr(OPN->type,SLOT,v); + break; + + case 0x90: /* SSG-EG */ + SLOT->ssg = v&0x0f; + SLOT->ssgn = (v&0x04)>>1; /* bit 1 in ssgn = attack */ + + /* SSG-EG envelope shapes : + + E AtAlH + 1 0 0 0 \\\\ + + 1 0 0 1 \___ + + 1 0 1 0 \/\/ + ___ + 1 0 1 1 \ + + 1 1 0 0 //// + ___ + 1 1 0 1 / + + 1 1 1 0 /\/\ + + 1 1 1 1 /___ + + + E = SSG-EG enable + + + The shapes are generated using Attack, Decay and Sustain phases. + + Each single character in the diagrams above represents this whole + sequence: + + - when KEY-ON = 1, normal Attack phase is generated (*without* any + difference when compared to normal mode), + + - later, when envelope level reaches minimum level (max volume), + the EG switches to Decay phase (which works with bigger steps + when compared to normal mode - see below), + + - later when envelope level passes the SL level, + the EG swithes to Sustain phase (which works with bigger steps + when compared to normal mode - see below), + + - finally when envelope level reaches maximum level (min volume), + the EG switches to Attack phase again (depends on actual waveform). + + Important is that when switch to Attack phase occurs, the phase counter + of that operator will be zeroed-out (as in normal KEY-ON) but not always. + (I havent found the rule for that - perhaps only when the output level is low) + + The difference (when compared to normal Envelope Generator mode) is + that the resolution in Decay and Sustain phases is 4 times lower; + this results in only 256 steps instead of normal 1024. + In other words: + when SSG-EG is disabled, the step inside of the EG is one, + when SSG-EG is enabled, the step is four (in Decay and Sustain phases). + + Times between the level changes are the same in both modes. + + + Important: + Decay 1 Level (so called SL) is compared to actual SSG-EG output, so + it is the same in both SSG and no-SSG modes, with this exception: + + when the SSG-EG is enabled and is generating raising levels + (when the EG output is inverted) the SL will be found at wrong level !!! + For example, when SL=02: + 0 -6 = -6dB in non-inverted EG output + 96-6 = -90dB in inverted EG output + Which means that EG compares its level to SL as usual, and that the + output is simply inverted afterall. + + + The Yamaha's manuals say that AR should be set to 0x1f (max speed). + That is not necessary, but then EG will be generating Attack phase. + + */ + + + break; + + case 0xa0: + switch( OPN_SLOT(r) ) + { + case 0: /* 0xa0-0xa2 : FNUM1 */ + { + uint32_t fn = (((uint32_t)( (OPN->ST.fn_h)&7))<<8) + v; + uint8_t blk = OPN->ST.fn_h>>3; + /* keyscale code */ + CH->kcode = (blk<<2) | opn_fktable[fn >> 7]; + /* phase increment counter */ + CH->fc = OPN->fn_table[fn*2]>>(7-blk); + + /* store fnum in clear form for LFO PM calculations */ + CH->block_fnum = (blk<<11) | fn; + + CH->SLOT[SLOT1].Incr=-1; + } + break; + case 1: /* 0xa4-0xa6 : FNUM2,BLK */ + OPN->ST.fn_h = v&0x3f; + break; + case 2: /* 0xa8-0xaa : 3CH FNUM1 */ + if(r < 0x100) + { + uint32_t fn = (((uint32_t)(OPN->SL3.fn_h&7))<<8) + v; + uint8_t blk = OPN->SL3.fn_h>>3; + /* keyscale code */ + OPN->SL3.kcode[c]= (blk<<2) | opn_fktable[fn >> 7]; + /* phase increment counter */ + OPN->SL3.fc[c] = OPN->fn_table[fn*2]>>(7-blk); + OPN->SL3.block_fnum[c] = (blk<<11) | fn; + (OPN->P_CH)[2].SLOT[SLOT1].Incr=-1; + } + break; + case 3: /* 0xac-0xae : 3CH FNUM2,BLK */ + if(r < 0x100) + OPN->SL3.fn_h = v&0x3f; + break; + } + break; + + case 0xb0: + switch( OPN_SLOT(r) ) + { + case 0: /* 0xb0-0xb2 : FB,ALGO */ + { + int feedback = (v>>3)&7; + CH->ALGO = v&7; + CH->FB = feedback ? feedback+6 : 0; + setup_connection( OPN, CH, c ); + } + break; + case 1: /* 0xb4-0xb6 : L , R , AMS , PMS (YM2612/YM2610B/YM2610/YM2608) */ + if( OPN->type & TYPE_LFOPAN) + { + /* b0-2 PMS */ + CH->pms = (v & 7) * 32; /* CH->pms = PM depth * 32 (index in lfo_pm_table) */ + + /* b4-5 AMS */ + CH->ams = lfo_ams_depth_shift[(v>>4) & 0x03]; + + /* PAN : b7 = L, b6 = R */ + OPN->pan[ c*2 ] = (v & 0x80) ? ~0 : 0; + OPN->pan[ c*2+1 ] = (v & 0x40) ? ~0 : 0; + + } + break; + } + break; + } +} + +#endif /* BUILD_OPN */ + +#if BUILD_OPN_PRESCALER +/* + prescaler circuit (best guess to verified chip behaviour) + + +--------------+ +-sel2-+ + | +--|in20 | + +---+ | +-sel1-+ | | +M-CLK -+-|1/2|-+--|in10 | +---+ | out|--INT_CLOCK + | +---+ | out|-|1/3|-|in21 | + +----------|in11 | +---+ +------+ + +------+ + +reg.2d : sel2 = in21 (select sel2) +reg.2e : sel1 = in11 (select sel1) +reg.2f : sel1 = in10 , sel2 = in20 (clear selector) +reset : sel1 = in11 , sel2 = in21 (clear both) + +*/ +static void OPNPrescaler_w(FM_OPN *OPN , int addr, int pre_divider) +{ + static const int opn_pres[4] = { 2*12 , 2*12 , 6*12 , 3*12 }; + static const int ssg_pres[4] = { 1 , 1 , 4 , 2 }; + int sel; + + switch(addr) + { + case 0: /* when reset */ + OPN->ST.prescaler_sel = 2; + break; + case 1: /* when postload */ + break; + case 0x2d: /* divider sel : select 1/1 for 1/3line */ + OPN->ST.prescaler_sel |= 0x02; + break; + case 0x2e: /* divider sel , select 1/3line for output */ + OPN->ST.prescaler_sel |= 0x01; + break; + case 0x2f: /* divider sel , clear both selector to 1/2,1/2 */ + OPN->ST.prescaler_sel = 0; + break; + } + sel = OPN->ST.prescaler_sel & 3; + /* update prescaler */ + OPNSetPres( OPN, opn_pres[sel]*pre_divider, + opn_pres[sel]*pre_divider, + ssg_pres[sel]*pre_divider ); +} +#endif /* BUILD_OPN_PRESCALER */ + +#if BUILD_YM2203 +/*****************************************************************************/ +/* YM2203 local section */ +/*****************************************************************************/ + +/* here's the virtual YM2203(OPN) */ +namespace { +struct ym2203_state +{ + uint8_t REGS[256]; /* registers */ + FM_OPN OPN; /* OPN state */ + FM_CH CH[3]; /* channel state */ +}; +} // anonymous namespace + +/* Generate samples for one of the YM2203s */ +void ym2203_update_one(void *chip, FMSAMPLE *buffer, int length) +{ + ym2203_state *F2203 = (ym2203_state *)chip; + FM_OPN *OPN = &F2203->OPN; + int i; + FMSAMPLE *buf = buffer; + FM_CH *cch[3]; + + cch[0] = &F2203->CH[0]; + cch[1] = &F2203->CH[1]; + cch[2] = &F2203->CH[2]; + + + /* refresh PG and EG */ + refresh_fc_eg_chan( OPN, cch[0] ); + refresh_fc_eg_chan( OPN, cch[1] ); + if( (F2203->OPN.ST.mode & 0xc0) ) + { + /* 3SLOT MODE */ + if( cch[2]->SLOT[SLOT1].Incr==-1) + { + refresh_fc_eg_slot(OPN, &cch[2]->SLOT[SLOT1] , OPN->SL3.fc[1] , OPN->SL3.kcode[1] ); + refresh_fc_eg_slot(OPN, &cch[2]->SLOT[SLOT2] , OPN->SL3.fc[2] , OPN->SL3.kcode[2] ); + refresh_fc_eg_slot(OPN, &cch[2]->SLOT[SLOT3] , OPN->SL3.fc[0] , OPN->SL3.kcode[0] ); + refresh_fc_eg_slot(OPN, &cch[2]->SLOT[SLOT4] , cch[2]->fc , cch[2]->kcode ); + } + } + else + refresh_fc_eg_chan( OPN, cch[2] ); + + + /* YM2203 doesn't have LFO so we must keep these globals at 0 level */ + OPN->LFO_AM = 0; + OPN->LFO_PM = 0; + + /* buffering */ + for (i=0; i < length ; i++) + { + /* clear outputs */ + OPN->out_fm[0] = 0; + OPN->out_fm[1] = 0; + OPN->out_fm[2] = 0; + + /* advance envelope generator */ + OPN->eg_timer += OPN->eg_timer_add; + while (OPN->eg_timer >= OPN->eg_timer_overflow) + { + OPN->eg_timer -= OPN->eg_timer_overflow; + OPN->eg_cnt++; + + advance_eg_channel(OPN, &cch[0]->SLOT[SLOT1]); + advance_eg_channel(OPN, &cch[1]->SLOT[SLOT1]); + advance_eg_channel(OPN, &cch[2]->SLOT[SLOT1]); + } + + /* calculate FM */ + chan_calc(OPN, cch[0], 0 ); + chan_calc(OPN, cch[1], 1 ); + chan_calc(OPN, cch[2], 2 ); + + /* buffering */ + { + int lt; + + lt = OPN->out_fm[0] + OPN->out_fm[1] + OPN->out_fm[2]; + + lt >>= FINAL_SH; + + Limit( lt , MAXOUT, MINOUT ); + + #ifdef SAVE_SAMPLE + SAVE_ALL_CHANNELS + #endif + + /* buffering */ + buf[i] = lt; + } + + /* timer A control */ + INTERNAL_TIMER_A( &F2203->OPN.ST , cch[2] ) + } + INTERNAL_TIMER_B(&F2203->OPN.ST,length) +} + +/* ---------- reset one of chip ---------- */ +void ym2203_reset_chip(void *chip) +{ + int i; + ym2203_state *F2203 = (ym2203_state *)chip; + FM_OPN *OPN = &F2203->OPN; + + /* Reset Prescaler */ + OPNPrescaler_w(OPN, 0 , 1 ); + /* reset SSG section */ + (*OPN->ST.SSG->reset)(OPN->ST.device); + /* status clear */ + FM_IRQMASK_SET(&OPN->ST,0x03); + FM_BUSY_CLEAR(&OPN->ST); + OPNWriteMode(OPN,0x27,0x30); /* mode 0 , timer reset */ + + OPN->eg_timer = 0; + OPN->eg_cnt = 0; + + FM_STATUS_RESET(&OPN->ST, 0xff); + + reset_channels( &OPN->ST , F2203->CH , 3 ); + /* reset OPerator paramater */ + for(i = 0xb2 ; i >= 0x30 ; i-- ) OPNWriteReg(OPN,i,0); + for(i = 0x26 ; i >= 0x20 ; i-- ) OPNWriteReg(OPN,i,0); +} + +#ifdef MAME_EMU_SAVE_H +void ym2203_postload(void *chip) +{ + if (chip) + { + ym2203_state *F2203 = (ym2203_state *)chip; + int r; + + /* prescaler */ + OPNPrescaler_w(&F2203->OPN,1,1); + + /* SSG registers */ + for(r=0;r<16;r++) + { + (*F2203->OPN.ST.SSG->write)(F2203->OPN.ST.device,0,r); + (*F2203->OPN.ST.SSG->write)(F2203->OPN.ST.device,1,F2203->REGS[r]); + } + + /* OPN registers */ + /* DT / MULTI , TL , KS / AR , AMON / DR , SR , SL / RR , SSG-EG */ + for(r=0x30;r<0x9e;r++) + if((r&3) != 3) + OPNWriteReg(&F2203->OPN,r,F2203->REGS[r]); + /* FB / CONNECT , L / R / AMS / PMS */ + for(r=0xb0;r<0xb6;r++) + if((r&3) != 3) + OPNWriteReg(&F2203->OPN,r,F2203->REGS[r]); + + /* channels */ + /*FM_channel_postload(F2203->CH,3);*/ + } +} + +static void YM2203_save_state(ym2203_state *F2203, device_t *device) +{ + device->save_item(NAME(F2203->REGS)); + FMsave_state_st(device,&F2203->OPN.ST); + FMsave_state_channel(device,F2203->CH,3); + /* 3slots */ + device->save_item (NAME(F2203->OPN.SL3.fc)); + device->save_item (NAME(F2203->OPN.SL3.fn_h)); + device->save_item (NAME(F2203->OPN.SL3.kcode)); +} +#endif /* MAME_EMU_SAVE_H */ + +/* ---------- Initialize YM2203 emulator(s) ---------- + 'num' is the number of virtual YM2203s to allocate + 'clock' is the chip clock in Hz + 'rate' is sampling rate +*/ +void * ym2203_init(device_t *device, int clock, int rate, FM_TIMERHANDLER timer_handler,FM_IRQHANDLER IRQHandler, const ssg_callbacks *ssg) +{ + ym2203_state *F2203; + + /* allocate ym2203 state space */ + F2203 = new ym2203_state; + memset(F2203, 0, sizeof(*F2203)); + + if( !init_tables() ) + { + delete F2203; + return nullptr; + } + + F2203->OPN.type = TYPE_YM2203; + F2203->OPN.P_CH = F2203->CH; + F2203->OPN.ST.device = device; + F2203->OPN.ST.clock = clock; + F2203->OPN.ST.rate = rate; + + F2203->OPN.ST.timer_handler = timer_handler; + F2203->OPN.ST.IRQ_Handler = IRQHandler; + F2203->OPN.ST.SSG = ssg; + + for (unsigned i = 0; i < 3; i++) + { + F2203->CH[i].pan_volume_l = 46340; + F2203->CH[i].pan_volume_r = 46340; + } + +#ifdef MAME_EMU_SAVE_H + YM2203_save_state(F2203, device); +#endif + return F2203; +} + +void ym2203_clock_changed(void *chip, int clock, int rate) +{ + ym2203_state *FM2203 = (ym2203_state *)chip; + + FM2203->OPN.ST.clock = clock; + FM2203->OPN.ST.rate = rate; +} + +/* shut down emulator */ +void ym2203_shutdown(void *chip) +{ + ym2203_state *FM2203 = (ym2203_state *)chip; + + FMCloseTable(); + delete FM2203; +} + +/* YM2203 I/O interface */ +int ym2203_write(void *chip,int a,uint8_t v) +{ + ym2203_state *F2203 = (ym2203_state *)chip; + FM_OPN *OPN = &F2203->OPN; + + if( !(a&1) ) + { /* address port */ + OPN->ST.address = (v &= 0xff); + + /* Write register to SSG emulator */ + if( v < 16 ) (*OPN->ST.SSG->write)(OPN->ST.device,0,v); + + /* prescaler select : 2d,2e,2f */ + if( v >= 0x2d && v <= 0x2f ) + OPNPrescaler_w(OPN , v , 1); + } + else + { /* data port */ + int addr = OPN->ST.address; + F2203->REGS[addr] = v; + switch( addr & 0xf0 ) + { + case 0x00: /* 0x00-0x0f : SSG section */ + /* Write data to SSG emulator */ + (*OPN->ST.SSG->write)(OPN->ST.device,a,v); + break; + case 0x20: /* 0x20-0x2f : Mode section */ + ym2203_device::update_request(OPN->ST.device); + /* write register */ + OPNWriteMode(OPN,addr,v); + break; + default: /* 0x30-0xff : OPN section */ + ym2203_device::update_request(OPN->ST.device); + /* write register */ + OPNWriteReg(OPN,addr,v); + } + FM_BUSY_SET(&OPN->ST,1); + } + return OPN->ST.irq; +} + +uint8_t ym2203_read(void *chip,int a) +{ + ym2203_state *F2203 = (ym2203_state *)chip; + int addr = F2203->OPN.ST.address; + uint8_t ret = 0; + + if( !(a&1) ) + { /* status port */ + ret = FM_STATUS_FLAG(&F2203->OPN.ST); + } + else + { /* data port (only SSG) */ + if( addr < 16 ) ret = (*F2203->OPN.ST.SSG->read)(F2203->OPN.ST.device); + } + return ret; +} + +int ym2203_timer_over(void *chip,int c) +{ + ym2203_state *F2203 = (ym2203_state *)chip; + + if( c ) + { /* Timer B */ + TimerBOver( &(F2203->OPN.ST) ); + } + else + { /* Timer A */ + ym2203_device::update_request(F2203->OPN.ST.device); + /* timer update */ + TimerAOver( &(F2203->OPN.ST) ); + /* CSM mode key,TL control */ + if( F2203->OPN.ST.mode & 0x80 ) + { /* CSM mode auto key on */ + CSMKeyControll( F2203->OPN.type, &(F2203->CH[2]) ); + } + } + return F2203->OPN.ST.irq; +} +#endif /* BUILD_YM2203 */ + + + +#if (BUILD_YM2608||BUILD_YM2610||BUILD_YM2610B) + +namespace { +/**** YM2610 ADPCM defines ****/ +CONSTEXPR unsigned ADPCM_SHIFT = 16; /* frequency step rate */ +CONSTEXPR unsigned ADPCMA_ADDRESS_SHIFT = 8; /* adpcm A address shift */ + +/* speedup purposes only */ +static int jedi_table[ 49*16 ]; + +/* ADPCM type A channel struct */ +struct ADPCM_CH +{ + uint8_t flag; /* port state */ + uint8_t flagMask; /* arrived flag mask */ + uint8_t now_data; /* current ROM data */ + uint32_t now_addr; /* current ROM address */ + uint32_t now_step; + uint32_t step; + uint32_t start; /* sample data start address*/ + uint32_t end; /* sample data end address */ + uint8_t IL; /* Instrument Level */ + int32_t adpcm_acc; /* accumulator */ + int32_t adpcm_step; /* step */ + int32_t adpcm_out; /* (speedup) hiro-shi!! */ + int8_t vol_mul; /* volume in "0.75dB" steps */ + uint8_t vol_shift; /* volume in "-6dB" steps */ + int32_t *pan; /* &out_adpcm[OPN_xxxx] */ +}; + +/* here's the virtual YM2610 */ +struct ym2610_state +{ + uint8_t REGS[512]; /* registers */ + FM_OPN OPN; /* OPN state */ + FM_CH CH[6]; /* channel state */ + uint8_t addr_A1; /* address line A1 */ + + /* ADPCM-A unit */ + FM_READBYTE read_byte; + uint8_t adpcmTL; /* adpcmA total level */ + ADPCM_CH adpcm[6]; /* adpcm channels */ + uint32_t adpcmreg[0x30]; /* registers */ + uint8_t adpcm_arrivedEndAddress; + YM_DELTAT deltaT; /* Delta-T ADPCM unit */ + + uint8_t flagmask; /* YM2608 only */ + uint8_t irqmask; /* YM2608 only */ + + device_t *device; + + /* different from the usual ADPCM table */ + //static CONSTEXPR int step_inc[8] = { -1*16, -1*16, -1*16, -1*16, 2*16, 5*16, 7*16, 9*16 }; + static int step_inc[8]; + + /* ADPCM A (Non control type) : calculate one channel output */ + inline void ADPCMA_calc_chan( ADPCM_CH *ch ) + { + uint32_t step; + uint8_t data; + + + ch->now_step += ch->step; + if ( ch->now_step >= uint32_t(1<now_step >> ADPCM_SHIFT; + ch->now_step &= (1< instead of == */ + /* YM2610 checks lower 20 bits only, the 4 MSB bits are sample bank */ + /* Here we use 1<<21 to compensate for nibble calculations */ + + if ( (ch->now_addr & ((1<<21)-1)) == ((ch->end<<1) & ((1<<21)-1)) ) + { + ch->flag = 0; + adpcm_arrivedEndAddress |= ch->flagMask; + return; + } +#if 0 + if ( ch->now_addr > (pcmsizeA<<1) ) + { + LOG(LOG_WAR,("YM2610: Attempting to play past adpcm rom size!\n" )); + return; + } +#endif + if ( ch->now_addr&1 ) + data = ch->now_data & 0x0f; + else + { + ch->now_data = read_byte(device, ch->now_addr>>1); + data = (ch->now_data >> 4) & 0x0f; + } + + ch->now_addr++; + + ch->adpcm_acc += jedi_table[ch->adpcm_step + data]; + + /* extend 12-bit signed int */ + if (ch->adpcm_acc & ~0x7ff) + ch->adpcm_acc |= ~0xfff; + else + ch->adpcm_acc &= 0xfff; + + ch->adpcm_step += step_inc[data & 7]; + Limit( ch->adpcm_step, 48*16, 0*16 ); + + }while(--step); + + /* calc pcm * volume data */ + ch->adpcm_out = ((ch->adpcm_acc * ch->vol_mul) >> ch->vol_shift) & ~3; /* multiply, shift and mask out 2 LSB bits */ + } + + /* output for work of output channels (out_adpcm[OPNxxxx])*/ + *(ch->pan) += ch->adpcm_out; + } + + /* ADPCM type A Write */ + void FM_ADPCMAWrite(int r,int v) + { + uint8_t c = r&0x07; + + adpcmreg[r] = v&0xff; /* stock data */ + switch( r ) + { + case 0x00: /* DM,--,C5,C4,C3,C2,C1,C0 */ + if( !(v&0x80) ) + { + /* KEY ON */ + for( c = 0; c < 6; c++ ) + { + if( (v>>c)&1 ) + { + /**** start adpcm ****/ + adpcm[c].step = (uint32_t)((float)(1<>c)&1 ) + adpcm[c].flag = 0; + } + break; + case 0x01: /* B0-5 = TL */ + adpcmTL = (v & 0x3f) ^ 0x3f; + for( c = 0; c < 6; c++ ) + { + int volume = adpcmTL + adpcm[c].IL; + + if ( volume >= 63 ) /* This is correct, 63 = quiet */ + { + adpcm[c].vol_mul = 0; + adpcm[c].vol_shift = 0; + } + else + { + adpcm[c].vol_mul = 15 - (volume & 7); /* so called 0.75 dB */ + adpcm[c].vol_shift = 1 + (volume >> 3); /* Yamaha engineers used the approximation: each -6 dB is close to divide by two (shift right) */ + } + + /* calc pcm * volume data */ + adpcm[c].adpcm_out = ((adpcm[c].adpcm_acc * adpcm[c].vol_mul) >> adpcm[c].vol_shift) & ~3; /* multiply, shift and mask out low 2 bits */ + } + break; + default: + c = r&0x07; + if( c >= 0x06 ) return; + switch( r&0x38 ) + { + case 0x08: /* B7=L,B6=R, B4-0=IL */ + { + int volume; + + adpcm[c].IL = (v & 0x1f) ^ 0x1f; + + volume = adpcmTL + adpcm[c].IL; + + if ( volume >= 63 ) /* This is correct, 63 = quiet */ + { + adpcm[c].vol_mul = 0; + adpcm[c].vol_shift = 0; + } + else + { + adpcm[c].vol_mul = 15 - (volume & 7); /* so called 0.75 dB */ + adpcm[c].vol_shift = 1 + (volume >> 3); /* Yamaha engineers used the approximation: each -6 dB is close to divide by two (shift right) */ + } + + adpcm[c].pan = &OPN.out_adpcm[(v>>6)&0x03]; + + /* calc pcm * volume data */ + adpcm[c].adpcm_out = ((adpcm[c].adpcm_acc * adpcm[c].vol_mul) >> adpcm[c].vol_shift) & ~3; /* multiply, shift and mask out low 2 bits */ + } + break; + case 0x10: + case 0x18: + adpcm[c].start = ( (adpcmreg[0x18 + c]*0x0100 | adpcmreg[0x10 + c]) << ADPCMA_ADDRESS_SHIFT); + break; + case 0x20: + case 0x28: + adpcm[c].end = ( (adpcmreg[0x28 + c]*0x0100 | adpcmreg[0x20 + c]) << ADPCMA_ADDRESS_SHIFT); + adpcm[c].end += (1<save_item(NAME(adpcm->flag), ch); + device->save_item(NAME(adpcm->now_data), ch); + device->save_item(NAME(adpcm->now_addr), ch); + device->save_item(NAME(adpcm->now_step), ch); + device->save_item(NAME(adpcm->adpcm_acc), ch); + device->save_item(NAME(adpcm->adpcm_step), ch); + device->save_item(NAME(adpcm->adpcm_out), ch); + } +} +#endif /* MAME_EMU_SAVE_H */ +} // anonymous namespace + +#endif /* (BUILD_YM2608||BUILD_YM2610||BUILD_YM2610B) */ + + +#if BUILD_YM2608 +/*****************************************************************************/ +/* YM2608 local section */ +/*****************************************************************************/ + + + +static const unsigned int YM2608_ADPCM_ROM_addr[2*6] = { +0x0000, 0x01bf, /* bass drum */ +0x01c0, 0x043f, /* snare drum */ +0x0440, 0x1b7f, /* top cymbal */ +0x1b80, 0x1cff, /* high hat */ +0x1d00, 0x1f7f, /* tom tom */ +0x1f80, 0x1fff /* rim shot */ +}; + + +/* flag enable control 0x110 */ +static inline void YM2608IRQFlagWrite(FM_OPN *OPN, ym2608_state *F2608, int v) +{ + if( v & 0x80 ) + { /* Reset IRQ flag */ + FM_STATUS_RESET(&OPN->ST, 0xf7); /* don't touch BUFRDY flag otherwise we'd have to call ymdeltat module to set the flag back */ + } + else + { /* Set status flag mask */ + F2608->flagmask = (~(v&0x1f)); + FM_IRQMASK_SET(&OPN->ST, (F2608->irqmask & F2608->flagmask) ); + } +} + +/* compatible mode & IRQ enable control 0x29 */ +static inline void YM2608IRQMaskWrite(FM_OPN *OPN, ym2608_state *F2608, int v) +{ + /* SCH,xx,xxx,EN_ZERO,EN_BRDY,EN_EOS,EN_TB,EN_TA */ + + /* extend 3ch. enable/disable */ + if(v&0x80) + OPN->type |= TYPE_6CH; /* OPNA mode - 6 FM channels */ + else + OPN->type &= ~TYPE_6CH; /* OPN mode - 3 FM channels */ + + /* IRQ MASK store and set */ + F2608->irqmask = v&0x1f; + FM_IRQMASK_SET(&OPN->ST, (F2608->irqmask & F2608->flagmask) ); +} + +/* Generate samples for one of the YM2608s */ +void ym2608_update_one(void *chip, FMSAMPLE **buffer, int length) +{ + ym2608_state *F2608 = (ym2608_state *)chip; + FM_OPN *OPN = &F2608->OPN; + YM_DELTAT *DELTAT = &F2608->deltaT; + int i,j; + FMSAMPLE *bufL,*bufR; + FM_CH *cch[6]; + int32_t *out_fm = OPN->out_fm; + + /* set bufer */ + bufL = buffer[0]; + bufR = buffer[1]; + + cch[0] = &F2608->CH[0]; + cch[1] = &F2608->CH[1]; + cch[2] = &F2608->CH[2]; + cch[3] = &F2608->CH[3]; + cch[4] = &F2608->CH[4]; + cch[5] = &F2608->CH[5]; + + /* refresh PG and EG */ + refresh_fc_eg_chan( OPN, cch[0] ); + refresh_fc_eg_chan( OPN, cch[1] ); + if( (OPN->ST.mode & 0xc0) ) + { + /* 3SLOT MODE */ + if( cch[2]->SLOT[SLOT1].Incr==-1) + { + refresh_fc_eg_slot(OPN, &cch[2]->SLOT[SLOT1] , OPN->SL3.fc[1] , OPN->SL3.kcode[1] ); + refresh_fc_eg_slot(OPN, &cch[2]->SLOT[SLOT2] , OPN->SL3.fc[2] , OPN->SL3.kcode[2] ); + refresh_fc_eg_slot(OPN, &cch[2]->SLOT[SLOT3] , OPN->SL3.fc[0] , OPN->SL3.kcode[0] ); + refresh_fc_eg_slot(OPN, &cch[2]->SLOT[SLOT4] , cch[2]->fc , cch[2]->kcode ); + } + } + else + refresh_fc_eg_chan( OPN, cch[2] ); + refresh_fc_eg_chan( OPN, cch[3] ); + refresh_fc_eg_chan( OPN, cch[4] ); + refresh_fc_eg_chan( OPN, cch[5] ); + + + /* buffering */ + for(i=0; i < length ; i++) + { + advance_lfo(OPN); + + /* clear output acc. */ + OPN->out_adpcm[OUTD_LEFT] = OPN->out_adpcm[OUTD_RIGHT] = OPN->out_adpcm[OUTD_CENTER] = 0; + OPN->out_delta[OUTD_LEFT] = OPN->out_delta[OUTD_RIGHT] = OPN->out_delta[OUTD_CENTER] = 0; + /* clear outputs */ + out_fm[0] = 0; + out_fm[1] = 0; + out_fm[2] = 0; + out_fm[3] = 0; + out_fm[4] = 0; + out_fm[5] = 0; + + /* calculate FM */ + chan_calc(OPN, cch[0], 0 ); + chan_calc(OPN, cch[1], 1 ); + chan_calc(OPN, cch[2], 2 ); + chan_calc(OPN, cch[3], 3 ); + chan_calc(OPN, cch[4], 4 ); + chan_calc(OPN, cch[5], 5 ); + + /* deltaT ADPCM */ + if( DELTAT->portstate&0x80 ) + DELTAT->ADPCM_CALC(); + + /* ADPCMA */ + for( j = 0; j < 6; j++ ) + { + if( F2608->adpcm[j].flag ) + F2608->ADPCMA_calc_chan( &F2608->adpcm[j]); + } + + /* advance envelope generator */ + OPN->eg_timer += OPN->eg_timer_add; + while (OPN->eg_timer >= OPN->eg_timer_overflow) + { + OPN->eg_timer -= OPN->eg_timer_overflow; + OPN->eg_cnt++; + + advance_eg_channel(OPN, &cch[0]->SLOT[SLOT1]); + advance_eg_channel(OPN, &cch[1]->SLOT[SLOT1]); + advance_eg_channel(OPN, &cch[2]->SLOT[SLOT1]); + advance_eg_channel(OPN, &cch[3]->SLOT[SLOT1]); + advance_eg_channel(OPN, &cch[4]->SLOT[SLOT1]); + advance_eg_channel(OPN, &cch[5]->SLOT[SLOT1]); + } + + /* buffering */ + { + int lt,rt; + + lt = OPN->out_adpcm[OUTD_LEFT] + OPN->out_adpcm[OUTD_CENTER]; + rt = OPN->out_adpcm[OUTD_RIGHT] + OPN->out_adpcm[OUTD_CENTER]; + lt += (OPN->out_delta[OUTD_LEFT] + OPN->out_delta[OUTD_CENTER])>>9; + rt += (OPN->out_delta[OUTD_RIGHT] + OPN->out_delta[OUTD_CENTER])>>9; + + /* libOPNMIDI: 6-channels mixing */ +#define PANLAW_L(ch, chpan) (((out_fm[ch]>>1) * cch[ch]->pan_volume_l / 65535) & OPN->pan[chpan]); +#define PANLAW_R(ch, chpan) (((out_fm[ch]>>1) * cch[ch]->pan_volume_r / 65535) & OPN->pan[chpan]); + lt = PANLAW_L(0, 0); + rt = PANLAW_R(0, 1); + lt += PANLAW_L(1, 2); + rt += PANLAW_R(1, 3); + lt += PANLAW_L(2, 4); + rt += PANLAW_R(2, 5); + lt += PANLAW_L(3, 6); + rt += PANLAW_R(3, 7); + lt += PANLAW_L(4, 8); + rt += PANLAW_R(4, 9); + lt += PANLAW_L(5, 10); + rt += PANLAW_R(5, 11); +#undef PANLAW_L +#undef PANLAW_R + + lt >>= FINAL_SH; + rt >>= FINAL_SH; + + Limit( lt, MAXOUT, MINOUT ); + Limit( rt, MAXOUT, MINOUT ); + /* buffering */ + bufL[i] = lt; + bufR[i] = rt; + + #ifdef SAVE_SAMPLE + SAVE_ALL_CHANNELS + #endif + + } + + /* timer A control */ + INTERNAL_TIMER_A( &OPN->ST , cch[2] ) + } + INTERNAL_TIMER_B(&OPN->ST,length) + + + /* check IRQ for DELTA-T EOS */ + FM_STATUS_SET(&OPN->ST, 0); + +} +#ifdef MAME_EMU_SAVE_H +void ym2608_postload(void *chip) +{ + if (chip) + { + ym2608_state *F2608 = (ym2608_state *)chip; + int r; + + /* prescaler */ + OPNPrescaler_w(&F2608->OPN,1,2); + F2608->deltaT.freqbase = F2608->OPN.ST.freqbase; + /* IRQ mask / mode */ + YM2608IRQMaskWrite(&F2608->OPN, F2608, F2608->REGS[0x29]); + /* SSG registers */ + for(r=0;r<16;r++) + { + (*F2608->OPN.ST.SSG->write)(F2608->OPN.ST.device,0,r); + (*F2608->OPN.ST.SSG->write)(F2608->OPN.ST.device,1,F2608->REGS[r]); + } + + /* OPN registers */ + /* DT / MULTI , TL , KS / AR , AMON / DR , SR , SL / RR , SSG-EG */ + for(r=0x30;r<0x9e;r++) + if((r&3) != 3) + { + OPNWriteReg(&F2608->OPN,r,F2608->REGS[r]); + OPNWriteReg(&F2608->OPN,r|0x100,F2608->REGS[r|0x100]); + } + /* FB / CONNECT , L / R / AMS / PMS */ + for(r=0xb0;r<0xb6;r++) + if((r&3) != 3) + { + OPNWriteReg(&F2608->OPN,r,F2608->REGS[r]); + OPNWriteReg(&F2608->OPN,r|0x100,F2608->REGS[r|0x100]); + } + /* FM channels */ + /*FM_channel_postload(F2608->CH,6);*/ + /* rhythm(ADPCMA) */ + F2608->FM_ADPCMAWrite(1,F2608->REGS[0x111]); + for( r=0x08 ; r<0x0c ; r++) + F2608->FM_ADPCMAWrite(r,F2608->REGS[r+0x110]); + /* Delta-T ADPCM unit */ + F2608->deltaT.postload( &F2608->REGS[0x100] ); + } +} + +static void YM2608_save_state(ym2608_state *F2608, device_t *device) +{ + device->save_item(NAME(F2608->REGS)); + FMsave_state_st(device,&F2608->OPN.ST); + FMsave_state_channel(device,F2608->CH,6); + /* 3slots */ + device->save_item(NAME(F2608->OPN.SL3.fc)); + device->save_item(NAME(F2608->OPN.SL3.fn_h)); + device->save_item(NAME(F2608->OPN.SL3.kcode)); + /* address register1 */ + device->save_item(NAME(F2608->addr_A1)); + /* rhythm(ADPCMA) */ + FMsave_state_adpcma(device,F2608->adpcm); + /* Delta-T ADPCM unit */ + F2608->deltaT.savestate(device); +} +#endif /* MAME_EMU_SAVE_H */ + +static void YM2608_deltat_status_set(void *chip, uint8_t changebits) +{ + ym2608_state *F2608 = (ym2608_state *)chip; + FM_STATUS_SET(&(F2608->OPN.ST), changebits); +} +static void YM2608_deltat_status_reset(void *chip, uint8_t changebits) +{ + ym2608_state *F2608 = (ym2608_state *)chip; + FM_STATUS_RESET(&(F2608->OPN.ST), changebits); +} +/* YM2608(OPNA) */ +void * ym2608_init(device_t *device, int clock, int rate, + FM_READBYTE InternalReadByte, + FM_READBYTE ExternalReadByte, FM_WRITEBYTE ExternalWriteByte, + FM_TIMERHANDLER timer_handler,FM_IRQHANDLER IRQHandler, const ssg_callbacks *ssg) +{ + ym2608_state *F2608; + + /* allocate extend state space */ + F2608 = new ym2608_state; + memset(F2608, 0, sizeof(*F2608)); + /* allocate total level table (128kb space) */ + if( !init_tables() ) + { + delete F2608; + return NULLPTR; + } + + F2608->device = device; + F2608->OPN.type = TYPE_YM2608; + F2608->OPN.P_CH = F2608->CH; + F2608->OPN.ST.device = device; + F2608->OPN.ST.clock = clock; + F2608->OPN.ST.rate = rate; + + /* External handlers */ + F2608->OPN.ST.timer_handler = timer_handler; + F2608->OPN.ST.IRQ_Handler = IRQHandler; + F2608->OPN.ST.SSG = ssg; + + /* DELTA-T */ + F2608->deltaT.read_byte = ExternalReadByte; + F2608->deltaT.write_byte = ExternalWriteByte; + + /*F2608->deltaT.write_time = 20.0 / clock;*/ /* a single byte write takes 20 cycles of main clock */ + /*F2608->deltaT.read_time = 18.0 / clock;*/ /* a single byte read takes 18 cycles of main clock */ + + F2608->deltaT.status_set_handler = YM2608_deltat_status_set; + F2608->deltaT.status_reset_handler = YM2608_deltat_status_reset; + F2608->deltaT.status_change_which_chip = F2608; + F2608->deltaT.status_change_EOS_bit = 0x04; /* status flag: set bit2 on End Of Sample */ + F2608->deltaT.status_change_BRDY_bit = 0x08; /* status flag: set bit3 on BRDY */ + F2608->deltaT.status_change_ZERO_bit = 0x10; /* status flag: set bit4 if silence continues for more than 290 milliseconds while recording the ADPCM */ + + /* ADPCM Rhythm */ + F2608->read_byte = InternalReadByte; + + Init_ADPCMATable(); + + for (unsigned i = 0; i < 6; i++) + { + F2608->CH[i].pan_volume_l = 46340; + F2608->CH[i].pan_volume_r = 46340; + } + +#ifdef MAME_EMU_SAVE_H + YM2608_save_state(F2608, device); +#endif + return F2608; +} + +void ym2608_clock_changed(void *chip, int clock, int rate) +{ + ym2608_state *F2608 = (ym2608_state *)chip; + + F2608->OPN.ST.clock = clock; + F2608->OPN.ST.rate = rate; +} + +/* shut down emulator */ +void ym2608_shutdown(void *chip) +{ + ym2608_state *F2608 = (ym2608_state *)chip; + + FMCloseTable(); + delete F2608; +} + +/* reset one of chips */ +void ym2608_reset_chip(void *chip) +{ + int i; + ym2608_state *F2608 = (ym2608_state *)chip; + FM_OPN *OPN = &F2608->OPN; + YM_DELTAT *DELTAT = &F2608->deltaT; + + /* Reset Prescaler */ + OPNPrescaler_w(OPN , 0 , 2); + F2608->deltaT.freqbase = OPN->ST.freqbase; + /* reset SSG section */ + (*OPN->ST.SSG->reset)(OPN->ST.device); + + /* status clear */ + FM_BUSY_CLEAR(&OPN->ST); + + /* register 0x29 - default value after reset is: + enable only 3 FM channels and enable all the status flags */ + YM2608IRQMaskWrite(OPN, F2608, 0x1f ); /* default value for D4-D0 is 1 */ + + /* register 0x10, A1=1 - default value is 1 for D4, D3, D2, 0 for the rest */ + YM2608IRQFlagWrite(OPN, F2608, 0x1c ); /* default: enable timer A and B, disable EOS, BRDY and ZERO */ + + OPNWriteMode(OPN,0x27,0x30); /* mode 0 , timer reset */ + + OPN->eg_timer = 0; + OPN->eg_cnt = 0; + + FM_STATUS_RESET(&OPN->ST, 0xff); + + reset_channels( &OPN->ST , F2608->CH , 6 ); + /* reset OPerator paramater */ + for(i = 0xb6 ; i >= 0xb4 ; i-- ) + { + OPNWriteReg(OPN,i ,0xc0); + OPNWriteReg(OPN,i|0x100,0xc0); + } + for(i = 0xb2 ; i >= 0x30 ; i-- ) + { + OPNWriteReg(OPN,i ,0); + OPNWriteReg(OPN,i|0x100,0); + } + for(i = 0x26 ; i >= 0x20 ; i-- ) OPNWriteReg(OPN,i,0); + + /* ADPCM - percussion sounds */ + for( i = 0; i < 6; i++ ) + { + if (i<=3) /* channels 0,1,2,3 */ + F2608->adpcm[i].step = (uint32_t)((float)(1<OPN.ST.freqbase)/3.0f); + else /* channels 4 and 5 work with slower clock */ + F2608->adpcm[i].step = (uint32_t)((float)(1<OPN.ST.freqbase)/6.0f); + + F2608->adpcm[i].start = YM2608_ADPCM_ROM_addr[i*2]; + F2608->adpcm[i].end = YM2608_ADPCM_ROM_addr[i*2+1]; + + F2608->adpcm[i].now_addr = 0; + F2608->adpcm[i].now_step = 0; + /* F2608->adpcm[i].delta = 21866; */ + F2608->adpcm[i].vol_mul = 0; + F2608->adpcm[i].pan = &OPN->out_adpcm[OUTD_CENTER]; /* default center */ + F2608->adpcm[i].flagMask = 0; + F2608->adpcm[i].flag = 0; + F2608->adpcm[i].adpcm_acc = 0; + F2608->adpcm[i].adpcm_step= 0; + F2608->adpcm[i].adpcm_out = 0; + } + F2608->adpcmTL = 0x3f; + + F2608->adpcm_arrivedEndAddress = 0; /* not used */ + + /* DELTA-T unit */ + DELTAT->freqbase = OPN->ST.freqbase; + DELTAT->output_pointer = OPN->out_delta; + DELTAT->portshift = 5; /* always 5bits shift */ /* ASG */ + DELTAT->output_range = 1<<23; + DELTAT->ADPCM_Reset(OUTD_CENTER,YM_DELTAT::EMULATION_MODE_NORMAL,F2608->device); +} + +/* YM2608 write */ +/* n = number */ +/* a = address */ +/* v = value */ +int ym2608_write(void *chip, int a,uint8_t v) +{ + ym2608_state *F2608 = (ym2608_state *)chip; + FM_OPN *OPN = &F2608->OPN; + int addr; + + v &= 0xff; /*adjust to 8 bit bus */ + + + switch(a&3) + { + case 0: /* address port 0 */ + OPN->ST.address = v; + F2608->addr_A1 = 0; + + /* Write register to SSG emulator */ + if( v < 16 ) (*OPN->ST.SSG->write)(OPN->ST.device,0,v); + /* prescaler selecter : 2d,2e,2f */ + if( v >= 0x2d && v <= 0x2f ) + { + OPNPrescaler_w(OPN , v , 2); + F2608->deltaT.freqbase = OPN->ST.freqbase; + } + break; + + case 1: /* data port 0 */ + if (F2608->addr_A1 != 0) + break; /* verified on real YM2608 */ + + addr = OPN->ST.address; + F2608->REGS[addr] = v; + switch(addr & 0xf0) + { + case 0x00: /* SSG section */ + /* Write data to SSG emulator */ + (*OPN->ST.SSG->write)(OPN->ST.device,a,v); + break; + case 0x10: /* 0x10-0x1f : Rhythm section */ + ym2608_device::update_request(OPN->ST.device); + F2608->FM_ADPCMAWrite(addr-0x10,v); + break; + case 0x20: /* Mode Register */ + switch(addr) + { + case 0x29: /* SCH,xx,xxx,EN_ZERO,EN_BRDY,EN_EOS,EN_TB,EN_TA */ + YM2608IRQMaskWrite(OPN, F2608, v); + break; + default: + ym2608_device::update_request(OPN->ST.device); + OPNWriteMode(OPN,addr,v); + } + break; + default: /* OPN section */ + ym2608_device::update_request(OPN->ST.device); + OPNWriteReg(OPN,addr,v); + } + break; + + case 2: /* address port 1 */ + OPN->ST.address = v; + F2608->addr_A1 = 1; + break; + + case 3: /* data port 1 */ + if (F2608->addr_A1 != 1) + break; /* verified on real YM2608 */ + + addr = OPN->ST.address; + F2608->REGS[addr | 0x100] = v; + ym2608_device::update_request(OPN->ST.device); + switch( addr & 0xf0 ) + { + case 0x00: /* DELTAT PORT */ + switch( addr ) + { + case 0x0e: /* DAC data */ + F2608->device->logerror("YM2608: write to DAC data (unimplemented) value=%02x\n",v); + break; + default: + /* 0x00-0x0d */ + F2608->deltaT.ADPCM_Write(addr,v); + } + break; + case 0x10: /* IRQ Flag control */ + if( addr == 0x10 ) + { + YM2608IRQFlagWrite(OPN, F2608, v); + } + break; + default: + OPNWriteReg(OPN,addr | 0x100,v); + } + } + return OPN->ST.irq; +} + +// libOPNMIDI: soft panning +void ym2608_write_pan(void *chip, int c, unsigned char v) +{ + ym2608_state *F2608 = (ym2608_state *)chip; + assert((c >= 0) && (c < 6)); + F2608->CH[c].pan_volume_l = panlawtable[v & 0x7F]; + F2608->CH[c].pan_volume_r = panlawtable[0x7F - (v & 0x7F)]; +} + +uint8_t ym2608_read(void *chip,int a) +{ + ym2608_state *F2608 = (ym2608_state *)chip; + int addr = F2608->OPN.ST.address; + uint8_t ret = 0; + + switch( a&3 ) + { + case 0: /* status 0 : YM2203 compatible */ + /* BUSY:x:x:x:x:x:FLAGB:FLAGA */ + ret = FM_STATUS_FLAG(&F2608->OPN.ST) & 0x83; + break; + + case 1: /* status 0, ID */ + if( addr < 16 ) ret = (*F2608->OPN.ST.SSG->read)(F2608->OPN.ST.device); + else if(addr == 0xff) ret = 0x01; /* ID code */ + break; + + case 2: /* status 1 : status 0 + ADPCM status */ + /* BUSY : x : PCMBUSY : ZERO : BRDY : EOS : FLAGB : FLAGA */ + ret = (FM_STATUS_FLAG(&F2608->OPN.ST) & (F2608->flagmask|0x80)) | ((F2608->deltaT.PCM_BSY & 1)<<5) ; + break; + + case 3: + if(addr == 0x08) + { + ret = F2608->deltaT.ADPCM_Read(); + } + else + { + if(addr == 0x0f) + { + F2608->device->logerror("YM2608 A/D conversion is accessed but not implemented !\n"); + ret = 0x80; /* 2's complement PCM data - result from A/D conversion */ + } + } + break; + } + return ret; +} + +int ym2608_timer_over(void *chip,int c) +{ + ym2608_state *F2608 = (ym2608_state *)chip; + + switch(c) + { +#if 0 + case 2: + { /* BUFRDY flag */ + F2608->deltaT.BRDY_callback(); + } + break; +#endif + case 1: + { /* Timer B */ + TimerBOver( &(F2608->OPN.ST) ); + } + break; + case 0: + { /* Timer A */ + ym2608_device::update_request(F2608->OPN.ST.device); + /* timer update */ + TimerAOver( &(F2608->OPN.ST) ); + /* CSM mode key,TL controll */ + if( F2608->OPN.ST.mode & 0x80 ) + { /* CSM mode total level latch and auto key on */ + CSMKeyControll( F2608->OPN.type, &(F2608->CH[2]) ); + } + } + break; + default: + break; + } + + return F2608->OPN.ST.irq; +} + +#endif /* BUILD_YM2608 */ + + + +#if (BUILD_YM2610||BUILD_YM2610B) +/* YM2610(OPNB) */ + +/* Generate samples for one of the YM2610s */ +void ym2610_update_one(void *chip, FMSAMPLE **buffer, int length) +{ + ym2610_state *F2610 = (ym2610_state *)chip; + FM_OPN *OPN = &F2610->OPN; + YM_DELTAT *DELTAT = &F2610->deltaT; + int i,j; + FMSAMPLE *bufL,*bufR; + FM_CH *cch[4]; + int32_t *out_fm = OPN->out_fm; + + /* buffer setup */ + bufL = buffer[0]; + bufR = buffer[1]; + + cch[0] = &F2610->CH[1]; + cch[1] = &F2610->CH[2]; + cch[2] = &F2610->CH[4]; + cch[3] = &F2610->CH[5]; + +#ifdef YM2610B_WARNING +#define FM_KEY_IS(SLOT) ((SLOT)->key) +#define FM_MSG_YM2610B "YM2610-%p.CH%d is playing,Check whether the type of the chip is YM2610B\n" + /* Check YM2610B warning message */ + if( FM_KEY_IS(&F2610->CH[0].SLOT[3]) ) + LOG(F2610->device,LOG_WAR,(FM_MSG_YM2610B,F2610->OPN.ST.device,0)); + if( FM_KEY_IS(&F2610->CH[3].SLOT[3]) ) + LOG(F2610->device,LOG_WAR,(FM_MSG_YM2610B,F2610->OPN.ST.device,3)); +#endif + + /* refresh PG and EG */ + refresh_fc_eg_chan( OPN, cch[0] ); + if( (OPN->ST.mode & 0xc0) ) + { + /* 3SLOT MODE */ + if( cch[1]->SLOT[SLOT1].Incr==-1) + { + refresh_fc_eg_slot(OPN, &cch[1]->SLOT[SLOT1] , OPN->SL3.fc[1] , OPN->SL3.kcode[1] ); + refresh_fc_eg_slot(OPN, &cch[1]->SLOT[SLOT2] , OPN->SL3.fc[2] , OPN->SL3.kcode[2] ); + refresh_fc_eg_slot(OPN, &cch[1]->SLOT[SLOT3] , OPN->SL3.fc[0] , OPN->SL3.kcode[0] ); + refresh_fc_eg_slot(OPN, &cch[1]->SLOT[SLOT4] , cch[1]->fc , cch[1]->kcode ); + } + } + else + refresh_fc_eg_chan( OPN, cch[1] ); + refresh_fc_eg_chan( OPN, cch[2] ); + refresh_fc_eg_chan( OPN, cch[3] ); + + /* buffering */ + for(i=0; i < length ; i++) + { + advance_lfo(OPN); + + /* clear output acc. */ + OPN->out_adpcm[OUTD_LEFT] = OPN->out_adpcm[OUTD_RIGHT] = OPN->out_adpcm[OUTD_CENTER] = 0; + OPN->out_delta[OUTD_LEFT] = OPN->out_delta[OUTD_RIGHT] = OPN->out_delta[OUTD_CENTER] = 0; + /* clear outputs */ + out_fm[1] = 0; + out_fm[2] = 0; + out_fm[4] = 0; + out_fm[5] = 0; + + /* advance envelope generator */ + OPN->eg_timer += OPN->eg_timer_add; + while (OPN->eg_timer >= OPN->eg_timer_overflow) + { + OPN->eg_timer -= OPN->eg_timer_overflow; + OPN->eg_cnt++; + + advance_eg_channel(OPN, &cch[0]->SLOT[SLOT1]); + advance_eg_channel(OPN, &cch[1]->SLOT[SLOT1]); + advance_eg_channel(OPN, &cch[2]->SLOT[SLOT1]); + advance_eg_channel(OPN, &cch[3]->SLOT[SLOT1]); + } + + /* calculate FM */ + chan_calc(OPN, cch[0], 1 ); /*remapped to 1*/ + chan_calc(OPN, cch[1], 2 ); /*remapped to 2*/ + chan_calc(OPN, cch[2], 4 ); /*remapped to 4*/ + chan_calc(OPN, cch[3], 5 ); /*remapped to 5*/ + + /* deltaT ADPCM */ + if( DELTAT->portstate&0x80 ) + DELTAT->ADPCM_CALC(); + + /* ADPCMA */ + for( j = 0; j < 6; j++ ) + { + if( F2610->adpcm[j].flag ) + F2610->ADPCMA_calc_chan(&F2610->adpcm[j]); + } + + /* buffering */ + { + int lt,rt; + + lt = OPN->out_adpcm[OUTD_LEFT] + OPN->out_adpcm[OUTD_CENTER]; + rt = OPN->out_adpcm[OUTD_RIGHT] + OPN->out_adpcm[OUTD_CENTER]; + lt += (OPN->out_delta[OUTD_LEFT] + OPN->out_delta[OUTD_CENTER])>>9; + rt += (OPN->out_delta[OUTD_RIGHT] + OPN->out_delta[OUTD_CENTER])>>9; + + + lt += ((out_fm[1]>>1) & OPN->pan[2]); /* the shift right was verified on real chip */ + rt += ((out_fm[1]>>1) & OPN->pan[3]); + lt += ((out_fm[2]>>1) & OPN->pan[4]); + rt += ((out_fm[2]>>1) & OPN->pan[5]); + + lt += ((out_fm[4]>>1) & OPN->pan[8]); + rt += ((out_fm[4]>>1) & OPN->pan[9]); + lt += ((out_fm[5]>>1) & OPN->pan[10]); + rt += ((out_fm[5]>>1) & OPN->pan[11]); + + + lt >>= FINAL_SH; + rt >>= FINAL_SH; + + Limit( lt, MAXOUT, MINOUT ); + Limit( rt, MAXOUT, MINOUT ); + + #ifdef SAVE_SAMPLE + SAVE_ALL_CHANNELS + #endif + + /* buffering */ + bufL[i] = lt; + bufR[i] = rt; + } + + /* timer A control */ + INTERNAL_TIMER_A( &OPN->ST , cch[1] ) + } + INTERNAL_TIMER_B(&OPN->ST,length) + +} + +#if BUILD_YM2610B +/* Generate samples for one of the YM2610Bs */ +void ym2610b_update_one(void *chip, FMSAMPLE **buffer, int length) +{ + ym2610_state *F2610 = (ym2610_state *)chip; + FM_OPN *OPN = &F2610->OPN; + YM_DELTAT *DELTAT = &F2610->deltaT; + int i,j; + FMSAMPLE *bufL,*bufR; + FM_CH *cch[6]; + int32_t *out_fm = OPN->out_fm; + + /* buffer setup */ + bufL = buffer[0]; + bufR = buffer[1]; + + cch[0] = &F2610->CH[0]; + cch[1] = &F2610->CH[1]; + cch[2] = &F2610->CH[2]; + cch[3] = &F2610->CH[3]; + cch[4] = &F2610->CH[4]; + cch[5] = &F2610->CH[5]; + + /* refresh PG and EG */ + refresh_fc_eg_chan( OPN, cch[0] ); + refresh_fc_eg_chan( OPN, cch[1] ); + if( (OPN->ST.mode & 0xc0) ) + { + /* 3SLOT MODE */ + if( cch[2]->SLOT[SLOT1].Incr==-1) + { + refresh_fc_eg_slot(OPN, &cch[2]->SLOT[SLOT1] , OPN->SL3.fc[1] , OPN->SL3.kcode[1] ); + refresh_fc_eg_slot(OPN, &cch[2]->SLOT[SLOT2] , OPN->SL3.fc[2] , OPN->SL3.kcode[2] ); + refresh_fc_eg_slot(OPN, &cch[2]->SLOT[SLOT3] , OPN->SL3.fc[0] , OPN->SL3.kcode[0] ); + refresh_fc_eg_slot(OPN, &cch[2]->SLOT[SLOT4] , cch[2]->fc , cch[2]->kcode ); + } + } + else + refresh_fc_eg_chan( OPN, cch[2] ); + refresh_fc_eg_chan( OPN, cch[3] ); + refresh_fc_eg_chan( OPN, cch[4] ); + refresh_fc_eg_chan( OPN, cch[5] ); + + /* buffering */ + for(i=0; i < length ; i++) + { + advance_lfo(OPN); + + /* clear output acc. */ + OPN->out_adpcm[OUTD_LEFT] = OPN->out_adpcm[OUTD_RIGHT] = OPN->out_adpcm[OUTD_CENTER] = 0; + OPN->out_delta[OUTD_LEFT] = OPN->out_delta[OUTD_RIGHT] = OPN->out_delta[OUTD_CENTER] = 0; + /* clear outputs */ + out_fm[0] = 0; + out_fm[1] = 0; + out_fm[2] = 0; + out_fm[3] = 0; + out_fm[4] = 0; + out_fm[5] = 0; + + /* advance envelope generator */ + OPN->eg_timer += OPN->eg_timer_add; + while (OPN->eg_timer >= OPN->eg_timer_overflow) + { + OPN->eg_timer -= OPN->eg_timer_overflow; + OPN->eg_cnt++; + + advance_eg_channel(OPN, &cch[0]->SLOT[SLOT1]); + advance_eg_channel(OPN, &cch[1]->SLOT[SLOT1]); + advance_eg_channel(OPN, &cch[2]->SLOT[SLOT1]); + advance_eg_channel(OPN, &cch[3]->SLOT[SLOT1]); + advance_eg_channel(OPN, &cch[4]->SLOT[SLOT1]); + advance_eg_channel(OPN, &cch[5]->SLOT[SLOT1]); + } + + /* calculate FM */ + chan_calc(OPN, cch[0], 0 ); + chan_calc(OPN, cch[1], 1 ); + chan_calc(OPN, cch[2], 2 ); + chan_calc(OPN, cch[3], 3 ); + chan_calc(OPN, cch[4], 4 ); + chan_calc(OPN, cch[5], 5 ); + + /* deltaT ADPCM */ + if( DELTAT->portstate&0x80 ) + DELTAT->ADPCM_CALC(); + + /* ADPCMA */ + for( j = 0; j < 6; j++ ) + { + if( F2610->adpcm[j].flag ) + F2610->ADPCMA_calc_chan(&F2610->adpcm[j]); + } + + /* buffering */ + { + int lt,rt; + + lt = OPN->out_adpcm[OUTD_LEFT] + OPN->out_adpcm[OUTD_CENTER]; + rt = OPN->out_adpcm[OUTD_RIGHT] + OPN->out_adpcm[OUTD_CENTER]; + lt += (OPN->out_delta[OUTD_LEFT] + OPN->out_delta[OUTD_CENTER])>>9; + rt += (OPN->out_delta[OUTD_RIGHT] + OPN->out_delta[OUTD_CENTER])>>9; + + lt += ((out_fm[0]>>1) & OPN->pan[0]); /* the shift right is verified on YM2610 */ + rt += ((out_fm[0]>>1) & OPN->pan[1]); + lt += ((out_fm[1]>>1) & OPN->pan[2]); + rt += ((out_fm[1]>>1) & OPN->pan[3]); + lt += ((out_fm[2]>>1) & OPN->pan[4]); + rt += ((out_fm[2]>>1) & OPN->pan[5]); + lt += ((out_fm[3]>>1) & OPN->pan[6]); + rt += ((out_fm[3]>>1) & OPN->pan[7]); + lt += ((out_fm[4]>>1) & OPN->pan[8]); + rt += ((out_fm[4]>>1) & OPN->pan[9]); + lt += ((out_fm[5]>>1) & OPN->pan[10]); + rt += ((out_fm[5]>>1) & OPN->pan[11]); + + + lt >>= FINAL_SH; + rt >>= FINAL_SH; + + Limit( lt, MAXOUT, MINOUT ); + Limit( rt, MAXOUT, MINOUT ); + + #ifdef SAVE_SAMPLE + SAVE_ALL_CHANNELS + #endif + + /* buffering */ + bufL[i] = lt; + bufR[i] = rt; + } + + /* timer A control */ + INTERNAL_TIMER_A( &OPN->ST , cch[2] ) + } + INTERNAL_TIMER_B(&OPN->ST,length) + +} +#endif /* BUILD_YM2610B */ + + +#ifdef MAME_EMU_SAVE_H +void ym2610_postload(void *chip) +{ + if (chip) + { + ym2610_state *F2610 = (ym2610_state *)chip; + int r; + + /* SSG registers */ + for(r=0;r<16;r++) + { + (*F2610->OPN.ST.SSG->write)(F2610->OPN.ST.device,0,r); + (*F2610->OPN.ST.SSG->write)(F2610->OPN.ST.device,1,F2610->REGS[r]); + } + + /* OPN registers */ + /* DT / MULTI , TL , KS / AR , AMON / DR , SR , SL / RR , SSG-EG */ + for(r=0x30;r<0x9e;r++) + if((r&3) != 3) + { + OPNWriteReg(&F2610->OPN,r,F2610->REGS[r]); + OPNWriteReg(&F2610->OPN,r|0x100,F2610->REGS[r|0x100]); + } + /* FB / CONNECT , L / R / AMS / PMS */ + for(r=0xb0;r<0xb6;r++) + if((r&3) != 3) + { + OPNWriteReg(&F2610->OPN,r,F2610->REGS[r]); + OPNWriteReg(&F2610->OPN,r|0x100,F2610->REGS[r|0x100]); + } + /* FM channels */ + /*FM_channel_postload(F2610->CH,6);*/ + + /* rhythm(ADPCMA) */ + F2610->FM_ADPCMAWrite(1,F2610->REGS[0x101]); + for( r=0 ; r<6 ; r++) + { + F2610->FM_ADPCMAWrite(r+0x08,F2610->REGS[r+0x108]); + F2610->FM_ADPCMAWrite(r+0x10,F2610->REGS[r+0x110]); + F2610->FM_ADPCMAWrite(r+0x18,F2610->REGS[r+0x118]); + F2610->FM_ADPCMAWrite(r+0x20,F2610->REGS[r+0x120]); + F2610->FM_ADPCMAWrite(r+0x28,F2610->REGS[r+0x128]); + } + /* Delta-T ADPCM unit */ + F2610->deltaT.postload( &F2610->REGS[0x010] ); + } +} + +static void YM2610_save_state(ym2610_state *F2610, device_t *device) +{ + device->save_item(NAME(F2610->REGS)); + FMsave_state_st(device,&F2610->OPN.ST); + FMsave_state_channel(device,F2610->CH,6); + /* 3slots */ + device->save_item(NAME(F2610->OPN.SL3.fc)); + device->save_item(NAME(F2610->OPN.SL3.fn_h)); + device->save_item(NAME(F2610->OPN.SL3.kcode)); + /* address register1 */ + device->save_item(NAME(F2610->addr_A1)); + + device->save_item(NAME(F2610->adpcm_arrivedEndAddress)); + /* rhythm(ADPCMA) */ + FMsave_state_adpcma(device,F2610->adpcm); + /* Delta-T ADPCM unit */ + F2610->deltaT.savestate(device); +} +#endif /* MAME_EMU_SAVE_H */ + +static void YM2610_deltat_status_set(void *chip, uint8_t changebits) +{ + ym2610_state *F2610 = (ym2610_state *)chip; + F2610->adpcm_arrivedEndAddress |= changebits; +} +static void YM2610_deltat_status_reset(void *chip, uint8_t changebits) +{ + ym2610_state *F2610 = (ym2610_state *)chip; + F2610->adpcm_arrivedEndAddress &= (~changebits); +} + +void *ym2610_init(device_t *device, int clock, int rate, + FM_READBYTE adpcm_a_read_byte, FM_READBYTE adpcm_b_read_byte, + FM_TIMERHANDLER timer_handler,FM_IRQHANDLER IRQHandler, const ssg_callbacks *ssg) +{ + ym2610_state *F2610; + + /* allocate extend state space */ + F2610 = new ym2610_state; + memset(F2610, 0, sizeof(*F2610)); + /* allocate total level table (128kb space) */ + if( !init_tables() ) + { + delete F2610; + return nullptr; + } + + F2610->device = device; + /* FM */ + F2610->OPN.type = TYPE_YM2610; + F2610->OPN.P_CH = F2610->CH; + F2610->OPN.ST.device = device; + F2610->OPN.ST.clock = clock; + F2610->OPN.ST.rate = rate; + /* Extend handler */ + F2610->OPN.ST.timer_handler = timer_handler; + F2610->OPN.ST.IRQ_Handler = IRQHandler; + F2610->OPN.ST.SSG = ssg; + /* ADPCM */ + F2610->read_byte = adpcm_a_read_byte; + /* DELTA-T */ + F2610->deltaT.read_byte = adpcm_b_read_byte; + F2610->deltaT.write_byte = nullptr; + + F2610->deltaT.status_set_handler = YM2610_deltat_status_set; + F2610->deltaT.status_reset_handler = YM2610_deltat_status_reset; + F2610->deltaT.status_change_which_chip = F2610; + F2610->deltaT.status_change_EOS_bit = 0x80; /* status flag: set bit7 on End Of Sample */ + + Init_ADPCMATable(); + + for (unsigned i = 0; i < 6; i++) + { + F2610->CH[i].pan_volume_l = 46340; + F2610->CH[i].pan_volume_r = 46340; + } + +#ifdef MAME_EMU_SAVE_H + YM2610_save_state(F2610, device); +#endif + return F2610; +} + +void ym2610_clock_changed(void *chip, int clock, int rate) +{ + ym2610_state *F2610 = (ym2610_state *)chip; + + F2610->OPN.ST.clock = clock; + F2610->OPN.ST.rate = rate; +} + +/* shut down emulator */ +void ym2610_shutdown(void *chip) +{ + ym2610_state *F2610 = (ym2610_state *)chip; + + FMCloseTable(); + delete F2610; +} + +/* reset one of chip */ +void ym2610_reset_chip(void *chip) +{ + int i; + ym2610_state *F2610 = (ym2610_state *)chip; + FM_OPN *OPN = &F2610->OPN; + YM_DELTAT *DELTAT = &F2610->deltaT; + + device_t* dev = F2610->OPN.ST.device; + std::string name(dev->tag()); + + /* Reset Prescaler */ + OPNSetPres( OPN, 6*24, 6*24, 4*2); /* OPN 1/6 , SSG 1/4 */ + /* reset SSG section */ + (*OPN->ST.SSG->reset)(OPN->ST.device); + /* status clear */ + FM_IRQMASK_SET(&OPN->ST,0x03); + FM_BUSY_CLEAR(&OPN->ST); + OPNWriteMode(OPN,0x27,0x30); /* mode 0 , timer reset */ + + OPN->eg_timer = 0; + OPN->eg_cnt = 0; + + FM_STATUS_RESET(&OPN->ST, 0xff); + + reset_channels( &OPN->ST , F2610->CH , 6 ); + /* reset OPerator paramater */ + for(i = 0xb6 ; i >= 0xb4 ; i-- ) + { + OPNWriteReg(OPN,i ,0xc0); + OPNWriteReg(OPN,i|0x100,0xc0); + } + for(i = 0xb2 ; i >= 0x30 ; i-- ) + { + OPNWriteReg(OPN,i ,0); + OPNWriteReg(OPN,i|0x100,0); + } + for(i = 0x26 ; i >= 0x20 ; i-- ) OPNWriteReg(OPN,i,0); + /**** ADPCM work initial ****/ + for( i = 0; i < 6 ; i++ ) + { + F2610->adpcm[i].step = (uint32_t)((float)(1<OPN.ST.freqbase)/3.0f); + F2610->adpcm[i].now_addr = 0; + F2610->adpcm[i].now_step = 0; + F2610->adpcm[i].start = 0; + F2610->adpcm[i].end = 0; + /* F2610->adpcm[i].delta = 21866; */ + F2610->adpcm[i].vol_mul = 0; + F2610->adpcm[i].pan = &OPN->out_adpcm[OUTD_CENTER]; /* default center */ + F2610->adpcm[i].flagMask = 1<adpcm[i].flag = 0; + F2610->adpcm[i].adpcm_acc = 0; + F2610->adpcm[i].adpcm_step= 0; + F2610->adpcm[i].adpcm_out = 0; + } + F2610->adpcmTL = 0x3f; + + F2610->adpcm_arrivedEndAddress = 0; + + /* DELTA-T unit */ + DELTAT->freqbase = OPN->ST.freqbase; + DELTAT->output_pointer = OPN->out_delta; + DELTAT->portshift = 8; /* allways 8bits shift */ + DELTAT->output_range = 1<<23; + DELTAT->ADPCM_Reset(OUTD_CENTER,YM_DELTAT::EMULATION_MODE_YM2610,F2610->device); +} + +/* YM2610 write */ +/* n = number */ +/* a = address */ +/* v = value */ +int ym2610_write(void *chip, int a, uint8_t v) +{ + ym2610_state *F2610 = (ym2610_state *)chip; + FM_OPN *OPN = &F2610->OPN; + int addr; + int ch; + + v &= 0xff; /* adjust to 8 bit bus */ + + switch( a&3 ) + { + case 0: /* address port 0 */ + OPN->ST.address = v; + F2610->addr_A1 = 0; + + /* Write register to SSG emulator */ + if( v < 16 ) (*OPN->ST.SSG->write)(OPN->ST.device,0,v); + break; + + case 1: /* data port 0 */ + if (F2610->addr_A1 != 0) + break; /* verified on real YM2608 */ + + addr = OPN->ST.address; + F2610->REGS[addr] = v; + switch(addr & 0xf0) + { + case 0x00: /* SSG section */ + /* Write data to SSG emulator */ + (*OPN->ST.SSG->write)(OPN->ST.device,a,v); + break; + case 0x10: /* DeltaT ADPCM */ + ym2610_device::update_request(OPN->ST.device); + + switch(addr) + { + case 0x10: /* control 1 */ + case 0x11: /* control 2 */ + case 0x12: /* start address L */ + case 0x13: /* start address H */ + case 0x14: /* stop address L */ + case 0x15: /* stop address H */ + + case 0x19: /* delta-n L */ + case 0x1a: /* delta-n H */ + case 0x1b: /* volume */ + { + F2610->deltaT.ADPCM_Write(addr-0x10,v); + } + break; + + case 0x1c: /* FLAG CONTROL : Extend Status Clear/Mask */ + { + uint8_t statusmask = ~v; + /* set arrived flag mask */ + for(ch=0;ch<6;ch++) + F2610->adpcm[ch].flagMask = statusmask&(1<deltaT.status_change_EOS_bit = statusmask & 0x80; /* status flag: set bit7 on End Of Sample */ + + /* clear arrived flag */ + F2610->adpcm_arrivedEndAddress &= statusmask; + } + break; + + default: + F2610->device->logerror("YM2610: write to unknown deltat register %02x val=%02x\n",addr,v); + break; + } + + break; + case 0x20: /* Mode Register */ + ym2610_device::update_request(OPN->ST.device); + OPNWriteMode(OPN,addr,v); + break; + default: /* OPN section */ + ym2610_device::update_request(OPN->ST.device); + /* write register */ + OPNWriteReg(OPN,addr,v); + } + break; + + case 2: /* address port 1 */ + OPN->ST.address = v; + F2610->addr_A1 = 1; + break; + + case 3: /* data port 1 */ + if (F2610->addr_A1 != 1) + break; /* verified on real YM2608 */ + + ym2610_device::update_request(OPN->ST.device); + addr = OPN->ST.address; + F2610->REGS[addr | 0x100] = v; + if( addr < 0x30 ) + /* 100-12f : ADPCM A section */ + F2610->FM_ADPCMAWrite(addr,v); + else + OPNWriteReg(OPN,addr | 0x100,v); + } + return OPN->ST.irq; +} + +uint8_t ym2610_read(void *chip,int a) +{ + ym2610_state *F2610 = (ym2610_state *)chip; + int addr = F2610->OPN.ST.address; + uint8_t ret = 0; + + switch( a&3) + { + case 0: /* status 0 : YM2203 compatible */ + ret = FM_STATUS_FLAG(&F2610->OPN.ST) & 0x83; + break; + case 1: /* data 0 */ + if( addr < 16 ) ret = (*F2610->OPN.ST.SSG->read)(F2610->OPN.ST.device); + if( addr == 0xff ) ret = 0x01; + break; + case 2: /* status 1 : ADPCM status */ + /* ADPCM STATUS (arrived End Address) */ + /* B,--,A5,A4,A3,A2,A1,A0 */ + /* B = ADPCM-B(DELTA-T) arrived end address */ + /* A0-A5 = ADPCM-A arrived end address */ + ret = F2610->adpcm_arrivedEndAddress; + break; + case 3: + ret = 0; + break; + } + return ret; +} + +int ym2610_timer_over(void *chip,int c) +{ + ym2610_state *F2610 = (ym2610_state *)chip; + + if( c ) + { /* Timer B */ + TimerBOver( &(F2610->OPN.ST) ); + } + else + { /* Timer A */ + ym2610_device::update_request(F2610->OPN.ST.device); + /* timer update */ + TimerAOver( &(F2610->OPN.ST) ); + /* CSM mode key,TL controll */ + if( F2610->OPN.ST.mode & 0x80 ) + { /* CSM mode total level latch and auto key on */ + CSMKeyControll( F2610->OPN.type, &(F2610->CH[2]) ); + } + } + return F2610->OPN.ST.irq; +} + +#endif /* (BUILD_YM2610||BUILD_YM2610B) */ diff --git a/thirdparty/opnmidi/chips/mamefm/fm.h b/thirdparty/opnmidi/chips/mamefm/fm.h new file mode 100644 index 0000000..b95c4ff --- /dev/null +++ b/thirdparty/opnmidi/chips/mamefm/fm.h @@ -0,0 +1,193 @@ +// license:GPL-2.0+ +// copyright-holders:Jarek Burczynski,Tatsuyuki Satoh +/* + File: fm.h -- header file for software emulation for FM sound generator + +*/ + +#ifndef MAME_SOUND_FM_H +#define MAME_SOUND_FM_H + +#pragma once +#include "emu.h" + +struct device_t; +typedef int32_t stream_sample_t; + +/* --- select emulation chips --- */ +#define BUILD_YM2203 (0) /* build YM2203(OPN) emulator */ +#define BUILD_YM2608 (1) /* build YM2608(OPNA) emulator */ +#define BUILD_YM2610 (0) /* build YM2610(OPNB) emulator */ +#define BUILD_YM2610B (0) /* build YM2610B(OPNB?)emulator */ +#define BUILD_YM2612 (0) /* build YM2612(OPN2) emulator */ +#define BUILD_YM3438 (0) /* build YM3438(OPN) emulator */ + +/* select bit size of output : 8 or 16 */ +#define FM_SAMPLE_BITS 16 + +/* select timer system internal or external */ +#define FM_INTERNAL_TIMER 0 + +/* --- speedup optimize --- */ +/* busy flag emulation , The definition of FM_GET_TIME_NOW() is necessary. */ +#define FM_BUSY_FLAG_SUPPORT 0 + +/* --- external SSG(YM2149/AY-3-8910)emulator interface port */ +/* used by YM2203,YM2608,and YM2610 */ +struct ssg_callbacks +{ + void (*set_clock)(device_t *device, int clock); + void (*write)(device_t *device, int address, int data); + int (*read)(device_t *device); + void (*reset)(device_t *device); +}; + +/* --- external callback functions for realtime update --- */ + +#if FM_BUSY_FLAG_SUPPORT +using TIME_TYPE = attotime; +#define UNDEFINED_TIME attotime::zero +#define FM_GET_TIME_NOW(machine) (machine)->time() +inline TIME_TYPE ADD_TIMES(TIME_TYPE const &t1, TIME_TYPE const &t2) { return t1 + t2; } +constexpr int COMPARE_TIMES(TIME_TYPE const &t1, TIME_TYPE const &t2) { return (t1 == t2) ? 0 : (t1 < t2) ? -1 : 1; } +template constexpr TIME_TYPE MULTIPLY_TIME_BY_INT(TIME_TYPE const &t, X &&i) { return t * i; } +#endif + + +typedef stream_sample_t FMSAMPLE; +/* +#if (FM_SAMPLE_BITS==16) +typedef int16_t FMSAMPLE; +#endif +#if (FM_SAMPLE_BITS==8) +typedef unsigned char FMSAMPLE; +#endif +*/ + +typedef uint8_t (*FM_READBYTE)(device_t *device, offs_t offset); +typedef void(*FM_WRITEBYTE)(device_t *device, offs_t offset, uint8_t data); +typedef void (*FM_TIMERHANDLER)(device_t *device,int c,int cnt,int clock); +typedef void (*FM_IRQHANDLER)(device_t *device,int irq); +/* FM_TIMERHANDLER : Stop or Start timer */ +/* int n = chip number */ +/* int c = Channel 0=TimerA,1=TimerB */ +/* int count = timer count (0=stop) */ +/* doube stepTime = step time of one count (sec.)*/ + +/* FM_IRQHHANDLER : IRQ level changing sense */ +/* int n = chip number */ +/* int irq = IRQ level 0=OFF,1=ON */ + +#if BUILD_YM2203 +/* -------------------- YM2203(OPN) Interface -------------------- */ + +/* +** Initialize YM2203 emulator(s). +** +** 'num' is the number of virtual YM2203's to allocate +** 'baseclock' +** 'rate' is sampling rate +** 'TimerHandler' timer callback handler when timer start and clear +** 'IRQHandler' IRQ callback handler when changed IRQ level +** return 0 = success +*/ +void * ym2203_init(device_t *device, int baseclock, int rate, + FM_TIMERHANDLER TimerHandler,FM_IRQHANDLER IRQHandler, const ssg_callbacks *ssg); + +/* +** YM2203 clock changed notifier +*/ +void ym2203_clock_changed(void *chip, int clock, int rate); + +/* +** shutdown the YM2203 emulators +*/ +void ym2203_shutdown(void *chip); + +/* +** reset all chip registers for YM2203 number 'num' +*/ +void ym2203_reset_chip(void *chip); + +/* +** update one of chip +*/ +void ym2203_update_one(void *chip, FMSAMPLE *buffer, int length); + +/* +** Write +** return : InterruptLevel +*/ +int ym2203_write(void *chip,int a,unsigned char v); + +/* +** Read +** return : InterruptLevel +*/ +unsigned char ym2203_read(void *chip,int a); + +/* +** Timer OverFlow +*/ +int ym2203_timer_over(void *chip, int c); + +/* +** State Save +*/ +void ym2203_postload(void *chip); +#endif /* BUILD_YM2203 */ + +#if BUILD_YM2608 +/* -------------------- YM2608(OPNA) Interface -------------------- */ +void * ym2608_init(device_t *device, int baseclock, int rate, + FM_READBYTE InternalReadByte, + FM_READBYTE ExternalReadByte, FM_WRITEBYTE ExternalWriteByte, + FM_TIMERHANDLER TimerHandler, FM_IRQHANDLER IRQHandler, const ssg_callbacks *ssg); +void ym2608_clock_changed(void *chip, int clock, int rate); +void ym2608_shutdown(void *chip); +void ym2608_reset_chip(void *chip); +void ym2608_update_one(void *chip, FMSAMPLE **buffer, int length); + +int ym2608_write(void *chip, int a,unsigned char v); +void ym2608_write_pan(void *chip, int c,unsigned char v); // libOPNMIDI: soft panning +unsigned char ym2608_read(void *chip,int a); +int ym2608_timer_over(void *chip, int c ); +void ym2608_postload(void *chip); +#endif /* BUILD_YM2608 */ + +#if (BUILD_YM2610||BUILD_YM2610B) +/* -------------------- YM2610(OPNB) Interface -------------------- */ +void * ym2610_init(device_t *device, int baseclock, int rate, + FM_READBYTE adpcm_a_read_byte, FM_READBYTE adpcm_b_read_byte, + FM_TIMERHANDLER TimerHandler,FM_IRQHANDLER IRQHandler, const ssg_callbacks *ssg); +void ym2610_clock_changed(void *chip, int clock, int rate); +void ym2610_shutdown(void *chip); +void ym2610_reset_chip(void *chip); +void ym2610_update_one(void *chip, FMSAMPLE **buffer, int length); + +#if BUILD_YM2610B +void ym2610b_update_one(void *chip, FMSAMPLE **buffer, int length); +#endif /* BUILD_YM2610B */ + +int ym2610_write(void *chip, int a,unsigned char v); +unsigned char ym2610_read(void *chip,int a); +int ym2610_timer_over(void *chip, int c ); +void ym2610_postload(void *chip); +#endif /* (BUILD_YM2610||BUILD_YM2610B) */ + +#if (BUILD_YM2612||BUILD_YM3438) +void * ym2612_init(device_t *device, int baseclock, int rate, + FM_TIMERHANDLER TimerHandler,FM_IRQHANDLER IRQHandler); +void ym2612_clock_changed(void *chip, int clock, int rate); +void ym2612_shutdown(void *chip); +void ym2612_reset_chip(void *chip); +void ym2612_update_one(void *chip, FMSAMPLE **buffer, int length); + +int ym2612_write(void *chip, int a,unsigned char v); +unsigned char ym2612_read(void *chip,int a); +int ym2612_timer_over(void *chip, int c ); +void ym2612_postload(void *chip); +#endif /* (BUILD_YM2612||BUILD_YM3438) */ + + +#endif // MAME_SOUND_FM_H diff --git a/thirdparty/opnmidi/chips/mamefm/fmopn_2608rom.h b/thirdparty/opnmidi/chips/mamefm/fmopn_2608rom.h new file mode 100644 index 0000000..5d428ee --- /dev/null +++ b/thirdparty/opnmidi/chips/mamefm/fmopn_2608rom.h @@ -0,0 +1,543 @@ +/* + This data is derived from the chip's output - internal ROM can't be read. + It was verified, using real YM2608, that this ADPCM stream produces 100% correct output signal. +*/ + +static const unsigned char YM2608_ADPCM_ROM[0x2000] = { + +/* Source: 01BD.ROM */ +/* Length: 448 / 0x000001C0 */ + +0x88,0x08,0x08,0x08,0x00,0x88,0x16,0x76,0x99,0xB8,0x22,0x3A,0x84,0x3C,0xB1,0x54, +0x10,0xA9,0x98,0x32,0x80,0x33,0x9A,0xA7,0x4A,0xB4,0x58,0xBC,0x15,0x29,0x8A,0x97, +0x9B,0x44,0xAC,0x80,0x12,0xDE,0x13,0x1B,0xC0,0x58,0xC8,0x11,0x0A,0xA2,0x1A,0xA0, +0x00,0x98,0x0B,0x93,0x9E,0x92,0x0A,0x88,0xBE,0x14,0x1B,0x98,0x08,0xA1,0x4A,0xC1, +0x30,0xD9,0x33,0x98,0x10,0x89,0x17,0x1A,0x82,0x29,0x37,0x0C,0x83,0x50,0x9A,0x24, +0x1A,0x83,0x10,0x23,0x19,0xB3,0x72,0x8A,0x16,0x10,0x0A,0x93,0x70,0x99,0x23,0x99, +0x02,0x20,0x91,0x18,0x02,0x41,0xAB,0x24,0x18,0x81,0x99,0x4A,0xE8,0x28,0x9A,0x99, +0xA1,0x2F,0xA8,0x9D,0x90,0x08,0xCC,0xA3,0x1D,0xCA,0x82,0x0B,0xD8,0x08,0xB9,0x09, +0xBC,0xB8,0x00,0xBE,0x90,0x1B,0xCA,0x00,0x9B,0x8A,0xA8,0x91,0x0F,0xB3,0x3D,0xB8, +0x31,0x0B,0xA5,0x0A,0x11,0xA1,0x48,0x92,0x10,0x50,0x91,0x30,0x23,0x09,0x37,0x39, +0xA2,0x72,0x89,0x92,0x30,0x83,0x1C,0x96,0x28,0xB9,0x24,0x8C,0xA1,0x31,0xAD,0xA9, +0x13,0x9C,0xBA,0xA8,0x0B,0xBF,0xB8,0x9B,0xCA,0x88,0xDB,0xB8,0x19,0xFC,0x92,0x0A, +0xBA,0x89,0xAB,0xB8,0xAB,0xD8,0x08,0xAD,0xBA,0x33,0x9D,0xAA,0x83,0x3A,0xC0,0x40, +0xB9,0x15,0x39,0xA2,0x52,0x89,0x02,0x63,0x88,0x13,0x23,0x03,0x52,0x02,0x54,0x00, +0x11,0x23,0x23,0x35,0x20,0x01,0x44,0x41,0x80,0x24,0x40,0xA9,0x45,0x19,0x81,0x12, +0x81,0x02,0x11,0x21,0x19,0x02,0x61,0x8A,0x13,0x3A,0x10,0x12,0x23,0x8B,0x37,0x18, +0x91,0x24,0x10,0x81,0x34,0x20,0x05,0x32,0x82,0x53,0x20,0x14,0x33,0x31,0x34,0x52, +0x00,0x43,0x32,0x13,0x52,0x22,0x13,0x52,0x11,0x43,0x11,0x32,0x32,0x32,0x22,0x02, +0x13,0x12,0x89,0x22,0x19,0x81,0x81,0x08,0xA8,0x08,0x8B,0x90,0x1B,0xBA,0x8A,0x9B, +0xB9,0x89,0xCA,0xB9,0xAB,0xCA,0x9B,0xCA,0xB9,0xAB,0xDA,0x99,0xAC,0xBB,0x9B,0xAC, +0xAA,0xBA,0xAC,0xAB,0x9A,0xAA,0xAA,0xBA,0xB8,0xA9,0xBA,0x99,0xA9,0x9A,0xA0,0x8A, +0xA9,0x08,0x8A,0xA9,0x00,0x99,0x89,0x88,0x98,0x08,0x99,0x00,0x89,0x80,0x08,0x98, +0x00,0x88,0x88,0x80,0x90,0x80,0x90,0x80,0x81,0x99,0x08,0x88,0x99,0x09,0x00,0x1A, +0xA8,0x10,0x9A,0x88,0x08,0x0A,0x8A,0x89,0x99,0xA8,0x98,0xA9,0x99,0x99,0xA9,0x99, +0xAA,0x8A,0xAA,0x9B,0x8A,0x9A,0xA9,0x9A,0xBA,0x99,0x9A,0xAA,0x99,0x89,0xA9,0x99, +0x98,0x9A,0x98,0x88,0x09,0x89,0x09,0x08,0x08,0x09,0x18,0x18,0x00,0x12,0x00,0x11, +0x11,0x11,0x12,0x12,0x21,0x21,0x22,0x22,0x22,0x22,0x22,0x22,0x32,0x31,0x32,0x31, +0x32,0x32,0x21,0x31,0x21,0x32,0x21,0x12,0x00,0x80,0x80,0x80,0x80,0x80,0x80,0x80, + +/* Source: 02SD.ROM */ +/* Length: 640 / 0x00000280 */ + +0x0A,0xDC,0x14,0x0B,0xBA,0xBC,0x01,0x0F,0xF5,0x2F,0x87,0x19,0xC9,0x24,0x1B,0xA1, +0x31,0x99,0x90,0x32,0x32,0xFE,0x83,0x48,0xA8,0xA9,0x23,0x19,0xBC,0x91,0x02,0x41, +0xDE,0x81,0x28,0xA8,0x0A,0xB1,0x72,0xDA,0x23,0xBC,0x04,0x19,0xB8,0x21,0x8A,0x03, +0x29,0xBA,0x14,0x21,0x0B,0xC0,0x43,0x08,0x91,0x50,0x93,0x0F,0x86,0x1A,0x91,0x18, +0x21,0xCB,0x27,0x0A,0xA1,0x42,0x8C,0xA9,0x21,0x10,0x08,0xAB,0x94,0x2A,0xDA,0x02, +0x8B,0x91,0x09,0x98,0xAE,0x80,0xA9,0x02,0x0A,0xE9,0x21,0xBB,0x15,0x20,0xBE,0x92, +0x42,0x09,0xA9,0x11,0x34,0x08,0x12,0x0A,0x27,0x29,0xA1,0x52,0x12,0x8E,0x92,0x28, +0x92,0x2B,0xD1,0x23,0xBF,0x81,0x10,0x99,0xA8,0x0A,0xC4,0x3B,0xB9,0xB0,0x00,0x62, +0xCF,0x92,0x29,0x92,0x2B,0xB1,0x1C,0xB2,0x72,0xAA,0x88,0x11,0x18,0x80,0x13,0x9E, +0x03,0x18,0xB0,0x60,0xA1,0x28,0x88,0x08,0x04,0x10,0x8F,0x96,0x19,0x90,0x01,0x09, +0xC8,0x50,0x91,0x8A,0x01,0xAB,0x03,0x50,0xBA,0x9D,0x93,0x68,0xBA,0x80,0x22,0xCB, +0x41,0xBC,0x92,0x60,0xB9,0x1A,0x95,0x4A,0xC8,0x20,0x88,0x33,0xAC,0x92,0x38,0x83, +0x09,0x80,0x16,0x09,0x29,0xD0,0x54,0x8C,0xA2,0x28,0x91,0x89,0x93,0x60,0xCD,0x85, +0x1B,0xA1,0x49,0x90,0x8A,0x80,0x34,0x0C,0xC9,0x14,0x19,0x98,0xA0,0x40,0xA9,0x21, +0xD9,0x34,0x0A,0xA9,0x10,0x23,0xCB,0x25,0xAA,0x25,0x9B,0x13,0xCD,0x16,0x09,0xA0, +0x80,0x01,0x19,0x90,0x88,0x21,0xAC,0x33,0x8B,0xD8,0x27,0x3B,0xB8,0x81,0x31,0x80, +0xAF,0x97,0x0A,0x82,0x0A,0xA0,0x21,0x89,0x8A,0xA2,0x32,0x8D,0xBB,0x87,0x19,0x21, +0xC9,0xBC,0x45,0x09,0x90,0x09,0xA1,0x24,0x1A,0xD0,0x10,0x08,0x11,0xA9,0x21,0xE8, +0x60,0xA9,0x14,0x0C,0xD1,0x32,0xAB,0x04,0x0C,0x81,0x90,0x29,0x83,0x9B,0x01,0x8F, +0x97,0x0B,0x82,0x18,0x88,0xBA,0x06,0x39,0xC8,0x23,0xBC,0x04,0x09,0x92,0x08,0x1A, +0xBB,0x74,0x8C,0x81,0x18,0x81,0x9D,0x83,0x41,0xCD,0x81,0x40,0x9A,0x90,0x10,0x12, +0x9C,0xA1,0x68,0xD8,0x33,0x9C,0x91,0x01,0x12,0xBE,0x02,0x09,0x12,0x99,0x9A,0x36, +0x0A,0xB0,0x30,0x88,0xA3,0x2D,0x12,0xBC,0x03,0x3A,0x11,0xBD,0x08,0xC8,0x62,0x80, +0x8B,0xD8,0x23,0x38,0xF9,0x12,0x08,0x99,0x91,0x21,0x99,0x85,0x2F,0xB2,0x30,0x90, +0x88,0xD9,0x53,0xAC,0x82,0x19,0x91,0x20,0xCC,0x96,0x29,0xC9,0x24,0x89,0x80,0x99, +0x12,0x08,0x18,0x88,0x99,0x23,0xAB,0x73,0xCB,0x33,0x9F,0x04,0x2B,0xB1,0x08,0x03, +0x1B,0xC9,0x21,0x32,0xFA,0x33,0xDB,0x02,0x33,0xAE,0xB9,0x54,0x8B,0xA1,0x20,0x89, +0x90,0x11,0x88,0x09,0x98,0x23,0xBE,0x37,0x8D,0x81,0x20,0xAA,0x34,0xBB,0x13,0x18, +0xB9,0x40,0xB1,0x18,0x83,0x8E,0xB2,0x72,0xBC,0x82,0x30,0xA9,0x9A,0x24,0x8B,0x27, +0x0E,0x91,0x20,0x90,0x08,0xB0,0x32,0xB9,0x21,0xB0,0xAC,0x45,0x9A,0xA1,0x50,0xA9, +0x80,0x0A,0x26,0x9B,0x11,0xBB,0x23,0x71,0xCB,0x12,0x10,0xB8,0x40,0xA9,0xA5,0x39, +0xC0,0x30,0xB2,0x20,0xAA,0xBA,0x76,0x1C,0xC1,0x48,0x98,0x80,0x18,0x81,0xAA,0x23, +0x9C,0xA2,0x32,0xAC,0x9A,0x43,0x9C,0x12,0xAD,0x82,0x72,0xBC,0x00,0x82,0x39,0xD1, +0x3A,0xB8,0x35,0x9B,0x10,0x40,0xF9,0x22,0x0A,0xC0,0x51,0xB9,0x82,0x18,0x98,0xA3, +0x79,0xD0,0x20,0x88,0x09,0x01,0x99,0x82,0x11,0x38,0xFC,0x33,0x09,0xC8,0x40,0xA9, +0x11,0x29,0xAA,0x94,0x3A,0xC2,0x4A,0xC0,0x89,0x52,0xBC,0x11,0x08,0x09,0xB8,0x71, +0xA9,0x08,0xA8,0x62,0x8D,0x92,0x10,0x00,0x9E,0x94,0x38,0xBA,0x13,0x88,0x90,0x4A, +0xE2,0x30,0xBA,0x02,0x00,0x19,0xD9,0x62,0xBB,0x04,0x0B,0xA3,0x68,0xB9,0x21,0x88, +0x9D,0x04,0x10,0x8C,0xC8,0x62,0x99,0xAA,0x24,0x1A,0x80,0x9A,0x14,0x9B,0x26,0x8C, +0x92,0x30,0xB9,0x09,0xA3,0x71,0xBB,0x10,0x19,0x82,0x39,0xDB,0x02,0x44,0x9F,0x10, + +/* Source: 04TOP.ROM */ +/* Length: 5952 / 0x00001740 */ + +0x07,0xFF,0x7C,0x3C,0x31,0xC6,0xC4,0xBB,0x7F,0x7F,0x7B,0x82,0x8A,0x4D,0x5F,0x7C, +0x3E,0x44,0xD2,0xB3,0xA0,0x19,0x1B,0x6C,0x81,0x28,0xC4,0xA1,0x1C,0x4B,0x18,0x00, +0x2A,0xA2,0x0A,0x7C,0x2A,0x00,0x01,0x89,0x98,0x48,0x8A,0x3C,0x28,0x2A,0x5B,0x3E, +0x3A,0x1A,0x3B,0x3D,0x4B,0x3B,0x4A,0x08,0x2A,0x1A,0x2C,0x4A,0x3B,0x82,0x99,0x3C, +0x5D,0x29,0x2B,0x39,0x0B,0x23,0xAB,0x1A,0x4C,0x79,0xA3,0x01,0xC1,0x2A,0x0A,0x38, +0xA7,0xB9,0x12,0x1F,0x29,0x08,0x82,0xA1,0x08,0xA9,0x42,0xAA,0x95,0xB3,0x90,0x81, +0x09,0xD4,0x1A,0x80,0x1B,0x07,0xB8,0x12,0x8E,0x49,0x81,0x92,0xD3,0x90,0xA1,0x2A, +0x02,0xE1,0xA3,0x99,0x02,0xB3,0x94,0xB3,0xB0,0xF4,0x98,0x93,0x90,0x13,0xE1,0x81, +0x99,0x38,0x91,0xA6,0xD3,0x99,0x94,0xC1,0x83,0xB1,0x92,0x98,0x49,0xC4,0xB2,0xA4, +0xA3,0xD0,0x1A,0x30,0xBA,0x59,0x02,0xD4,0xA0,0xA4,0xA2,0x8A,0x01,0x00,0xB7,0xA8, +0x18,0x2A,0x2B,0x1E,0x23,0xC8,0x1A,0x00,0x39,0xA0,0x18,0x92,0x4F,0x2D,0x5A,0x10, +0x89,0x81,0x2A,0x8B,0x6A,0x02,0x09,0xB3,0x8D,0x48,0x1B,0x80,0x19,0x34,0xF8,0x29, +0x0A,0x7B,0x2A,0x28,0x81,0x0C,0x02,0x1E,0x29,0x09,0x12,0xC2,0x94,0xE1,0x18,0x98, +0x02,0xC4,0x89,0x91,0x1A,0x20,0xA9,0x02,0x1B,0x48,0x8E,0x20,0x88,0x2D,0x08,0x59, +0x1B,0x02,0xA3,0xB1,0x8A,0x1E,0x58,0x80,0xC2,0xB6,0x88,0x91,0x88,0x11,0xA1,0xA3, +0xE2,0x01,0xB0,0x19,0x11,0x09,0xF4,0x88,0x09,0x88,0x19,0x89,0x12,0xF1,0x2A,0x28, +0x8C,0x25,0x99,0xA4,0x98,0x39,0xA1,0x00,0xD0,0x58,0xAA,0x59,0x01,0x0C,0x00,0x2B, +0x00,0x08,0x89,0x6B,0x69,0x90,0x01,0x90,0x98,0x12,0xB3,0xF3,0xA0,0x89,0x02,0x3B, +0x0C,0x50,0xA9,0x4E,0x6B,0x19,0x28,0x09,0xA2,0x08,0x2F,0x20,0x88,0x92,0x8A,0x11, +0xC4,0x93,0xF1,0x18,0x88,0x11,0xF2,0x80,0x92,0xA8,0x02,0xA8,0xB7,0xB3,0xA3,0xA0, +0x88,0x1A,0x40,0xE2,0x91,0x19,0x88,0x18,0x91,0x83,0xC1,0xB5,0x92,0xA9,0xC6,0x90, +0x01,0xC2,0x81,0x98,0x03,0xF0,0x00,0x2C,0x2A,0x92,0x2C,0x83,0x1F,0x3A,0x29,0x00, +0xB8,0x70,0xAB,0x69,0x18,0x89,0x10,0x0D,0x12,0x0B,0x88,0x4A,0x3A,0x9B,0x70,0xA8, +0x28,0x2F,0x2A,0x3A,0x1B,0x85,0x88,0x8B,0x6A,0x29,0x00,0x91,0x91,0x1B,0x7C,0x29, +0x01,0x88,0x90,0x19,0x2B,0x2B,0x00,0x39,0xA8,0x5E,0x21,0x89,0x91,0x09,0x3A,0x6F, +0x2A,0x18,0x18,0x8B,0x50,0x89,0x2B,0x19,0x49,0x88,0x29,0xF5,0x89,0x08,0x09,0x12, +0xAA,0x15,0xB0,0x82,0xAC,0x38,0x00,0x3F,0x81,0x10,0xB0,0x49,0xA2,0x81,0x3A,0xC8, +0x87,0x90,0xC4,0xA3,0x99,0x19,0x83,0xE1,0x84,0xE2,0xA2,0x90,0x80,0x93,0xB5,0xC4, +0xB3,0xA1,0x0A,0x18,0x92,0xC4,0xA0,0x93,0x0C,0x3A,0x18,0x01,0x1E,0x20,0xB1,0x82, +0x8C,0x03,0xB5,0x2E,0x82,0x19,0xB2,0x1B,0x1B,0x6B,0x4C,0x19,0x12,0x8B,0x5A,0x11, +0x0C,0x3A,0x2C,0x18,0x3D,0x08,0x2A,0x5C,0x18,0x00,0x88,0x3D,0x29,0x80,0x2A,0x09, +0x00,0x7A,0x0A,0x10,0x0B,0x69,0x98,0x10,0x81,0x3F,0x00,0x18,0x19,0x91,0xB7,0x9A, +0x28,0x8A,0x48,0x92,0xF3,0xA2,0x88,0x98,0x87,0xA1,0x88,0x80,0x81,0x95,0xD1,0xA3, +0x1B,0x1C,0x39,0x10,0xA1,0x2A,0x0B,0x7A,0x4B,0x80,0x13,0xC1,0xD1,0x2B,0x2A,0x85, +0xB2,0xA2,0x93,0xB2,0xD3,0x80,0xD1,0x18,0x08,0x08,0xB7,0x98,0x81,0x3F,0x01,0x88, +0x01,0xE2,0x00,0x9A,0x59,0x08,0x10,0xC3,0x99,0x84,0xA9,0xA5,0x91,0x91,0x91,0x80, +0xB5,0x94,0xC0,0x01,0x98,0x09,0x84,0xB0,0x80,0x7A,0x08,0x18,0x90,0xA8,0x6A,0x1C, +0x39,0x2A,0xB7,0x98,0x19,0x10,0x2A,0xA1,0x10,0xBD,0x39,0x18,0x2D,0x39,0x3F,0x10, +0x3F,0x01,0x09,0x19,0x0A,0x38,0x8C,0x40,0xB3,0xB4,0x93,0xAD,0x20,0x2B,0xD4,0x81, +0xC3,0xB0,0x39,0xA0,0x23,0xD8,0x04,0xB1,0x9B,0xA7,0x1A,0x92,0x08,0xA5,0x88,0x81, +0xE2,0x01,0xB8,0x01,0x81,0xC1,0xC7,0x90,0x92,0x80,0xA1,0x97,0xA0,0xA2,0x82,0xB8, +0x18,0x00,0x9C,0x78,0x98,0x83,0x0B,0x0B,0x32,0x7D,0x19,0x10,0xA1,0x19,0x09,0x0A, +0x78,0xA8,0x10,0x1B,0x29,0x29,0x1A,0x14,0x2F,0x88,0x4A,0x1B,0x10,0x10,0xAB,0x79, +0x0D,0x49,0x18,0xA0,0x02,0x1F,0x19,0x3A,0x2B,0x11,0x8A,0x88,0x79,0x8A,0x20,0x49, +0x9B,0x58,0x0B,0x28,0x18,0xA9,0x3A,0x7D,0x00,0x29,0x88,0x82,0x3D,0x1A,0x38,0xBA, +0x15,0x09,0xAA,0x51,0x8B,0x83,0x3C,0x8A,0x58,0x1B,0xB5,0x01,0xBB,0x50,0x19,0x99, +0x24,0xCA,0x21,0x1B,0xA2,0x87,0xA8,0xB1,0x68,0xA1,0xA6,0xA2,0xA8,0x29,0x8B,0x24, +0xB4,0xE2,0x92,0x8A,0x00,0x19,0x93,0xB5,0xB4,0xB1,0x81,0xB1,0x03,0x9A,0x82,0xA7, +0x90,0xD6,0xA0,0x80,0x1B,0x29,0x01,0xA4,0xE1,0x18,0x0A,0x2A,0x29,0x92,0xC7,0xA8, +0x81,0x19,0x89,0x30,0x10,0xE0,0x30,0xB8,0x10,0x0C,0x1A,0x79,0x1B,0xA7,0x80,0xA0, +0x00,0x0B,0x28,0x18,0xB1,0x85,0x1E,0x00,0x20,0xA9,0x18,0x18,0x1C,0x13,0xBC,0x15, +0x99,0x2E,0x12,0x00,0xE1,0x00,0x0B,0x3B,0x21,0x90,0x06,0xC9,0x2A,0x49,0x0A,0x18, +0x20,0xD1,0x3C,0x08,0x00,0x83,0xC9,0x41,0x8E,0x18,0x08,0x02,0xA0,0x09,0xA4,0x7B, +0x90,0x19,0x2A,0x10,0x2A,0xA8,0x71,0xBA,0x10,0x4A,0x0E,0x22,0xB2,0xB2,0x1B,0x8C, +0x78,0x1A,0xB5,0x93,0xA9,0x1B,0x49,0x19,0x29,0xA3,0xC6,0x88,0xAA,0x32,0x0D,0x1B, +0x22,0x08,0xC2,0x18,0xB9,0x79,0x3F,0x01,0x10,0xA9,0x84,0x1C,0x09,0x21,0xB0,0xA7, +0x0A,0x99,0x50,0x0C,0x81,0x28,0x8B,0x48,0x2E,0x00,0x08,0x99,0x38,0x5B,0x88,0x14, +0xA9,0x08,0x11,0xAA,0x72,0xC1,0xB3,0x09,0x8A,0x05,0x91,0xF2,0x81,0xA1,0x09,0x02, +0xF2,0x92,0x99,0x1A,0x49,0x80,0xC5,0x90,0x90,0x18,0x09,0x12,0xA1,0xF2,0x81,0x98, +0xC6,0x91,0xA0,0x11,0xA0,0x94,0xB4,0xF2,0x81,0x8B,0x03,0x80,0xD2,0x93,0xA8,0x88, +0x69,0xA0,0x03,0xB8,0x88,0x32,0xBC,0x97,0x80,0xB1,0x3B,0x1A,0xA6,0x00,0xD1,0x01, +0x0B,0x3B,0x30,0x9B,0x31,0x3E,0x92,0x19,0x8A,0xD3,0x5C,0x1B,0x41,0xA0,0x93,0xA2, +0xAF,0x39,0x4C,0x01,0x92,0xA8,0x81,0x3C,0x0D,0x78,0x98,0x00,0x19,0x0A,0x20,0x2D, +0x29,0x3C,0x1B,0x48,0x88,0x99,0x7A,0x2D,0x29,0x2A,0x82,0x80,0xA8,0x49,0x3E,0x19, +0x11,0x98,0x82,0x9A,0x3B,0x28,0x2F,0x20,0x4C,0x90,0x29,0x19,0x9A,0x7A,0x29,0x28, +0x98,0x88,0x33,0xCD,0x11,0x3A,0xC1,0xA4,0xA0,0xC4,0x82,0xC8,0x50,0x98,0xB2,0x21, +0xC0,0xB6,0x98,0x82,0x80,0x9C,0x23,0x00,0xF8,0x30,0xA8,0x1A,0x68,0xA8,0x86,0x9A, +0x01,0x2A,0x0A,0x97,0x91,0xC1,0x18,0x89,0x02,0x83,0xE0,0x01,0x8B,0x29,0x30,0xE2, +0x91,0x0B,0x18,0x3B,0x1C,0x11,0x28,0xAC,0x78,0x80,0x93,0x91,0xA9,0x49,0x8B,0x87, +0x90,0x99,0x3D,0x5A,0x81,0x08,0xA1,0x11,0x2F,0x1A,0x21,0x9B,0x15,0xA2,0xB0,0x11, +0xC0,0x91,0x5B,0x98,0x24,0xA2,0xF2,0x92,0x8B,0x6A,0x18,0x81,0xB5,0xB1,0x88,0x4C, +0x00,0x00,0xA4,0xC1,0x2B,0x1A,0x59,0x0A,0x02,0x80,0x1E,0x02,0x08,0xB3,0x80,0x9A, +0x23,0xB8,0xF2,0x84,0xAB,0x01,0x48,0x90,0xA7,0x90,0x0A,0x29,0x09,0x95,0x99,0xA0, +0x59,0x2B,0x00,0x97,0xB0,0x29,0x89,0x2A,0x03,0xD0,0xB7,0x1B,0x81,0x00,0xA6,0xB1, +0x90,0x09,0x48,0xC0,0x11,0x00,0x8A,0x00,0x5B,0x83,0x9A,0x18,0x2F,0x3C,0x18,0x11, +0xA9,0x04,0x1A,0x4F,0x01,0x98,0x81,0x09,0x09,0x4A,0x18,0xB4,0xA2,0x0B,0x59,0x90, +0x3B,0x49,0xBC,0x40,0x6A,0x88,0x3A,0x08,0x3E,0x3A,0x80,0x93,0xB0,0xE1,0x5A,0x00, +0xA4,0xB3,0xE3,0x90,0x0D,0x38,0x09,0x82,0xC4,0xA1,0xB1,0x4C,0x18,0x10,0x91,0xB2, +0x13,0xEA,0x34,0x99,0x88,0xA6,0x89,0x92,0x91,0xC1,0x20,0xB2,0xC2,0x86,0xD2,0xB3, +0x80,0xB2,0x08,0x09,0x87,0x91,0xC0,0x11,0x89,0x90,0x28,0xB9,0x79,0x19,0xA4,0x82, +0xD0,0x03,0x0C,0xA3,0xA5,0xB2,0xB2,0x1B,0x29,0x13,0xF1,0xB4,0x81,0x9D,0x38,0x00, +0xC4,0xA1,0x89,0x59,0x1A,0x81,0xA4,0xA9,0x1C,0x6A,0x19,0x02,0xB1,0x1A,0x4A,0x0B, +0x78,0x89,0x81,0x1C,0x2A,0x29,0x4A,0xA3,0x3E,0x1C,0x49,0x1A,0x08,0x21,0xAE,0x28, +0x4B,0x19,0x20,0x8C,0x10,0x3A,0xAB,0x26,0x8B,0x18,0x59,0x99,0x13,0xA2,0xAB,0x79, +0x2F,0x18,0x10,0xB2,0x80,0x1B,0x4D,0x5A,0x80,0x82,0x98,0x81,0x80,0x09,0xA5,0x90, +0x91,0x03,0xC2,0xE2,0x81,0xA8,0x82,0x09,0xC6,0xA3,0xB1,0x08,0x5B,0x08,0x05,0xD1, +0xA2,0x89,0x2A,0x28,0x91,0xA6,0x88,0xB0,0x49,0x80,0x09,0x08,0x88,0x07,0xB8,0x05, +0x99,0x81,0x88,0x18,0xE2,0x00,0xC3,0x18,0x0D,0x10,0x30,0xD0,0x93,0x8A,0x09,0x10, +0x2F,0x11,0x90,0xA1,0x20,0x9B,0xB1,0x73,0xC8,0x94,0x98,0x3B,0x01,0x0C,0x30,0x19, +0xF8,0x12,0x90,0xBA,0x78,0x0A,0x11,0x98,0xA0,0x79,0x8A,0x30,0x2B,0xC2,0x11,0x0D, +0x09,0x7A,0x00,0x82,0xB9,0x01,0x7A,0x89,0x21,0x09,0xA1,0x0A,0x7C,0x10,0x88,0xB5, +0x88,0x0A,0x2B,0x69,0x1A,0x10,0xA0,0x5B,0x19,0x1A,0x10,0x19,0x1A,0x6C,0x20,0x90, +0xA5,0x98,0x1B,0x0A,0x69,0x82,0xD1,0x18,0x09,0x19,0x2A,0x93,0xD4,0x9A,0x01,0x49, +0xA2,0xA2,0x82,0xD8,0x22,0xAA,0x97,0xA9,0x2D,0x38,0x2A,0xB6,0x80,0x90,0x0A,0x3C, +0x82,0x94,0xB8,0x21,0x0E,0x2A,0x22,0xB8,0x00,0x4F,0x2B,0x3A,0x81,0xA1,0x29,0x2C, +0x6A,0x13,0xD1,0xA2,0x98,0x28,0x0C,0x01,0xD5,0x08,0xA9,0x31,0xB3,0xB0,0xA7,0xB0, +0x29,0x1B,0x87,0xA2,0xA1,0xB2,0x4A,0x89,0x11,0xC3,0xF3,0x98,0x08,0x03,0xA0,0xA3, +0xC5,0x90,0xB3,0xB5,0xB4,0xB8,0x02,0x91,0x91,0xD3,0xA4,0xC1,0x1B,0x82,0x28,0xA4, +0xD1,0x94,0x8A,0x28,0x08,0x03,0xE0,0x80,0xD4,0x90,0x91,0xA1,0x3B,0x3D,0x02,0xE4, +0xA1,0x92,0x89,0x1A,0x4B,0x95,0xB3,0x90,0x99,0x6A,0x0A,0x30,0xA1,0x93,0xA6,0xA9, +0x85,0x8B,0x82,0x10,0xB1,0xA3,0x94,0xF8,0x38,0x9A,0x30,0x1A,0x8B,0xA7,0x89,0x01, +0x5B,0x19,0x18,0x11,0xF0,0x18,0x1C,0x39,0x19,0x0C,0x12,0x1C,0x2A,0x7B,0x3A,0x88, +0x2B,0x18,0x2B,0x5C,0x20,0x92,0x8D,0x38,0x8A,0x3A,0x5B,0x2E,0x3A,0x2B,0x10,0x12, +0xBB,0x6A,0x4D,0x18,0x10,0xB1,0x81,0x2A,0x8B,0x79,0x80,0x01,0x0A,0x09,0x5B,0x2D, +0x84,0x8A,0x08,0x02,0xA2,0x91,0x82,0xE8,0x50,0x9B,0x85,0xA3,0xB0,0xA3,0x1B,0x02, +0x18,0xF3,0xA2,0x88,0xAB,0x53,0xD1,0xB4,0xA3,0x09,0x09,0x18,0xD4,0x08,0xB0,0x09, +0x58,0xD1,0x82,0x89,0x81,0x1A,0x18,0x05,0xB9,0xC3,0x30,0xC0,0x95,0x80,0xC3,0x89, +0x89,0x13,0x88,0xF2,0x93,0x0E,0x18,0x01,0x92,0xA5,0xB8,0x2A,0x39,0xAA,0x33,0x9A, +0xB1,0x11,0xF5,0xA1,0xA1,0x0A,0x50,0xB8,0x03,0xC4,0xA0,0x4E,0x29,0x10,0x88,0xC2, +0x1A,0x39,0x1D,0x28,0x98,0x94,0x0E,0x10,0x2A,0x3C,0x02,0x2D,0x1B,0x4B,0x3B,0x49, +0x19,0xA9,0x48,0x2F,0x29,0x10,0x89,0x02,0x0C,0x10,0x09,0xB9,0x70,0x1B,0x8A,0x50, +0xA8,0x2B,0x49,0x89,0x69,0x88,0x95,0x89,0x90,0x92,0x4C,0x19,0x82,0xC1,0x01,0x80, +0xA0,0x2B,0x7A,0x81,0x10,0xC2,0xB7,0x98,0x88,0x19,0x2C,0x03,0xB1,0xA4,0xA1,0x0C, +0x3B,0x78,0x88,0x85,0xB1,0xA0,0x1B,0x3A,0x4A,0x08,0x94,0x81,0xF1,0x80,0x00,0x0C, +0x59,0x09,0x18,0x90,0xA6,0x92,0x8C,0x1A,0x79,0x92,0xA8,0x00,0x81,0x2E,0x2A,0x13, +0xA2,0xB0,0xA5,0x88,0x88,0x89,0x11,0x19,0xA0,0xF3,0x82,0xB0,0x83,0x5F,0x2A,0x01, +0xA1,0x94,0xB0,0x09,0x78,0x98,0xA3,0xA6,0xA0,0x91,0x80,0x93,0x98,0xC1,0x12,0x18, +0xC9,0x17,0xA0,0xA0,0x1A,0x21,0x80,0x99,0xD4,0x30,0x9D,0x00,0x10,0x2F,0x08,0x1C, +0x21,0x08,0xB4,0xC3,0x2B,0xA9,0x52,0xD2,0xA3,0xD1,0x09,0x10,0x8B,0x24,0x92,0xD1, +0x80,0x19,0xA0,0x2C,0x12,0x49,0xAA,0xB6,0x95,0xB8,0x08,0x3A,0x2B,0x01,0xF3,0xB3, +0x0B,0x09,0x79,0x18,0xA2,0xA4,0xA0,0x18,0x0C,0x20,0x08,0xA9,0x16,0x0C,0x00,0x1B, +0x08,0x2B,0x7B,0x01,0x01,0xB9,0x59,0x19,0x8B,0x45,0xA8,0x80,0x0C,0x1A,0x41,0x1E, +0x00,0x28,0xA8,0x5A,0x00,0xC1,0x49,0x99,0x21,0x1D,0x08,0x85,0x99,0x95,0x89,0x90, +0x11,0x90,0xD1,0x28,0xB2,0xA7,0x99,0x81,0x02,0xAC,0x13,0x81,0xB2,0xA6,0xA9,0x28, +0x1C,0xB1,0x33,0xD1,0xC1,0x58,0xA8,0x14,0xB0,0xB7,0x91,0xA0,0x82,0x89,0xC2,0x28, +0xA1,0xB2,0x49,0xD2,0x94,0xC8,0x12,0x80,0x99,0x85,0x08,0xD3,0x09,0xA2,0xB3,0x1E, +0x08,0x21,0xB9,0x23,0xB4,0xAB,0x41,0xAC,0x87,0x09,0xA2,0xC5,0x0B,0x2A,0x5A,0x91, +0x20,0x9A,0x89,0x78,0x9B,0x31,0x89,0x80,0x29,0x0A,0xB7,0x3C,0x98,0x48,0x1D,0x00, +0x01,0xB0,0x20,0x2F,0x29,0x4A,0x89,0x94,0x1C,0x88,0x28,0x2B,0x10,0x88,0x9A,0x71, +0x9A,0x08,0x4A,0x2F,0x18,0x2B,0x18,0x02,0xA8,0x4B,0x7A,0x99,0x48,0x80,0xA8,0x20, +0x1D,0x40,0xA8,0x10,0x08,0xA8,0xC5,0x88,0xC2,0x18,0x88,0x2A,0x12,0xF3,0x82,0xD8, +0x20,0x0A,0x09,0xA6,0x98,0x04,0xB9,0x11,0x18,0xC3,0xE1,0x29,0xA1,0x11,0xC1,0x03, +0xE2,0x9A,0x33,0xA9,0xB5,0x98,0x92,0xA1,0x02,0xF8,0x21,0xA8,0x10,0x02,0xC1,0xB7, +0x1B,0x90,0x5B,0x3C,0x83,0x93,0xE0,0x19,0x1A,0x11,0x11,0xF1,0x92,0x89,0x19,0x2C, +0x2C,0x41,0x99,0x92,0x90,0x3F,0x18,0x4B,0x00,0x08,0xD2,0x01,0xB2,0xAA,0x78,0x09, +0x01,0x91,0xA2,0x98,0x2F,0x3A,0x2C,0x01,0x00,0x93,0xE0,0x28,0x2C,0x2B,0x01,0x12, +0xE1,0x80,0xB3,0x3D,0x3A,0x0A,0x50,0x98,0xC2,0xA0,0x11,0xAA,0x30,0x87,0x90,0xC2, +0x29,0x88,0x38,0xC8,0xB5,0x90,0xBA,0x70,0x1A,0x02,0x94,0xD0,0x80,0x1A,0x82,0xA6, +0xB0,0x91,0x18,0xB3,0x00,0x13,0xF1,0xA2,0xC1,0x82,0xB0,0x00,0x15,0x0B,0xD3,0x02, +0xA8,0x91,0x2B,0x1F,0x49,0x88,0xA6,0x80,0x88,0x08,0x1B,0xA5,0x80,0xB9,0x06,0x0B, +0x90,0x21,0x9D,0x48,0x18,0xA0,0x15,0xC9,0x82,0x2B,0x1A,0x42,0x9A,0xC4,0x39,0xBC, +0x69,0x00,0xA0,0x29,0x8C,0x39,0x59,0x08,0x09,0x49,0xA9,0x6B,0x81,0x00,0x98,0xB0, +0x68,0x3D,0x81,0x88,0x18,0x19,0x1D,0x12,0x80,0xB2,0x3A,0x3F,0x85,0x92,0xD0,0x00, +0x0A,0x19,0x12,0xF1,0x02,0x9B,0x19,0x40,0xB9,0x11,0x02,0xF2,0x1A,0x08,0x94,0x0A, +0xC2,0x83,0x0B,0xB4,0xA4,0xC0,0x32,0xD8,0x86,0x98,0x90,0x95,0x89,0xA3,0x83,0xC2, +0x92,0xE1,0x92,0x82,0xD9,0x03,0x08,0xA9,0x85,0x92,0xA2,0x80,0xE0,0x30,0x8B,0xB3, +0x87,0x89,0x90,0x83,0xA0,0x08,0x92,0x93,0x3E,0xAB,0x43,0x89,0xE3,0x80,0x83,0x2F, +0x00,0xA3,0x80,0xC9,0x22,0x3F,0x08,0x81,0x0B,0x33,0x9A,0xA3,0x7B,0x0C,0x29,0x4A, +0x1B,0x21,0xAA,0x70,0x1B,0x0D,0x48,0x1A,0x81,0x88,0xB1,0x39,0x3F,0x08,0x58,0xA0, +0x81,0x1A,0x1A,0x2B,0x6D,0x11,0x0A,0x91,0x01,0x1A,0x98,0x5A,0x0C,0x03,0xB1,0x84, +0xA3,0xAD,0x58,0x2A,0xA1,0x84,0xB1,0xA0,0x5C,0x2B,0x13,0xA8,0x95,0x83,0xE8,0x10, +0x81,0xB0,0x00,0xC2,0x96,0xA0,0x91,0x00,0x2C,0x90,0x30,0xF2,0x80,0xA8,0x39,0x21, +0xC1,0x03,0xAC,0x39,0x7C,0x29,0x91,0x1A,0x00,0x19,0x2C,0x3A,0x93,0xB0,0x29,0x8F, +0x28,0x02,0x93,0xF3,0xA9,0x01,0x03,0xE0,0x08,0x09,0x1D,0x58,0xA1,0x83,0xA9,0x6B, +0x2A,0x3C,0x21,0x89,0xC2,0x2C,0x4B,0x8A,0x50,0x81,0x98,0xA8,0x32,0x0C,0x8E,0x24, +0x0B,0x1A,0x81,0x92,0xA1,0x4F,0x18,0x3A,0x0A,0xB4,0x18,0x2E,0x39,0x82,0x19,0xD3, +0xD0,0x28,0x1B,0x11,0x98,0x07,0xAA,0x28,0x00,0x88,0xB4,0x89,0x1B,0x1F,0x22,0x00, +0xB3,0xC9,0x33,0xAB,0x2B,0xB5,0x48,0x98,0x98,0xA7,0x10,0xD2,0xC1,0x23,0xCA,0x93, +0xC6,0x80,0xA1,0x88,0x02,0x89,0xE2,0x09,0x38,0xBA,0x40,0x89,0x21,0xD8,0x49,0x10, +0x8D,0x02,0x90,0xC3,0x9A,0x24,0x89,0x08,0x84,0xA5,0x9C,0x10,0x11,0x9C,0x88,0x30, +0x3C,0xA1,0x94,0x58,0x8C,0x0B,0x69,0x29,0x9A,0x81,0x12,0x2B,0x8B,0x79,0x94,0xB0, +0xC1,0x84,0xC2,0x99,0x25,0x99,0x11,0xA2,0x93,0xE4,0x99,0x80,0x0A,0x00,0x10,0xB7, +0xB0,0x31,0xBA,0x3C,0x21,0xB3,0xF1,0x18,0xA0,0x2A,0x20,0xA3,0x06,0xE8,0x28,0xA1, +0xB4,0x08,0x0B,0x11,0x4B,0xB7,0x90,0xA5,0x98,0x3D,0x19,0x02,0xA1,0xC4,0xB2,0x19, +0x28,0xC0,0xA5,0x92,0xB1,0xA3,0x0A,0x0A,0x08,0x2B,0x70,0xC4,0xB3,0x00,0xBC,0x4B, +0x39,0x12,0xE3,0xA0,0x00,0x3F,0x18,0x29,0x94,0xD1,0x19,0x09,0x00,0xA1,0x83,0x99, +0x9B,0x35,0x80,0xC4,0xB1,0x6A,0x1A,0x1C,0x29,0x38,0x0E,0x19,0x5A,0x1A,0x82,0x8A, +0x59,0x2A,0x2E,0x20,0x88,0xA8,0x3A,0x38,0x3D,0x00,0xB3,0x29,0xAD,0x49,0x10,0x0C, +0x01,0x01,0xA3,0x8F,0x85,0x09,0x1B,0x88,0x10,0xA3,0xD2,0x90,0x3C,0x5C,0x39,0x03, +0xD1,0xA0,0x00,0x2A,0x0B,0x04,0xA7,0x90,0xA0,0x11,0x90,0x99,0x83,0xB4,0xB1,0xF1, +0x84,0x88,0x90,0x18,0x18,0xD3,0xD2,0xB3,0xA0,0x1A,0x21,0xA7,0xB2,0xB3,0x92,0x9A, +0x22,0xB9,0x28,0x38,0xBD,0x87,0x2A,0xB1,0x13,0x0D,0x0A,0x38,0xC9,0x24,0xC0,0x19, +0x23,0x0F,0x01,0x88,0xC0,0x2A,0x82,0x18,0x28,0xF0,0x18,0x2A,0x29,0x4B,0x35,0xB8, +0xA3,0x9D,0x18,0x1B,0x40,0x00,0x9A,0x5C,0x3A,0x09,0x2F,0x38,0x8A,0x3B,0x3B,0x11, +0x5C,0x19,0x2B,0x4A,0x08,0x0A,0x3D,0x20,0x4F,0x3A,0x19,0x2A,0x18,0x4D,0x1B,0x3A, +0x11,0x0D,0x3A,0x3C,0x4B,0x93,0x81,0xAA,0x6B,0x4A,0x18,0x00,0xC3,0xC3,0x9A,0x59, +0x2A,0x1B,0xA7,0xA1,0x81,0x88,0x88,0x58,0xB2,0xB1,0x2B,0x83,0xD4,0x81,0x08,0x0F, +0x00,0x20,0xC2,0xE2,0x80,0x08,0x1C,0x29,0x04,0xB1,0xA2,0x01,0x1C,0x91,0x00,0x0C, +0x49,0xB0,0x43,0xF2,0x99,0x39,0x3F,0x00,0x81,0x94,0xC1,0x09,0x1A,0x69,0x90,0x80, +0x94,0xAA,0x20,0x2A,0x91,0xB1,0x39,0x7A,0x38,0xD1,0x10,0x8A,0x8C,0x5A,0x01,0xB5, +0x98,0x80,0x2A,0x0B,0x32,0x92,0xF1,0x81,0x9A,0x23,0x8A,0xA3,0xB7,0x09,0x03,0x08, +0xD0,0x94,0x9A,0x09,0x01,0x93,0xB7,0xC2,0x8C,0x3A,0x83,0x99,0x05,0xA0,0x0B,0x29, +0x93,0xE5,0x80,0x89,0x38,0x90,0x8A,0xD7,0xA1,0x19,0x1B,0x48,0x98,0x92,0xC3,0xA1, +0x09,0x3F,0x02,0x0C,0x22,0xC3,0xB2,0xA1,0x01,0x9F,0x4A,0x01,0xA3,0xD3,0xB0,0x28, +0x3F,0x29,0x20,0xA2,0xC2,0xB1,0x08,0x5A,0x98,0x13,0xD2,0xC1,0x01,0xB2,0x80,0x3D, +0x03,0xC1,0x89,0x96,0x90,0x90,0x3A,0x1A,0x9A,0x32,0xB6,0xA2,0x8E,0x4A,0x28,0x8A, +0x84,0xA2,0x8A,0x2D,0x49,0x09,0x88,0x18,0x30,0x9D,0x2C,0x23,0xB1,0x0C,0x92,0x2D, +0x39,0x82,0xC4,0x2E,0x10,0x1A,0x10,0xB9,0x48,0x19,0x39,0xBA,0x34,0xDA,0x2D,0x48, +0x1A,0xA6,0x98,0x83,0x9A,0x1D,0x38,0x04,0xD0,0x18,0x90,0x2C,0x11,0x93,0xD3,0x9A, +0x11,0x08,0x82,0xF1,0x01,0xA0,0x2A,0x93,0xD3,0xB4,0xB8,0x82,0x2F,0x11,0xA3,0xB3, +0xA8,0x3B,0x09,0x23,0x96,0xC8,0x3B,0x3F,0x93,0x82,0xA1,0x90,0x3F,0x28,0x81,0xD1, +0x93,0x08,0x2D,0x18,0x91,0xB3,0xB5,0x98,0x2A,0x2B,0x84,0xB1,0x5B,0x8A,0x31,0x18, +0x80,0x8B,0x7E,0x39,0x2B,0x02,0xC1,0x8B,0x6C,0x49,0x09,0x10,0xA1,0x08,0x01,0x0C, +0x20,0xA1,0x09,0x4F,0x18,0x00,0x01,0xA0,0x5C,0x1B,0x5B,0x10,0x92,0x90,0x2B,0x5A, +0x3D,0x18,0x91,0x19,0x98,0x2D,0x39,0x89,0x2D,0x3A,0x48,0x2C,0x11,0xB5,0x9A,0x19, +0x5B,0x28,0x90,0x95,0x98,0x89,0x2B,0x40,0x08,0x90,0xF3,0x0A,0x08,0xA6,0x80,0x91, +0xB2,0xA0,0x02,0xF2,0xA1,0xB7,0x89,0x81,0x82,0x91,0xB1,0x21,0xAB,0x32,0xE9,0x04, +0xA2,0x8D,0x12,0x91,0xA3,0xA3,0xD2,0x8B,0x39,0xD1,0x84,0xE2,0x90,0x00,0x2B,0x29, +0xA3,0xD4,0xA1,0x91,0x1D,0x5A,0x08,0x19,0x11,0x99,0x08,0x18,0x49,0x0F,0x18,0x10, +0x82,0xF1,0x00,0x89,0x2F,0x3A,0x01,0xB3,0xC2,0x81,0x3F,0x29,0x08,0x10,0xA1,0xA1, +0x3B,0x5D,0x19,0x28,0x0B,0x38,0x82,0x91,0x19,0xBD,0x3B,0x7A,0x80,0x12,0xB3,0xE0, +0x0B,0x6A,0x01,0x88,0xA4,0x08,0x0B,0x08,0x59,0x80,0x80,0x1D,0x49,0x89,0x00,0x84, +0x99,0x1A,0x2B,0x32,0xE3,0xB4,0xA9,0x3A,0x99,0x31,0xE3,0xAA,0x58,0x3B,0x88,0x95, +0xC0,0x18,0x4A,0x09,0x30,0xF2,0xA3,0x1C,0x1B,0x49,0x00,0xD3,0xB2,0xA0,0x18,0x11, +0x92,0xD3,0xB2,0x91,0x80,0xE7,0xA1,0x91,0x98,0x19,0x22,0xC2,0xD2,0x18,0x8D,0x3B, +0x10,0xA5,0x91,0x98,0x02,0x3E,0x80,0x01,0x90,0xAA,0x13,0xF1,0x02,0xD1,0x08,0x19, +0x49,0xB4,0x91,0xB4,0x99,0x2A,0x0C,0x32,0xC0,0x05,0x88,0x0B,0x80,0x2C,0x81,0x10, +0x0B,0x51,0xA9,0x19,0x05,0xBF,0x28,0x20,0xE1,0x90,0x80,0x28,0x19,0x08,0x26,0xB1, +0xA1,0x18,0x88,0x2A,0xF0,0x12,0x8A,0xB3,0x14,0x1B,0xD4,0xD8,0x10,0x08,0x8A,0x17, +0xA0,0x98,0x2B,0x3A,0x29,0x48,0xA4,0x99,0x0E,0x4A,0x12,0x8B,0x31,0x8B,0x4E,0x1A, +0x11,0xB5,0x89,0x91,0x29,0x89,0xC2,0x97,0x90,0x0A,0x19,0x11,0x91,0xC1,0xD5,0x08, +0x89,0x20,0x91,0xB1,0x1A,0x2D,0x18,0x29,0xD2,0x3B,0x3E,0x3A,0x2A,0x90,0x82,0x1C, +0x49,0x3B,0x93,0xB6,0xC8,0x4C,0x02,0x91,0x93,0xF2,0x88,0x2D,0x28,0x81,0x82,0xC1, +0x89,0x2D,0x6B,0x19,0x82,0x80,0x18,0x8B,0x39,0x39,0xC8,0x3A,0x6A,0x0A,0x22,0xD2, +0x09,0x2C,0x1A,0x68,0x92,0xE2,0x89,0x2A,0x2A,0x30,0xC2,0xA3,0xB4,0x1D,0x2A,0x09, +0x93,0x18,0xF2,0x89,0x28,0xB3,0x01,0x8F,0x18,0x11,0xA1,0x93,0x90,0xD1,0x7A,0x20, +0xC3,0xA2,0xA8,0x88,0x1D,0x28,0xA5,0xA2,0xA2,0x0B,0x29,0x2B,0x87,0xC1,0x80,0x0A, +0x19,0x01,0x12,0xF1,0x10,0x80,0x0A,0x18,0x08,0x2F,0x4A,0x02,0x89,0x1B,0x29,0x5D, +0x4C,0x08,0x82,0xA1,0x0A,0x3A,0x4B,0x29,0xC6,0xC3,0x09,0x09,0x88,0x39,0x98,0x82, +0xA5,0x1A,0x30,0x11,0xBD,0x3F,0x12,0x8B,0x28,0xC3,0x88,0x3F,0x2B,0x3B,0x48,0xA1, +0x80,0x8A,0x4D,0x39,0x01,0x93,0xA2,0xF1,0x19,0x19,0x0A,0x02,0xB2,0x8B,0x24,0xD2, +0x4B,0x12,0xC8,0x2E,0x10,0xB5,0x89,0x01,0x09,0x1C,0x2A,0x03,0xD4,0x91,0x98,0x99, +0x11,0x2B,0xE4,0x00,0x00,0x01,0xE0,0xA5,0x89,0x99,0x31,0x18,0xD0,0xB7,0x98,0x18, +0x0A,0x10,0x94,0xC2,0x90,0x18,0x00,0x99,0x87,0xA0,0x90,0x2A,0x3C,0x02,0xB8,0xC1, +0x79,0x1A,0x20,0x08,0xA1,0xD2,0x1C,0x29,0x03,0xD1,0x29,0x99,0x2C,0x50,0xB3,0xD1, +0x08,0x09,0x3C,0x10,0x04,0xB2,0x0D,0x2B,0x59,0x80,0x90,0x01,0x0F,0x3A,0x18,0x01, +0xA2,0x9B,0x5B,0x3D,0x81,0x03,0xD2,0x98,0x59,0x90,0x81,0x92,0xB4,0x8B,0x1B,0x40, +0xB2,0xB5,0x08,0x4B,0x01,0x09,0xD1,0x91,0x8B,0x7A,0x10,0xB3,0xC3,0x99,0x49,0x1A, +0x29,0xB5,0xA2,0xAB,0x40,0x81,0x19,0xB7,0xB0,0x20,0x2B,0xD4,0x88,0xA1,0x91,0x3C, +0x82,0x37,0xD3,0xB1,0x8A,0x1B,0x30,0xB3,0xF4,0xA1,0x91,0x09,0x10,0x03,0xD0,0x83, +0xA9,0x8F,0x10,0x01,0x90,0x18,0x80,0x20,0x2B,0xF1,0x28,0x99,0x2A,0x41,0xF0,0x12, +0xAA,0x83,0x82,0xD1,0xC1,0x08,0x89,0x59,0x09,0x83,0x87,0xB0,0x2A,0x4D,0x18,0x09, +0x19,0xB3,0x4B,0x3F,0x39,0x19,0x09,0x01,0x89,0x03,0x1F,0x00,0x1A,0x0B,0x10,0x68, +0xA0,0x18,0x8C,0x6A,0x09,0x08,0x97,0xA1,0x81,0x1B,0x2B,0x4C,0x03,0xB4,0xA8,0x92, +0x4B,0x3C,0xA1,0x81,0x95,0xA8,0x81,0x12,0xBB,0x92,0x45,0xB9,0x93,0xF4,0x88,0x0A, +0x2D,0x28,0x00,0xA3,0xA3,0x8A,0x3F,0x48,0xB1,0x92,0xB4,0xA8,0x30,0x80,0xD3,0x80, +0xD1,0x19,0x3B,0xC4,0x81,0xC1,0x29,0x0D,0x20,0x13,0xC8,0xB4,0x4C,0x09,0x00,0x82, +0xC2,0x3B,0x0D,0x30,0x0B,0x12,0xF0,0x1B,0x20,0x0A,0xA6,0x80,0x0A,0x4A,0x4A,0x80, +0x94,0xB1,0x2E,0x3B,0x1A,0x10,0x93,0x10,0x4C,0x3D,0x08,0x82,0xC9,0x19,0x6A,0x2B, +0x38,0xD1,0x08,0x19,0x2A,0x5A,0x82,0xB1,0x8D,0x29,0x78,0x09,0x82,0x0A,0x2C,0x1B, +0x19,0x41,0xB8,0x8C,0x79,0x2B,0x11,0x88,0x82,0x91,0xDC,0x28,0x11,0xB0,0x11,0x18, +0xC9,0x62,0xA1,0x91,0x98,0x3B,0x3A,0xB0,0xF4,0x01,0xC0,0x29,0x39,0xF8,0x95,0x91, +0x88,0x88,0x91,0x03,0xA1,0xE2,0x18,0x82,0xD1,0xA2,0xD1,0x80,0x19,0x20,0x83,0xB1, +0xE3,0x80,0x91,0x4D,0x1A,0x03,0xB2,0x09,0x18,0xD1,0x19,0x09,0x92,0xA6,0xA0,0xB6, +0xB2,0x8B,0x38,0x10,0x42,0xD3,0xD0,0xA8,0x20,0x2C,0x10,0x01,0xB1,0xB4,0xAB,0x5B, +0x79,0x80,0x10,0x1A,0xA8,0x3D,0x18,0x20,0xB3,0x8F,0x18,0x01,0x00,0x09,0xF3,0x89, +0x69,0x88,0x81,0x91,0x08,0xE1,0x1A,0x08,0x11,0x81,0x1E,0x29,0xA0,0x01,0x00,0x90, +0x3E,0x7B,0x18,0x82,0xC3,0xA1,0x2A,0x2C,0x5B,0x81,0xA5,0x90,0x81,0x00,0x0B,0x1A, +0x1C,0x2C,0x32,0xC0,0xF3,0x80,0x2D,0x2A,0x10,0x02,0xE4,0xC1,0x89,0x4A,0x09,0x01, +0x03,0xD2,0x98,0x2A,0x39,0x8A,0x89,0x26,0xB1,0xB2,0x12,0xC0,0x0A,0x5A,0x18,0x98, +0xF3,0x92,0x99,0x99,0x79,0x01,0xB5,0xA1,0x80,0x80,0x90,0x83,0xA0,0xE2,0x81,0x29, +0x93,0x8A,0x0A,0x6A,0x1F,0x18,0x02,0xC8,0x01,0x19,0x3B,0x4A,0x98,0x17,0xA8,0x0D, +0x38,0xA1,0x91,0x10,0xA2,0x2B,0x4C,0xA6,0x81,0xBA,0x21,0x4C,0x80,0x21,0xD1,0x92, +0x2C,0x08,0x30,0x9F,0x93,0x2A,0x89,0x03,0x8B,0x87,0x0A,0x0D,0x12,0x98,0xA4,0x93, +0xBB,0x59,0x18,0xA1,0x32,0xE9,0x84,0x08,0x8A,0x02,0xA1,0x91,0x4B,0xB4,0x20,0x88, +0xF0,0x3A,0x1A,0x88,0x87,0xB1,0x92,0x0A,0x08,0x6B,0x83,0xC3,0x91,0xC0,0x2B,0x79, +0x08,0x8A,0x84,0xA0,0x89,0x40,0x1B,0xA1,0x39,0x98,0x17,0xC2,0xA2,0x12,0xCD,0x20, +0x89,0x92,0x25,0xB0,0x2D,0x3A,0x8B,0x58,0x2A,0xA0,0x4C,0x08,0x30,0xAE,0x82,0x59, +0x89,0x1A,0x10,0xC2,0x18,0x2C,0x40,0x1E,0x01,0xA3,0x8A,0x81,0x2C,0x29,0x29,0xA9, +0x13,0x51,0xAD,0x12,0x89,0x8F,0x18,0x2C,0x39,0x00,0xC1,0x10,0x3C,0x2A,0x41,0xC8, +0xA2,0x91,0x0A,0x6C,0x10,0x12,0x88,0xE8,0x30,0x91,0x81,0xD8,0x01,0x1B,0x0D,0x07, +0x00,0xA8,0x92,0x0A,0x28,0xD2,0xC3,0x02,0xAA,0x94,0x81,0xB4,0xB3,0x1A,0x0B,0x13, +0xF9,0x16,0xA1,0x8A,0x59,0x19,0x02,0xC1,0x91,0x8B,0x3D,0x18,0x3B,0xA4,0x94,0x80, +0x99,0x88,0x1C,0x79,0x0A,0x02,0x03,0xF8,0x90,0x39,0x5B,0x19,0x02,0xC3,0x90,0xBB, +0x58,0x6A,0x09,0x02,0x89,0x91,0x88,0x1A,0x69,0x8A,0x19,0x15,0xA0,0xA2,0x00,0x9A, +0x6B,0x49,0x88,0xA3,0x92,0xBB,0x6B,0x3D,0x38,0x01,0x98,0x91,0x3F,0x09,0x18,0x20, +0x90,0x80,0xAC,0x70,0x91,0x9B,0x51,0x09,0x88,0x99,0x14,0x8B,0x98,0x83,0x79,0xA0, +0x99,0x13,0x01,0x19,0xE0,0x83,0x0B,0xB0,0x0C,0x31,0x95,0xB5,0xC2,0x8A,0x39,0x20, +0x80,0x39,0xF3,0xB1,0x10,0x88,0x5E,0x18,0x94,0xA1,0x88,0xA1,0x98,0x15,0xAA,0x39, +0xD4,0x84,0xC0,0xA2,0xA2,0x0C,0x81,0x86,0xB5,0xA1,0xB1,0x14,0x1B,0xB1,0x02,0x92, +0xC3,0xE0,0x88,0x11,0xAA,0x69,0x18,0x81,0xA3,0xB0,0x01,0xBF,0x2A,0x31,0x93,0xF1, +0x00,0x89,0x18,0x19,0x11,0xD3,0xE0,0x10,0x18,0xB1,0x18,0x24,0x9A,0x2B,0xA4,0xC0, +0xB0,0x31,0x6C,0x19,0xB4,0x12,0xA8,0xEA,0x58,0x10,0x8B,0x93,0x82,0x88,0x9A,0x41, +0x10,0xC3,0xEA,0x41,0xA9,0x9C,0x34,0xA1,0x2A,0x79,0xA2,0x01,0xA8,0xB3,0x28,0xCC, +0x41,0x9A,0xB3,0x4B,0xB3,0x27,0x8B,0x83,0x2B,0x2F,0x08,0x28,0xB2,0x80,0x2C,0x30, +0x5E,0x09,0x12,0x9B,0x09,0x22,0x5B,0x19,0x8A,0x11,0x59,0x99,0xA4,0x32,0xCD,0x18, +0x08,0x10,0x85,0xB3,0xB4,0x1E,0x88,0x28,0x8A,0x11,0x09,0xC0,0x79,0x80,0x91,0x3B, +0x80,0x10,0x0F,0x01,0x80,0x91,0x19,0x3D,0x92,0x28,0xA8,0x37,0x9A,0x0A,0x3A,0x8A, +0x45,0xA9,0xA4,0x00,0xAA,0x09,0x3D,0x59,0x20,0xE1,0x08,0x98,0x90,0x59,0x10,0x09, +0xA3,0xC3,0x93,0x99,0x2B,0x69,0x11,0xD1,0xB1,0xA4,0x91,0x3C,0x89,0x83,0xF0,0x10, +0x91,0xA1,0x89,0x59,0x05,0x99,0x93,0x94,0xC8,0x08,0x0A,0x09,0x17,0xB1,0x83,0xC1, +0x91,0x40,0xA2,0xC2,0x98,0xC3,0xBA,0x28,0x23,0x0F,0x80,0x50,0xB8,0x19,0x10,0x96, +0x98,0x8C,0x05,0x98,0x19,0x29,0x2B,0x3B,0x0A,0xE2,0x01,0x0F,0x3C,0x38,0x08,0x09, +0x81,0x4A,0x6C,0x08,0x00,0x88,0x98,0x38,0x2C,0x5A,0x1B,0x20,0x1A,0x39,0xB0,0x09, +0xCB,0x5B,0x49,0x09,0x71,0x00,0xC1,0x0E,0x08,0x38,0x0C,0x02,0x10,0x0E,0x10,0x8A, +0x48,0x19,0x90,0x92,0x0D,0xA3,0x98,0x3B,0x79,0x19,0x01,0x10,0xE1,0x80,0x19,0x2B, +0x10,0xF2,0x02,0xAB,0x84,0x9A,0x29,0xB4,0x80,0x92,0x03,0x88,0x95,0xD0,0x03,0x90, +0xA0,0xC7,0xA1,0xB0,0xA2,0x02,0x18,0xB5,0xD4,0x01,0xC0,0x08,0xA2,0x93,0xA8,0xA0, +0xC3,0x20,0xF3,0x90,0x00,0xD5,0x08,0x89,0xA5,0x80,0xA0,0x81,0x82,0xC2,0x09,0xD1, +0x13,0xCB,0x03,0x84,0x91,0xE1,0x1B,0x12,0x08,0xAB,0x87,0x18,0xAB,0x58,0x89,0x28, +0x81,0xC9,0x33,0xA9,0x80,0x2E,0x20,0x83,0xB9,0x20,0x3B,0x9E,0x7A,0x08,0x81,0x18, +0x0B,0x88,0x79,0x80,0x8B,0x00,0x12,0x0E,0x89,0x51,0x1B,0x81,0xA0,0x3A,0x01,0xAF, +0x11,0x28,0xBA,0x35,0x98,0x88,0x52,0xC0,0x83,0x2F,0xA9,0x11,0x0A,0x19,0x25,0xD0, +0x30,0x9C,0x08,0x21,0x98,0x81,0x2A,0xF3,0x2A,0x80,0xB6,0x2B,0x08,0x93,0xE9,0x02, +0x81,0x8C,0x21,0x00,0xA6,0xA9,0x94,0x01,0x8F,0x80,0x94,0x98,0x93,0xB4,0x00,0x08, +0xC0,0x14,0x98,0xB3,0xB4,0xC1,0x09,0x18,0xA7,0x00,0xA3,0xC8,0x0A,0x3C,0x19,0x96, +0x83,0xC1,0x99,0x19,0x4A,0x85,0x80,0xC1,0x91,0x99,0x90,0x2A,0x17,0x95,0x99,0x88, +0x12,0xAE,0x39,0x08,0x92,0x84,0xB0,0xA8,0x79,0x09,0x19,0x01,0xB2,0xA3,0x8F,0x28, +0x2B,0xA2,0x40,0x82,0xA0,0x4C,0xA9,0x39,0x8D,0x81,0x70,0x88,0xA0,0x1A,0x49,0x2D, +0x1A,0x26,0xA8,0x98,0x08,0x29,0x0B,0x12,0x96,0xB1,0xB2,0x3A,0x13,0x9B,0x60,0xA0, +0x88,0xB2,0x34,0xEA,0x1A,0x2A,0x79,0x98,0x10,0x04,0x8C,0x1C,0x81,0x04,0x8C,0x83, +0x19,0x2F,0x81,0x93,0x98,0x10,0x08,0x30,0x2A,0xFA,0x05,0x08,0x2A,0x89,0x91,0xA3, +0xFA,0x11,0x11,0x00,0x8C,0x04,0x8A,0x2A,0xB5,0x10,0xA9,0xC2,0x3D,0x1B,0x32,0x04, +0x0A,0x1A,0x09,0x40,0x1F,0x92,0x1D,0x2A,0x91,0x10,0x30,0x2F,0x0B,0x68,0x99,0xA2, +0x92,0x88,0x78,0xA9,0x20,0x28,0xE2,0x92,0x1A,0x99,0x4B,0x19,0x22,0xA1,0xE2,0x21, +0x2F,0x98,0x29,0x18,0x91,0x08,0xB0,0x79,0x1A,0x82,0x3B,0xB1,0xA7,0x8A,0xB3,0x98, +0x5B,0x23,0xCA,0x42,0x83,0xF0,0x90,0x18,0x98,0x08,0xB4,0x20,0xA3,0xC0,0x43,0xD8, +0x80,0x81,0xA3,0x99,0xD9,0xA7,0x19,0x90,0x10,0x05,0xB1,0x8B,0x02,0xA4,0xBD,0x23, +0x93,0x8A,0x99,0x4B,0x03,0xC1,0xF8,0x38,0x09,0x2B,0x14,0xD0,0x03,0x8A,0x2A,0x39, +0xB9,0x97,0x90,0xAA,0x50,0x01,0x99,0x51,0xD1,0x09,0x1A,0xB5,0x00,0x8B,0x93,0x08, +0x98,0x11,0xF9,0x85,0x2B,0x08,0x96,0x89,0x90,0x2A,0x12,0x4A,0xD8,0x85,0x2B,0x0E, +0x10,0x00,0x01,0xB1,0x9B,0x69,0x1A,0x90,0x40,0xB8,0x01,0x08,0x0A,0x2C,0x09,0x14, +0x4B,0xE2,0x82,0x88,0xB1,0x78,0x0A,0x01,0xC2,0x93,0x19,0xCE,0x20,0x3C,0x82,0xB4, +0x1B,0x20,0x8C,0x3B,0x29,0xAB,0x86,0x23,0xD8,0x81,0x9A,0x5A,0x49,0xB0,0x16,0xA0, +0xB0,0x28,0x1B,0x13,0x93,0xE4,0xA2,0xA9,0x08,0x5A,0xB3,0x12,0xC1,0xE1,0x10,0x88, +0x01,0x0C,0x92,0x08,0x89,0xB7,0x88,0x81,0x10,0x9A,0x17,0xA0,0xB0,0x13,0x99,0xE0, +0x39,0x31,0xD2,0xB2,0x80,0x0B,0x2D,0x49,0x80,0x01,0xB0,0x06,0x09,0x0C,0x3A,0x69, +0xA0,0x08,0xB2,0xA1,0x69,0x2B,0x5A,0x81,0x92,0xBA,0x21,0xB1,0x7D,0x10,0x80,0x08, +0x88,0x82,0x32,0x0D,0xB0,0x1A,0x1C,0x21,0x94,0xA9,0x58,0xB9,0x5A,0x4A,0xA0,0x13, +0xA9,0x80,0x7C,0x00,0x20,0x8A,0x04,0x0C,0x00,0x82,0x2A,0xB2,0xAC,0x4B,0x69,0xA0, +0xA6,0x81,0x9B,0x19,0x38,0x8B,0x17,0xB2,0x81,0x2A,0xBB,0x94,0x29,0xA2,0x15,0xBA, +0x97,0xA3,0xB9,0x79,0x01,0xB2,0x02,0xF1,0x90,0x0A,0x29,0x11,0x88,0xE5,0xA0,0x81, +0x19,0x91,0x90,0x28,0xB3,0x14,0xD0,0xB5,0x91,0x9A,0x29,0x0B,0x07,0xA2,0xB3,0x01, +0x9D,0x28,0x41,0xD0,0x91,0x90,0x82,0x1A,0xA8,0x44,0x9A,0xA9,0x21,0xE3,0xA9,0x4B, +0x19,0x78,0x89,0x83,0xA3,0xB9,0x5A,0x3D,0x80,0x82,0xA2,0xA0,0x6C,0x10,0x20,0x8B, +0x93,0x8B,0x0E,0x33,0xA9,0xB1,0x68,0x8A,0x31,0xAC,0x94,0xB4,0x8B,0x32,0x0B,0xB4, +0x81,0x91,0x1D,0x33,0xD9,0x31,0xE1,0x8B,0x3B,0x30,0x12,0x49,0xD2,0x8E,0x29,0x18, +0x8A,0x92,0x02,0xAA,0x59,0x1C,0x32,0x88,0x01,0x23,0xFB,0x83,0x29,0xDA,0x59,0x01, +0x81,0x92,0xE1,0x18,0x8A,0x1D,0x30,0x93,0xF1,0x00,0x01,0x0B,0x39,0x92,0x89,0xA0, +0x11,0x5B,0xE0,0x82,0x09,0x13,0xAA,0xB4,0x16,0xD8,0x91,0x2A,0x29,0x84,0x1B,0xC5, +0x98,0x98,0x31,0x98,0x99,0x17,0xA9,0x20,0x92,0xC3,0x18,0x9D,0x20,0x3D,0x89,0x94, +0xA2,0x1C,0x5C,0x29,0x39,0xA0,0xB3,0x00,0x0C,0x4C,0x48,0x92,0x0A,0x91,0x85,0x9A, +0x01,0x82,0x1F,0x10,0x99,0x15,0xC1,0xA0,0x39,0x1A,0x1D,0x85,0xB4,0x90,0x1A,0x2A, +0x4B,0x01,0xB2,0x93,0xBE,0x12,0x83,0xC9,0x18,0x09,0x20,0x78,0xF1,0x08,0x19,0x88, +0x3A,0x83,0xB3,0xA9,0x93,0x7A,0x0A,0x96,0x98,0x00,0xA8,0x3A,0x30,0x92,0xF2,0x9B, +0x3D,0x38,0x92,0x92,0xC3,0xB8,0x6B,0x29,0x01,0x01,0xB2,0x2F,0x09,0x19,0x18,0x01, +0x3B,0x7B,0x10,0xA1,0x90,0x39,0x0F,0x38,0x0A,0xB5,0xA4,0x89,0x8B,0x6A,0x2B,0x12, +0xC8,0x90,0x40,0x2A,0x9E,0x22,0x88,0x18,0x09,0x3A,0xC3,0xE8,0x09,0x59,0x08,0x12, +0x94,0xD0,0x1A,0x2C,0x38,0x00,0xA1,0x83,0xE8,0x08,0x3A,0x08,0x10,0x9E,0x83,0x1D, +0x92,0x19,0x2C,0x39,0x3B,0x59,0x04,0xE1,0x80,0x08,0x8D,0x21,0x81,0xB2,0xB2,0x02, +0x99,0x91,0xA4,0xD6,0x98,0x99,0x03,0x80,0x98,0xA7,0x91,0x09,0xA1,0xB2,0xB3,0xE1, +0x12,0x92,0xB1,0x81,0x06,0x99,0x0A,0x23,0xC4,0xB1,0xF2,0x89,0x19,0x3A,0x94,0x82, +0xE0,0x89,0x38,0x0B,0xA4,0xA5,0x80,0x80,0x8C,0x34,0xB9,0xA9,0x23,0x13,0xB9,0xC1, +0xC7,0x1B,0x89,0x10,0x20,0x11,0xE3,0xA8,0x4B,0x0B,0x40,0x91,0x90,0x1B,0x5F,0x2A, +0x18,0x82,0x91,0x0B,0x4A,0x28,0xCA,0x40,0x80,0x5B,0x2C,0x13,0xB0,0x8A,0xA9,0x5A, +0x58,0x89,0x82,0x88,0x2E,0x3B,0x31,0xA1,0x9B,0x01,0x7A,0x2C,0x01,0x91,0x93,0x3F, +0x88,0x39,0x10,0xF1,0x91,0x8B,0x48,0x0A,0x12,0xE3,0xA8,0x18,0x28,0x92,0x97,0x98, +0x99,0x19,0xA1,0x11,0xB6,0x88,0x3B,0x10,0xD3,0xC3,0xA1,0x2A,0x8A,0x49,0x04,0xF1, +0x91,0x02,0x8A,0x89,0x04,0xF1,0x98,0x80,0x18,0x12,0xE3,0x81,0x98,0x80,0x01,0xB3, +0xF2,0x99,0x12,0x2A,0xB5,0xB3,0x92,0xAA,0x19,0x50,0xB2,0xC3,0x92,0xD0,0x2B,0x68, +0x93,0x99,0xC0,0x2C,0x3E,0x80,0x20,0x08,0x93,0x0D,0x2A,0x31,0x8D,0x02,0x2B,0x91, +0x08,0x0A,0x03,0x2C,0x3C,0x52,0xB9,0xA0,0x12,0xBF,0x3A,0x29,0x01,0x88,0xC0,0x6A, +0x3C,0x0A,0x49,0x18,0x0B,0x39,0x2B,0x69,0x0A,0x84,0x2A,0x2A,0x1C,0x2A,0xC3,0x8C, +0x19,0x50,0x09,0x91,0xA7,0x8D,0x18,0x1A,0x28,0x00,0xA0,0x94,0x10,0x1F,0x20,0x90, +0x8A,0x12,0xD0,0x1A,0x5A,0x81,0x04,0xBC,0x23,0x10,0xE0,0x90,0x90,0x18,0x1A,0xA6, +0x12,0xB1,0xD0,0x4A,0x08,0x82,0x92,0xB6,0x9A,0x0A,0x12,0x88,0xC3,0xC5,0x8A,0x89, +0x20,0xB5,0x93,0x0B,0x18,0x00,0x09,0xF2,0x88,0x2A,0x4A,0x08,0x05,0xB2,0xA9,0x3B, +0x5D,0x28,0xA4,0xB1,0x00,0x19,0x19,0x7A,0xA3,0xB3,0x0A,0x90,0xA1,0xC4,0x80,0xBA, +0x50,0x13,0xC1,0xC2,0x9A,0x2A,0x7B,0x28,0x84,0xC1,0x09,0x3B,0x4E,0x20,0x91,0xA1, +0x18,0xAB,0x79,0x10,0xB4,0x08,0x9A,0x11,0x2B,0xF0,0x93,0xAA,0x01,0x6A,0x01,0x93, +0x80,0xB8,0x2A,0x5B,0x10,0x80,0x89,0x4A,0x5B,0x92,0x15,0xB2,0xA0,0x2F,0x19,0x93, +0xB8,0x95,0x80,0x1C,0x21,0xA9,0x02,0x0B,0xA0,0x5A,0x18,0x98,0x39,0x1B,0x68,0x00, +0x91,0x91,0x9C,0x39,0x3E,0x18,0x84,0xB3,0x9B,0x7A,0x08,0x18,0x0A,0xB5,0x91,0x0B, +0x28,0x39,0x19,0x90,0x0A,0x50,0xAC,0x11,0x01,0xAB,0x88,0x52,0x1B,0x83,0xC4,0xA2, +0x9A,0xAB,0x03,0x90,0x19,0x93,0x81,0x08,0x92,0x9A,0x68,0x98,0x19,0x39,0xC1,0x92, +0x8A,0x38,0x4E,0x02,0xB1,0x90,0xC3,0x18,0x2B,0x04,0xC3,0xD2,0x91,0x90,0x81,0x89, +0x13,0xF1,0x88,0x93,0xA2,0x00,0x91,0xC0,0x5B,0x21,0x99,0x93,0x06,0x9A,0x1B,0x48, +0x99,0xB7,0x90,0x89,0x18,0x1B,0x11,0xA4,0xB2,0x81,0x9A,0x08,0x97,0x98,0x91,0x10, +0xB8,0x06,0xA2,0xA0,0x29,0x2B,0x21,0xC2,0xD1,0x10,0x1A,0x4A,0x29,0xF1,0x98,0x29, +0x1B,0x31,0x10,0xA0,0xA1,0x1D,0x5A,0x29,0xB2,0x82,0xA8,0x0F,0x28,0x21,0x09,0x91, +0x82,0x4D,0x10,0xA3,0xB0,0x89,0x4C,0x39,0xA0,0xA4,0xA1,0x89,0x1E,0x28,0x29,0xA3, +0xC3,0x2D,0x19,0x01,0x49,0x01,0x9B,0x0C,0x21,0xC2,0xA2,0x93,0x7C,0x2A,0x10,0x90, + +/* Source: 08HH.ROM */ +/* Length: 384 / 0x00000180 */ + +0x75,0xF2,0xAB,0x7D,0x7E,0x5C,0x3B,0x4B,0x3C,0x4D,0x4A,0x02,0xB3,0xC5,0xE7,0xE3, +0x92,0xB3,0xC4,0xB3,0xC3,0x8A,0x3B,0x5D,0x5C,0x3A,0x84,0xC2,0x91,0xA4,0xE7,0xF7, +0xF7,0xF4,0xA1,0x1B,0x49,0xA5,0xB1,0x1E,0x7F,0x5A,0x00,0x89,0x39,0xB7,0xA8,0x3D, +0x4A,0x84,0xE7,0xF7,0xE2,0x2D,0x4C,0x3A,0x4E,0x7D,0x04,0xB0,0x2D,0x4B,0x10,0x80, +0xA3,0x99,0x10,0x0E,0x59,0x93,0xC4,0xB1,0x81,0xC4,0xA2,0xB2,0x88,0x08,0x3F,0x3B, +0x28,0xA6,0xC3,0xA2,0xA2,0xC5,0xC1,0x3F,0x7E,0x39,0x81,0x93,0xC2,0xA3,0xE5,0xD2, +0x80,0x93,0xB8,0x6D,0x49,0x82,0xD4,0xA1,0x90,0x01,0xA0,0x09,0x04,0xE3,0xB2,0x91, +0xB7,0xB3,0xA8,0x2A,0x03,0xF3,0xA1,0x92,0xC5,0xC3,0xB2,0x0B,0x30,0xB3,0x8E,0x6D, +0x4A,0x01,0xB4,0xB4,0xC4,0xC3,0x99,0x3B,0x12,0xE3,0xA1,0x88,0x82,0xB4,0x9A,0x5C, +0x3A,0x18,0x93,0xC3,0xB3,0xB4,0xA8,0x19,0x04,0xF3,0xA8,0x3B,0x10,0xA2,0x88,0xA5, +0xB2,0x0B,0x6D,0x4B,0x10,0x91,0x89,0x3C,0x18,0x18,0xA6,0xC4,0xC3,0x98,0x19,0x2B, +0x20,0x91,0xA0,0x4E,0x28,0x93,0xB3,0xC2,0x92,0xA9,0x5A,0x96,0xC4,0xC2,0x09,0x01, +0xC4,0xA1,0x92,0xC4,0xA1,0x89,0x10,0xA3,0xA1,0x90,0x1C,0x5A,0x01,0xC5,0xA1,0x92, +0xD4,0xB3,0xC4,0xC4,0xC3,0xA1,0x88,0x1A,0x28,0x89,0x3C,0x3A,0x3D,0x29,0x00,0x93, +0xB0,0x3D,0x28,0x80,0x91,0x82,0xE3,0x99,0x2A,0x11,0xD6,0xC3,0x99,0x29,0x82,0xC4, +0xC3,0xA1,0x0A,0x3B,0x3D,0x3A,0x02,0xC3,0xA2,0x99,0x3B,0x2C,0x7C,0x28,0x81,0xA3, +0xB2,0xA3,0xB1,0x08,0x1A,0x3C,0x18,0x2E,0x4C,0x39,0xA5,0xB3,0xB4,0xC2,0x88,0x08, +0x19,0x0A,0x49,0xB7,0xB3,0xA2,0xA1,0x92,0xA1,0x93,0xB1,0x0C,0x7D,0x39,0x93,0xB3, +0xB1,0x1A,0x19,0x5D,0x28,0xA6,0xC4,0xB2,0x90,0x09,0x2A,0x18,0x1B,0x5B,0x28,0x88, +0x2C,0x29,0x82,0xA0,0x18,0x91,0x2D,0x29,0x2B,0x5C,0x4C,0x3B,0x4C,0x28,0x80,0x92, +0x90,0x09,0x2B,0x28,0x1D,0x6B,0x11,0xC5,0xB2,0x0B,0x39,0x09,0x4D,0x28,0x88,0x00, +0x1B,0x28,0x94,0xE3,0xA0,0x1A,0x28,0xB5,0xB4,0xB3,0xB2,0x93,0xE2,0x91,0x92,0xD4, +0xA0,0x1B,0x4A,0x01,0xA1,0x88,0x2D,0x5C,0x3B,0x28,0x08,0x93,0xD4,0xB2,0x91,0xB4, +0xA0,0x3E,0x3B,0x4B,0x3B,0x29,0x08,0x93,0x9B,0x7B,0x3A,0x19,0x00,0x80,0x80,0xA0, + +/* Source: 10TOM.ROM */ +/* Length: 640 / 0x00000280 */ + +0x77,0x27,0x87,0x01,0x2D,0x4F,0xC3,0xC1,0x92,0x91,0x89,0x59,0x83,0x1A,0x32,0xC2, +0x95,0xB1,0x81,0x88,0x81,0x4A,0x3D,0x11,0x9E,0x0B,0x88,0x0C,0x18,0x3B,0x11,0x11, +0x91,0x00,0xA0,0xE2,0x0A,0x48,0x13,0x24,0x81,0x48,0x1B,0x39,0x1C,0x83,0x84,0xA1, +0xD1,0x8E,0x8A,0x0B,0xC0,0x98,0x92,0xB8,0x39,0x90,0x10,0x92,0xF0,0xB5,0x88,0x32, +0x49,0x51,0x21,0x03,0x82,0x10,0x8A,0x7A,0x09,0x00,0xA2,0xCA,0x1B,0xCC,0x1C,0xB9, +0x8E,0x89,0x89,0xA1,0x89,0x92,0x29,0x11,0x60,0x40,0x14,0x22,0x32,0x78,0x40,0x01, +0x02,0x90,0x81,0xAB,0x0B,0x00,0xAF,0x99,0xCC,0xAB,0xDA,0xA9,0x99,0x1B,0x30,0x14, +0x92,0x22,0x19,0x68,0x32,0x14,0x26,0x13,0x23,0x23,0x20,0x12,0x9A,0xA8,0xB9,0xFA, +0xAA,0xCA,0xCC,0x0C,0xA8,0xAE,0x88,0xB9,0x88,0xA0,0x02,0x21,0x50,0x43,0x03,0x81, +0x2A,0x11,0x34,0x63,0x24,0x33,0x22,0x38,0x8B,0xEA,0xAE,0x99,0xA0,0x90,0x82,0x00, +0x89,0xBF,0x8A,0xE8,0xA9,0x90,0x01,0x12,0x13,0x12,0x08,0xA9,0xAA,0xC9,0x22,0x63, +0x63,0x12,0x44,0x00,0x10,0x88,0x9C,0x98,0xA1,0x85,0x03,0x32,0x36,0x80,0x89,0xDB, +0xDB,0xBB,0xB9,0xBA,0x01,0x81,0x28,0x19,0xCB,0xFA,0xBC,0x09,0x13,0x37,0x34,0x34, +0x23,0x31,0x20,0x10,0x00,0x00,0x28,0x38,0x10,0x88,0xEC,0x8D,0xCB,0xBC,0xCC,0xBB, +0xBB,0xC9,0x99,0x00,0x00,0x33,0x11,0x22,0x81,0x07,0x41,0x54,0x34,0x34,0x22,0x31, +0x00,0x88,0x9A,0x9B,0x98,0xAB,0x8E,0x9B,0xBD,0x9C,0xBC,0xBB,0xDA,0xAA,0xA9,0x99, +0x18,0x38,0x60,0x20,0x31,0x13,0x13,0x51,0x14,0x31,0x53,0x33,0x35,0x22,0x01,0x8A, +0x9C,0xA9,0xCA,0xC9,0xA8,0x00,0x10,0x81,0x9C,0x9E,0xAB,0xCC,0xAB,0xBA,0x98,0x30, +0x52,0x03,0x81,0x08,0x9C,0xAC,0xAC,0x18,0x11,0x03,0x51,0x61,0x41,0x31,0x31,0x02, +0x01,0x20,0x24,0x43,0x44,0x40,0x30,0x10,0xBC,0xBE,0xCB,0xDB,0xAB,0xBA,0x99,0x98, +0x99,0xAA,0xBD,0xAA,0xC8,0x90,0x11,0x53,0x37,0x23,0x43,0x34,0x33,0x33,0x33,0x11, +0x28,0x00,0x19,0xA9,0x9A,0xCB,0xCE,0xBB,0xEB,0xBC,0xBB,0xCA,0xBA,0xA8,0x88,0x11, +0x12,0x21,0x20,0x22,0x26,0x26,0x23,0x23,0x43,0x24,0x22,0x32,0x20,0x31,0x81,0x9A, +0xBC,0xBC,0xCB,0xBD,0x9A,0xA9,0x90,0x98,0xBA,0xCC,0xCB,0xBC,0x8B,0x88,0x22,0x35, +0x23,0x12,0x99,0x8B,0xAA,0xAA,0x89,0x82,0x93,0x31,0x42,0x23,0x23,0x21,0x32,0x11, +0x20,0x13,0x13,0x24,0x24,0x24,0x22,0x11,0x8A,0x9E,0xAC,0xAC,0xAA,0xBA,0xAA,0xAB, +0xBD,0xBC,0xCB,0xCB,0xA9,0xA8,0x91,0x12,0x44,0x43,0x44,0x34,0x34,0x42,0x33,0x42, +0x21,0x11,0x11,0x88,0x80,0xAA,0x0B,0xAC,0xCB,0xEC,0xAC,0xBA,0xCA,0xAB,0x9A,0x99, +0x80,0x91,0x09,0x08,0x10,0x22,0x44,0x43,0x44,0x33,0x43,0x22,0x13,0x21,0x22,0x20, +0x09,0x88,0xB9,0xC8,0xBB,0xAB,0xAB,0xA9,0xA9,0x9B,0x9B,0x99,0x90,0x90,0x00,0x81, +0x00,0x08,0x09,0x8A,0x9A,0xAA,0xA9,0xA9,0x99,0x90,0x80,0x01,0x80,0x00,0x09,0x31, +0x32,0x44,0x33,0x43,0x34,0x33,0x24,0x22,0x23,0x12,0x10,0x09,0x9B,0xAB,0xCA,0xCC, +0xBB,0xCB,0xDA,0xCA,0xAB,0xCA,0xAB,0xA9,0xA8,0x92,0x12,0x43,0x53,0x35,0x23,0x33, +0x43,0x43,0x52,0x22,0x22,0x21,0x01,0x09,0x89,0xA9,0xBB,0xBD,0xBC,0xCB,0xDA,0xAB, +0xAB,0xAB,0xAA,0xA9,0x99,0xA8,0x09,0x01,0x11,0x34,0x25,0x23,0x33,0x51,0x22,0x31, +0x12,0x20,0x21,0x12,0x10,0x80,0x99,0x9A,0x99,0x99,0x88,0x08,0x00,0x88,0xA9,0x99, +0x99,0x80,0x80,0x10,0x01,0x00,0x9A,0xAA,0xBB,0xBA,0xBA,0xA9,0x99,0x99,0x89,0x99, +0x99,0x00,0x01,0x33,0x35,0x24,0x23,0x34,0x23,0x33,0x34,0x33,0x43,0x32,0x21,0x88, +0xAB,0xBD,0xBB,0xDB,0xAB,0xBA,0xBB,0xDA,0xBB,0xCB,0xBB,0xBC,0xA8,0x90,0x01,0x12, +0x23,0x43,0x53,0x34,0x34,0x39,0x80,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x08,0x00, + +/* Source: 20RIM.ROM */ +/* Length: 128 / 0x00000080 */ + +0x0F,0xFF,0x73,0x8E,0x71,0xCD,0x00,0x49,0x10,0x90,0x21,0x49,0xA0,0xDB,0x02,0x3A, +0xE3,0x0A,0x50,0x98,0xC0,0x59,0xA2,0x99,0x09,0x22,0xA2,0x80,0x10,0xA8,0x5B,0xD2, +0x88,0x21,0x09,0x96,0xA8,0x10,0x0A,0xE0,0x08,0x48,0x19,0xAB,0x52,0xA8,0x92,0x0C, +0x03,0x19,0xE2,0x0A,0x12,0xC2,0x81,0x1E,0x01,0xD0,0x48,0x88,0x98,0x01,0x49,0x91, +0xAA,0x2C,0x25,0x89,0x88,0xB5,0x81,0xA2,0x9A,0x12,0x9E,0x38,0x3B,0x81,0x9B,0x59, +0x01,0x93,0xCA,0x4A,0x21,0xA0,0x3D,0x0A,0x39,0x3D,0x12,0xA8,0x3F,0x18,0x01,0x92, +0x1C,0x00,0xB2,0x48,0xB9,0x94,0xA3,0x19,0x4F,0x19,0xB2,0x32,0x90,0xBA,0x01,0xE6, +0x91,0x80,0xC1,0xA4,0x2A,0x08,0xA1,0xB1,0x25,0xD2,0x88,0x99,0x21,0x80,0x88,0x80, +}; diff --git a/thirdparty/opnmidi/chips/mamefm/resampler.cpp b/thirdparty/opnmidi/chips/mamefm/resampler.cpp new file mode 100644 index 0000000..089c1b4 --- /dev/null +++ b/thirdparty/opnmidi/chips/mamefm/resampler.cpp @@ -0,0 +1,137 @@ +// SPDX-License-Identifier: GPL-2.0-only +#include "resampler.hpp" + +enum Stereo +{ + LEFT = 0, + RIGHT = 1 +}; + +static const size_t SMPL_BUF_SIZE_ = 0x10000; + +namespace chip +{ + AbstractResampler::AbstractResampler() + { + for (int pan = LEFT; pan <= RIGHT; ++pan) { + destBuf_[pan] = new sample[SMPL_BUF_SIZE_](); + } + } + + AbstractResampler::~AbstractResampler() + { + for (int pan = LEFT; pan <= RIGHT; ++pan) { + delete[] destBuf_[pan]; + } + } + + void AbstractResampler::init(int srcRate, int destRate, size_t maxDuration) + { + srcRate_ = srcRate; + maxDuration_ = maxDuration; + destRate_ = destRate; + updateRateRatio(); + } + + void AbstractResampler::setDestributionRate(int destRate) + { + destRate_ = destRate; + updateRateRatio(); + } + + void AbstractResampler::setMaxDuration(size_t maxDuration) + { + maxDuration_ = maxDuration; + } + + /****************************************/ + sample** LinearResampler::interpolate(sample** src, size_t nSamples, size_t intrSize) + { + (void)intrSize; + // Linear interplation + for (int pan = LEFT; pan <= RIGHT; ++pan) { + for (size_t n = 0; n < nSamples; ++n) { + float curnf = n * rateRatio_; + int curni = static_cast(curnf); + float sub = curnf - curni; + if (sub) { + destBuf_[pan][n] = static_cast(src[pan][curni] + (src[pan][curni + 1] - src[pan][curni]) * sub); + } + else /* if (sub == 0) */ { + destBuf_[pan][n] = src[pan][curni]; + } + } + } + + return destBuf_; + } + + /****************************************/ + const float SincResampler::F_PI_ = 3.14159265f; + const int SincResampler::SINC_OFFSET_ = 16; + + void SincResampler::init(int srcRate, int destRate, size_t maxDuration) + { + AbstractResampler::init(srcRate, destRate, maxDuration); + initSincTables(); + } + + void SincResampler::setDestributionRate(int destRate) + { + AbstractResampler::setDestributionRate(destRate); + initSincTables(); + } + + void SincResampler::setMaxDuration(size_t maxDuration) + { + AbstractResampler::setMaxDuration(maxDuration); + initSincTables(); + } + + sample** SincResampler::interpolate(sample** src, size_t nSamples, size_t intrSize) + { + // Sinc interpolation + size_t offsetx2 = SINC_OFFSET_ << 1; + + for (int pan = LEFT; pan <= RIGHT; ++pan) { + for (size_t n = 0; n < nSamples; ++n) { + size_t seg = n * offsetx2; + int curn = static_cast(n * rateRatio_); + int k = curn - SINC_OFFSET_; + if (k < 0) k = 0; + int end = curn + SINC_OFFSET_; + if (static_cast(end) > intrSize) end = static_cast(intrSize); + sample samp = 0; + for (; k < end; ++k) { + samp += static_cast(src[pan][k] * sincTable_[seg + SINC_OFFSET_ + (k - curn)]); + } + destBuf_[pan][n] = samp; + } + } + + return destBuf_; + } + + void SincResampler::initSincTables() + { + size_t maxSamples = destRate_ * maxDuration_ / 1000; + + if (srcRate_ != destRate_) { + size_t intrSize = calculateInternalSampleSize(maxSamples); + size_t offsetx2 = SINC_OFFSET_ << 1; + sincTable_.resize(maxSamples * offsetx2); + for (size_t n = 0; n < maxSamples; ++n) { + size_t seg = n * offsetx2; + float rcurn = n * rateRatio_; + int curn = static_cast(rcurn); + int k = curn - SINC_OFFSET_; + if (k < 0) k = 0; + int end = curn + SINC_OFFSET_; + if (static_cast(end) > intrSize) end = static_cast(intrSize); + for (; k < end; ++k) { + sincTable_[seg + SINC_OFFSET_ + (k - curn)] = sinc(F_PI_ * (rcurn - k)); + } + } + } + } +} diff --git a/thirdparty/opnmidi/chips/mamefm/resampler.hpp b/thirdparty/opnmidi/chips/mamefm/resampler.hpp new file mode 100644 index 0000000..7aee2ae --- /dev/null +++ b/thirdparty/opnmidi/chips/mamefm/resampler.hpp @@ -0,0 +1,70 @@ +// SPDX-License-Identifier: GPL-2.0-only +#pragma once +#include +#include +#include +#include + +typedef int32_t sample; + +namespace chip +{ + class AbstractResampler + { + public: + AbstractResampler(); + virtual ~AbstractResampler(); + virtual void init(int srcRate, int destRate, size_t maxDuration); + virtual void setDestributionRate(int destRate); + virtual void setMaxDuration(size_t maxDuration); + virtual sample** interpolate(sample** src, size_t nSamples, size_t intrSize) = 0; + + inline size_t calculateInternalSampleSize(size_t nSamples) + { + float f = nSamples * rateRatio_; + size_t i = static_cast(f); + return ((f - i) ? (i + 1) : i); + } + + protected: + inline void updateRateRatio() { + rateRatio_ = static_cast(srcRate_) / destRate_; + } + + protected: + int srcRate_, destRate_; + size_t maxDuration_; + float rateRatio_; + sample* destBuf_[2]; + }; + + + class LinearResampler : public AbstractResampler + { + public: + sample** interpolate(sample** src, size_t nSamples, size_t intrSize); + }; + + + class SincResampler : public AbstractResampler + { + public: + void init(int srcRate, int destRate, size_t maxDuration); + void setDestributionRate(int destRate); + void setMaxDuration(size_t maxDuration); + sample** interpolate(sample** src, size_t nSamples, size_t intrSize); + + private: + std::vector sincTable_; + + static const float F_PI_; + static const int SINC_OFFSET_; + + void initSincTables(); + + static inline float sinc(float x) + { + return ((!x) ? 1.0f : (std::sin(x) / x)); + } + }; +} diff --git a/thirdparty/opnmidi/chips/mamefm/ymdeltat.cpp b/thirdparty/opnmidi/chips/mamefm/ymdeltat.cpp new file mode 100644 index 0000000..67e354d --- /dev/null +++ b/thirdparty/opnmidi/chips/mamefm/ymdeltat.cpp @@ -0,0 +1,628 @@ +// license:GPL-2.0+ +// copyright-holders:Jarek Burczynski +/* +** +** File: ymdeltat.c +** +** YAMAHA DELTA-T adpcm sound emulation subroutine +** used by fmopl.c (Y8950) and fm.c (YM2608 and YM2610/B) +** +** Base program is YM2610 emulator by Hiromitsu Shioya. +** Written by Tatsuyuki Satoh +** Improvements by Jarek Burczynski (bujar at mame dot net) +** +** +** History: +** +** 03-08-2003 Jarek Burczynski: +** - fixed BRDY flag implementation. +** +** 24-07-2003 Jarek Burczynski, Frits Hilderink: +** - fixed delault value for control2 in YM_DELTAT_ADPCM_Reset +** +** 22-07-2003 Jarek Burczynski, Frits Hilderink: +** - fixed external memory support +** +** 15-06-2003 Jarek Burczynski: +** - implemented CPU -> AUDIO ADPCM synthesis (via writes to the ADPCM data reg $08) +** - implemented support for the Limit address register +** - supported two bits from the control register 2 ($01): RAM TYPE (x1 bit/x8 bit), ROM/RAM +** - implemented external memory access (read/write) via the ADPCM data reg reads/writes +** Thanks go to Frits Hilderink for the example code. +** +** 14-06-2003 Jarek Burczynski: +** - various fixes to enable proper support for status register flags: BSRDY, PCM BSY, ZERO +** - modified EOS handling +** +** 05-04-2003 Jarek Burczynski: +** - implemented partial support for external/processor memory on sample replay +** +** 01-12-2002 Jarek Burczynski: +** - fixed first missing sound in gigandes thanks to previous fix (interpolator) by ElSemi +** - renamed/removed some YM_DELTAT struct fields +** +** 28-12-2001 Acho A. Tang +** - added EOS status report on ADPCM playback. +** +** 05-08-2001 Jarek Burczynski: +** - now_step is initialized with 0 at the start of play. +** +** 12-06-2001 Jarek Burczynski: +** - corrected end of sample bug in YM_DELTAT_ADPCM_CALC. +** Checked on real YM2610 chip - address register is 24 bits wide. +** Thanks go to Stefan Jokisch (stefan.jokisch@gmx.de) for tracking down the problem. +** +** TO DO: +** Check size of the address register on the other chips.... +** +** Version 0.72 +** +** sound chips that have this unit: +** YM2608 OPNA +** YM2610/B OPNB +** Y8950 MSX AUDIO +** +*/ + +#include "emu.h" +#include "ymdeltat.h" + +#define YM_DELTAT_SHIFT (16) + +#define YM_DELTAT_DELTA_MAX (24576) +#define YM_DELTAT_DELTA_MIN (127) +#define YM_DELTAT_DELTA_DEF (127) + +#define YM_DELTAT_DECODE_RANGE 32768 +#define YM_DELTAT_DECODE_MIN (-(YM_DELTAT_DECODE_RANGE)) +#define YM_DELTAT_DECODE_MAX ((YM_DELTAT_DECODE_RANGE)-1) + +/* Forecast to next Forecast (rate = *8) */ +/* 1/8 , 3/8 , 5/8 , 7/8 , 9/8 , 11/8 , 13/8 , 15/8 */ +static CONSTEXPR int32_t ym_deltat_decode_tableB1[16] = { + 1, 3, 5, 7, 9, 11, 13, 15, + -1, -3, -5, -7, -9, -11, -13, -15, +}; +/* delta to next delta (rate= *64) */ +/* 0.9 , 0.9 , 0.9 , 0.9 , 1.2 , 1.6 , 2.0 , 2.4 */ +static CONSTEXPR int32_t ym_deltat_decode_tableB2[16] = { + 57, 57, 57, 57, 77, 102, 128, 153, + 57, 57, 57, 57, 77, 102, 128, 153 +}; + +#if 0 +void YM_DELTAT::BRDY_callback() +{ + logerror("BRDY_callback reached (flag set) !\n"); + + /* set BRDY bit in status register */ + if(status_set_handler) + if(status_change_BRDY_bit) + (status_set_handler)(status_change_which_chip, status_change_BRDY_bit); +} +#endif + +uint8_t YM_DELTAT::ADPCM_Read() +{ + uint8_t v = 0; + + /* external memory read */ + if ((portstate & 0xe0) == 0x20) + { + /* two dummy reads */ + if (memread) + { + now_addr = start << 1; + memread--; + return 0; + } + + + if (now_addr != (end << 1)) + { + v = read_byte(device, now_addr>>1); + + /*logerror("YM Delta-T memory read $%08x, v=$%02x\n", now_addr >> 1, v);*/ + + now_addr += 2; /* two nibbles at a time */ + + /* reset BRDY bit in status register, which means we are reading the memory now */ + if (status_reset_handler && status_change_BRDY_bit) + (status_reset_handler)(status_change_which_chip, status_change_BRDY_bit); + + /* setup a timer that will callback us in 10 master clock cycles for Y8950 + * in the callback set the BRDY flag to 1 , which means we have another data ready. + * For now, we don't really do this; we simply reset and set the flag in zero time, so that the IRQ will work. + */ + /* set BRDY bit in status register */ + if (status_set_handler && status_change_BRDY_bit) + (status_set_handler)(status_change_which_chip, status_change_BRDY_bit); + } + else + { + /* set EOS bit in status register */ + if (status_set_handler && status_change_EOS_bit) + (status_set_handler)(status_change_which_chip, status_change_EOS_bit); + } + } + + return v; +} + + +/* 0-DRAM x1, 1-ROM, 2-DRAM x8, 3-ROM (3 is bad setting - not allowed by the manual) */ +static CONSTEXPR uint8_t dram_rightshift[4]={3,0,0,0}; + +/* DELTA-T ADPCM write register */ +void YM_DELTAT::ADPCM_Write(int r, int v) +{ + if (r >= 0x10) return; + reg[r] = v; /* stock data */ + + switch (r) + { + case 0x00: +/* +START: + Accessing *external* memory is started when START bit (D7) is set to "1", so + you must set all conditions needed for recording/playback before starting. + If you access *CPU-managed* memory, recording/playback starts after + read/write of ADPCM data register $08. + +REC: + 0 = ADPCM synthesis (playback) + 1 = ADPCM analysis (record) + +MEMDATA: + 0 = processor (*CPU-managed*) memory (means: using register $08) + 1 = external memory (using start/end/limit registers to access memory: RAM or ROM) + + +SPOFF: + controls output pin that should disable the speaker while ADPCM analysis + +RESET and REPEAT only work with external memory. + + +some examples: +value: START, REC, MEMDAT, REPEAT, SPOFF, x,x,RESET meaning: + C8 1 1 0 0 1 0 0 0 Analysis (recording) from AUDIO to CPU (to reg $08), sample rate in PRESCALER register + E8 1 1 1 0 1 0 0 0 Analysis (recording) from AUDIO to EXT.MEMORY, sample rate in PRESCALER register + 80 1 0 0 0 0 0 0 0 Synthesis (playing) from CPU (from reg $08) to AUDIO,sample rate in DELTA-N register + a0 1 0 1 0 0 0 0 0 Synthesis (playing) from EXT.MEMORY to AUDIO, sample rate in DELTA-N register + + 60 0 1 1 0 0 0 0 0 External memory write via ADPCM data register $08 + 20 0 0 1 0 0 0 0 0 External memory read via ADPCM data register $08 + +*/ + /* handle emulation mode */ + if (emulation_mode == EMULATION_MODE_YM2610) + { + v |= 0x20; /* YM2610 always uses external memory and doesn't even have memory flag bit. */ + v &= ~0x40; /* YM2610 has no rec bit */ + } + + portstate = v & (0x80|0x40|0x20|0x10|0x01); /* start, rec, memory mode, repeat flag copy, reset(bit0) */ + + if (portstate & 0x80)/* START,REC,MEMDATA,REPEAT,SPOFF,--,--,RESET */ + { + /* set PCM BUSY bit */ + PCM_BSY = 1; + + /* start ADPCM */ + now_step = 0; + acc = 0; + prev_acc = 0; + adpcml = 0; + adpcmd = YM_DELTAT_DELTA_DEF; + now_data = 0; + + } + + if (portstate & 0x20) /* do we access external memory? */ + { + now_addr = start << 1; + memread = 2; /* two dummy reads needed before accesing external memory via register $08*/ + } + else /* we access CPU memory (ADPCM data register $08) so we only reset now_addr here */ + { + now_addr = 0; + } + + if (portstate & 0x01) + { + portstate = 0x00; + + /* clear PCM BUSY bit (in status register) */ + PCM_BSY = 0; + + /* set BRDY flag */ + if (status_set_handler && status_change_BRDY_bit) + (status_set_handler)(status_change_which_chip, status_change_BRDY_bit); + } + break; + + case 0x01: /* L,R,-,-,SAMPLE,DA/AD,RAMTYPE,ROM */ + /* handle emulation mode */ + if (emulation_mode == EMULATION_MODE_YM2610) + { + v |= 0x01; /* YM2610 always uses ROM as an external memory and doesn't tave ROM/RAM memory flag bit. */ + } + + pan = &output_pointer[(v >> 6) & 0x03]; + if ((control2 & 3) != (v & 3)) + { + /*0-DRAM x1, 1-ROM, 2-DRAM x8, 3-ROM (3 is bad setting - not allowed by the manual) */ + if (DRAMportshift != dram_rightshift[v & 3]) + { + DRAMportshift = dram_rightshift[v & 3]; + + /* final shift value depends on chip type and memory type selected: + 8 for YM2610 (ROM only), + 5 for ROM for Y8950 and YM2608, + 5 for x8bit DRAMs for Y8950 and YM2608, + 2 for x1bit DRAMs for Y8950 and YM2608. + */ + + /* refresh addresses */ + start = (reg[0x3] * 0x0100 | reg[0x2]) << (portshift - DRAMportshift); + end = (reg[0x5] * 0x0100 | reg[0x4]) << (portshift - DRAMportshift); + end += (1 << (portshift - DRAMportshift)) - 1; + limit = (reg[0xd]*0x0100 | reg[0xc]) << (portshift - DRAMportshift); + } + } + control2 = v; + break; + + case 0x02: /* Start Address L */ + case 0x03: /* Start Address H */ + start = (reg[0x3] * 0x0100 | reg[0x2]) << (portshift - DRAMportshift); + /*logerror("DELTAT start: 02=%2x 03=%2x addr=%8x\n",reg[0x2], reg[0x3],start );*/ + break; + + case 0x04: /* Stop Address L */ + case 0x05: /* Stop Address H */ + end = (reg[0x5]*0x0100 | reg[0x4]) << (portshift - DRAMportshift); + end += (1 << (portshift - DRAMportshift)) - 1; + /*logerror("DELTAT end : 04=%2x 05=%2x addr=%8x\n",reg[0x4], reg[0x5],end );*/ + break; + + case 0x06: /* Prescale L (ADPCM and Record frq) */ + case 0x07: /* Prescale H */ + break; + + case 0x08: /* ADPCM data */ +/* +some examples: +value: START, REC, MEMDAT, REPEAT, SPOFF, x,x,RESET meaning: + C8 1 1 0 0 1 0 0 0 Analysis (recording) from AUDIO to CPU (to reg $08), sample rate in PRESCALER register + E8 1 1 1 0 1 0 0 0 Analysis (recording) from AUDIO to EXT.MEMORY, sample rate in PRESCALER register + 80 1 0 0 0 0 0 0 0 Synthesis (playing) from CPU (from reg $08) to AUDIO,sample rate in DELTA-N register + a0 1 0 1 0 0 0 0 0 Synthesis (playing) from EXT.MEMORY to AUDIO, sample rate in DELTA-N register + + 60 0 1 1 0 0 0 0 0 External memory write via ADPCM data register $08 + 20 0 0 1 0 0 0 0 0 External memory read via ADPCM data register $08 + +*/ + + /* external memory write */ + if ((portstate & 0xe0) == 0x60) + { + if (memread) + { + now_addr = start << 1; + memread = 0; + } + + /*logerror("YM Delta-T memory write $%08x, v=$%02x\n", now_addr >> 1, v);*/ + + if (now_addr != (end << 1)) + { + write_byte(device, now_addr >> 1, v); + now_addr += 2; /* two nybbles at a time */ + + /* reset BRDY bit in status register, which means we are processing the write */ + if (status_reset_handler && status_change_BRDY_bit) + (status_reset_handler)(status_change_which_chip, status_change_BRDY_bit); + + /* setup a timer that will callback us in 10 master clock cycles for Y8950 + * in the callback set the BRDY flag to 1 , which means we have written the data. + * For now, we don't really do this; we simply reset and set the flag in zero time, so that the IRQ will work. + */ + /* set BRDY bit in status register */ + if (status_set_handler && status_change_BRDY_bit) + (status_set_handler)(status_change_which_chip, status_change_BRDY_bit); + + } + else + { + /* set EOS bit in status register */ + if (status_set_handler && status_change_EOS_bit) + (status_set_handler)(status_change_which_chip, status_change_EOS_bit); + } + + return; + } + + /* ADPCM synthesis from CPU */ + if ((portstate & 0xe0) == 0x80) + { + CPU_data = v; + + /* Reset BRDY bit in status register, which means we are full of data */ + if (status_reset_handler && status_change_BRDY_bit) + (status_reset_handler)(status_change_which_chip, status_change_BRDY_bit); + return; + } + + break; + + case 0x09: /* DELTA-N L (ADPCM Playback Prescaler) */ + case 0x0a: /* DELTA-N H */ + delta = (reg[0xa] * 0x0100 | reg[0x9]); + step = uint32_t(double(delta /* *(1<<(YM_DELTAT_SHIFT-16)) */) * freqbase); + /*logerror("DELTAT deltan:09=%2x 0a=%2x\n",reg[0x9], reg[0xa]);*/ + break; + + case 0x0b: /* Output level control (volume, linear) */ + { + const int32_t oldvol = volume; + volume = (v & 0xff) * (output_range / 256) / YM_DELTAT_DECODE_RANGE; +/* v * ((1<<16)>>8) >> 15; +* thus: v * (1<<8) >> 15; +* thus: output_range must be (1 << (15+8)) at least +* v * ((1<<23)>>8) >> 15; +* v * (1<<15) >> 15; +*/ + /*logerror("DELTAT vol = %2x\n",v&0xff);*/ + if (oldvol != 0) + { + adpcml = int(double(adpcml) / double(oldvol) * double(volume)); + } + } + break; + + case 0x0c: /* Limit Address L */ + case 0x0d: /* Limit Address H */ + limit = (reg[0xd] * 0x0100 | reg[0xc]) << (portshift - DRAMportshift); + /*logerror("DELTAT limit: 0c=%2x 0d=%2x addr=%8x\n",reg[0xc], reg[0xd],limit );*/ + break; + } +} + +void YM_DELTAT::ADPCM_Reset(int panidx, int mode, device_t *dev) +{ + device = dev; + now_addr = 0; + now_step = 0; + step = 0; + start = 0; + end = 0; + limit = ~0; /* this way YM2610 and Y8950 (both of which don't have limit address reg) will still work */ + volume = 0; + pan = &output_pointer[panidx]; + acc = 0; + prev_acc = 0; + adpcmd = 127; + adpcml = 0; + emulation_mode = uint8_t(mode); + portstate = (emulation_mode == EMULATION_MODE_YM2610) ? 0x20 : 0; + control2 = (emulation_mode == EMULATION_MODE_YM2610) ? 0x01 : 0; /* default setting depends on the emulation mode. MSX demo called "facdemo_4" doesn't setup control2 register at all and still works */ + DRAMportshift = dram_rightshift[control2 & 3]; + + /* The flag mask register disables the BRDY after the reset, however + ** as soon as the mask is enabled the flag needs to be set. */ + + /* set BRDY bit in status register */ + if (status_set_handler && status_change_BRDY_bit) + (status_set_handler)(status_change_which_chip, status_change_BRDY_bit); +} + +void YM_DELTAT::postload(uint8_t *regs) +{ + /* to keep adpcml */ + volume = 0; + /* update */ + for (int r = 1; r < 16; r++) + ADPCM_Write(r, regs[r]); + reg[0] = regs[0]; + + /* current rom data */ + now_data = read_byte(device, now_addr >> 1); + +} +void YM_DELTAT::savestate(device_t *device) +{ + (void)device; +#ifdef MAME_EMU_SAVE_H + YM_DELTAT *const DELTAT = this; // makes the save name sensible + device->save_item(NAME(DELTAT->portstate)); + device->save_item(NAME(DELTAT->now_addr)); + device->save_item(NAME(DELTAT->now_step)); + device->save_item(NAME(DELTAT->acc)); + device->save_item(NAME(DELTAT->prev_acc)); + device->save_item(NAME(DELTAT->adpcmd)); + device->save_item(NAME(DELTAT->adpcml)); +#endif +} + + +#define YM_DELTAT_Limit(val,max,min) \ +{ \ + if ( val > max ) val = max; \ + else if ( val < min ) val = min; \ +} + +static inline void YM_DELTAT_synthesis_from_external_memory(YM_DELTAT *DELTAT) +{ + uint32_t step; + int data; + + DELTAT->now_step += DELTAT->step; + if ( DELTAT->now_step >= (1<now_step >> YM_DELTAT_SHIFT; + DELTAT->now_step &= (1<now_addr == (DELTAT->limit<<1) ) + DELTAT->now_addr = 0; + + if ( DELTAT->now_addr == (DELTAT->end<<1) ) { /* 12-06-2001 JB: corrected comparison. Was > instead of == */ + if( DELTAT->portstate&0x10 ){ + /* repeat start */ + DELTAT->now_addr = DELTAT->start<<1; + DELTAT->acc = 0; + DELTAT->adpcmd = YM_DELTAT_DELTA_DEF; + DELTAT->prev_acc = 0; + }else{ + /* set EOS bit in status register */ + if(DELTAT->status_set_handler) + if(DELTAT->status_change_EOS_bit) + (DELTAT->status_set_handler)(DELTAT->status_change_which_chip, DELTAT->status_change_EOS_bit); + + /* clear PCM BUSY bit (reflected in status register) */ + DELTAT->PCM_BSY = 0; + + DELTAT->portstate = 0; + DELTAT->adpcml = 0; + DELTAT->prev_acc = 0; + return; + } + } + + if( DELTAT->now_addr&1 ) data = DELTAT->now_data & 0x0f; + else + { + DELTAT->now_data = DELTAT->read_byte(DELTAT->device, DELTAT->now_addr>>1); + data = DELTAT->now_data >> 4; + } + + DELTAT->now_addr++; + /* 12-06-2001 JB: */ + /* YM2610 address register is 24 bits wide.*/ + /* The "+1" is there because we use 1 bit more for nibble calculations.*/ + /* WARNING: */ + /* Side effect: we should take the size of the mapped ROM into account */ + DELTAT->now_addr &= ( (1<<(24+1))-1); + + /* store accumulator value */ + DELTAT->prev_acc = DELTAT->acc; + + /* Forecast to next Forecast */ + DELTAT->acc += (ym_deltat_decode_tableB1[data] * DELTAT->adpcmd / 8); + YM_DELTAT_Limit(DELTAT->acc,YM_DELTAT_DECODE_MAX, YM_DELTAT_DECODE_MIN); + + /* delta to next delta */ + DELTAT->adpcmd = (DELTAT->adpcmd * ym_deltat_decode_tableB2[data] ) / 64; + YM_DELTAT_Limit(DELTAT->adpcmd,YM_DELTAT_DELTA_MAX, YM_DELTAT_DELTA_MIN ); + + /* ElSemi: Fix interpolator. */ + /*DELTAT->prev_acc = prev_acc + ((DELTAT->acc - prev_acc) / 2 );*/ + + }while(--step); + + } + + /* ElSemi: Fix interpolator. */ + DELTAT->adpcml = DELTAT->prev_acc * (int)((1<now_step); + DELTAT->adpcml += (DELTAT->acc * (int)DELTAT->now_step); + DELTAT->adpcml = (DELTAT->adpcml>>YM_DELTAT_SHIFT) * (int)DELTAT->volume; + + /* output for work of output channels (outd[OPNxxxx])*/ + *(DELTAT->pan) += DELTAT->adpcml; +} + + + +static inline void YM_DELTAT_synthesis_from_CPU_memory(YM_DELTAT *DELTAT) +{ + uint32_t step; + int data; + + DELTAT->now_step += DELTAT->step; + if ( DELTAT->now_step >= (1<now_step >> YM_DELTAT_SHIFT; + DELTAT->now_step &= (1<now_addr&1 ) + { + data = DELTAT->now_data & 0x0f; + + DELTAT->now_data = DELTAT->CPU_data; + + /* after we used CPU_data, we set BRDY bit in status register, + * which means we are ready to accept another byte of data */ + if(DELTAT->status_set_handler) + if(DELTAT->status_change_BRDY_bit) + (DELTAT->status_set_handler)(DELTAT->status_change_which_chip, DELTAT->status_change_BRDY_bit); + } + else + { + data = DELTAT->now_data >> 4; + } + + DELTAT->now_addr++; + + /* store accumulator value */ + DELTAT->prev_acc = DELTAT->acc; + + /* Forecast to next Forecast */ + DELTAT->acc += (ym_deltat_decode_tableB1[data] * DELTAT->adpcmd / 8); + YM_DELTAT_Limit(DELTAT->acc,YM_DELTAT_DECODE_MAX, YM_DELTAT_DECODE_MIN); + + /* delta to next delta */ + DELTAT->adpcmd = (DELTAT->adpcmd * ym_deltat_decode_tableB2[data] ) / 64; + YM_DELTAT_Limit(DELTAT->adpcmd,YM_DELTAT_DELTA_MAX, YM_DELTAT_DELTA_MIN ); + + + }while(--step); + + } + + /* ElSemi: Fix interpolator. */ + DELTAT->adpcml = DELTAT->prev_acc * (int)((1<now_step); + DELTAT->adpcml += (DELTAT->acc * (int)DELTAT->now_step); + DELTAT->adpcml = (DELTAT->adpcml>>YM_DELTAT_SHIFT) * (int)DELTAT->volume; + + /* output for work of output channels (outd[OPNxxxx])*/ + *(DELTAT->pan) += DELTAT->adpcml; +} + + + +/* ADPCM B (Delta-T control type) */ +void YM_DELTAT::ADPCM_CALC() +{ +/* +some examples: +value: START, REC, MEMDAT, REPEAT, SPOFF, x,x,RESET meaning: + 80 1 0 0 0 0 0 0 0 Synthesis (playing) from CPU (from reg $08) to AUDIO,sample rate in DELTA-N register + a0 1 0 1 0 0 0 0 0 Synthesis (playing) from EXT.MEMORY to AUDIO, sample rate in DELTA-N register + C8 1 1 0 0 1 0 0 0 Analysis (recording) from AUDIO to CPU (to reg $08), sample rate in PRESCALER register + E8 1 1 1 0 1 0 0 0 Analysis (recording) from AUDIO to EXT.MEMORY, sample rate in PRESCALER register + + 60 0 1 1 0 0 0 0 0 External memory write via ADPCM data register $08 + 20 0 0 1 0 0 0 0 0 External memory read via ADPCM data register $08 + +*/ + + if ( (portstate & 0xe0)==0xa0 ) + { + YM_DELTAT_synthesis_from_external_memory(this); + return; + } + + if ( (portstate & 0xe0)==0x80 ) + { + /* ADPCM synthesis from CPU-managed memory (from reg $08) */ + YM_DELTAT_synthesis_from_CPU_memory(this); /* change output based on data in ADPCM data reg ($08) */ + return; + } + +//todo: ADPCM analysis +// if ( (portstate & 0xe0)==0xc0 ) +// if ( (portstate & 0xe0)==0xe0 ) + + return; +} diff --git a/thirdparty/opnmidi/chips/mamefm/ymdeltat.h b/thirdparty/opnmidi/chips/mamefm/ymdeltat.h new file mode 100644 index 0000000..fefe02e --- /dev/null +++ b/thirdparty/opnmidi/chips/mamefm/ymdeltat.h @@ -0,0 +1,91 @@ +// license:GPL-2.0+ +// copyright-holders:Jarek Burczynski +#ifndef MAME_SOUND_YMDELTAT_H +#define MAME_SOUND_YMDELTAT_H + +#pragma once +#include "emu.h" + +typedef uint8_t (*FM_READBYTE)(device_t *device, offs_t offset); +typedef void (*FM_WRITEBYTE)(device_t *device, offs_t offset, uint8_t data); +typedef void (*STATUS_CHANGE_HANDLER)(void *chip, uint8_t status_bits); + + +/* DELTA-T (adpcm type B) struct */ +struct YM_DELTAT {/* AT: rearranged and tightened structure */ + enum + { + EMULATION_MODE_NORMAL = 0, + EMULATION_MODE_YM2610 = 1 + }; + + FM_READBYTE read_byte; + FM_WRITEBYTE write_byte; + int32_t *output_pointer;/* pointer of output pointers */ + int32_t *pan; /* pan : &output_pointer[pan] */ + double freqbase; +#if 0 + double write_time; /* Y8950: 10 cycles of main clock; YM2608: 20 cycles of main clock */ + double read_time; /* Y8950: 8 cycles of main clock; YM2608: 18 cycles of main clock */ +#endif + uint32_t memory_size; + int output_range; + uint32_t now_addr; /* current address */ + uint32_t now_step; /* correct step */ + uint32_t step; /* step */ + uint32_t start; /* start address */ + uint32_t limit; /* limit address */ + uint32_t end; /* end address */ + uint32_t delta; /* delta scale */ + int32_t volume; /* current volume */ + int32_t acc; /* shift Measurement value*/ + int32_t adpcmd; /* next Forecast */ + int32_t adpcml; /* current value */ + int32_t prev_acc; /* leveling value */ + uint8_t now_data; /* current rom data */ + uint8_t CPU_data; /* current data from reg 08 */ + uint8_t portstate; /* port status */ + uint8_t control2; /* control reg: SAMPLE, DA/AD, RAM TYPE (x8bit / x1bit), ROM/RAM */ + uint8_t portshift; /* address bits shift-left: + ** 8 for YM2610, + ** 5 for Y8950 and YM2608 */ + + uint8_t DRAMportshift; /* address bits shift-right: + ** 0 for ROM and x8bit DRAMs, + ** 3 for x1 DRAMs */ + + uint8_t memread; /* needed for reading/writing external memory */ + + /* handlers and parameters for the status flags support */ + STATUS_CHANGE_HANDLER status_set_handler; + STATUS_CHANGE_HANDLER status_reset_handler; + + /* note that different chips have these flags on different + ** bits of the status register + */ + void * status_change_which_chip; /* this chip id */ + uint8_t status_change_EOS_bit; /* 1 on End Of Sample (record/playback/cycle time of AD/DA converting has passed)*/ + uint8_t status_change_BRDY_bit; /* 1 after recording 2 datas (2x4bits) or after reading/writing 1 data */ + uint8_t status_change_ZERO_bit; /* 1 if silence lasts for more than 290 milliseconds on ADPCM recording */ + + /* neither Y8950 nor YM2608 can generate IRQ when PCMBSY bit changes, so instead of above, + ** the statusflag gets ORed with PCM_BSY (below) (on each read of statusflag of Y8950 and YM2608) + */ + uint8_t PCM_BSY; /* 1 when ADPCM is playing; Y8950/YM2608 only */ + + uint8_t reg[16]; /* adpcm registers */ + uint8_t emulation_mode; /* which chip we're emulating */ + device_t *device; + + /*void BRDY_callback();*/ + + uint8_t ADPCM_Read(); + void ADPCM_Write(int r, int v); + void ADPCM_Reset(int panidx, int mode, device_t *dev); + void ADPCM_CALC(); + + void postload(uint8_t *regs); + void savestate(device_t *device); +}; + +#endif // MAME_SOUND_YMDELTAT_H diff --git a/thirdparty/opnmidi/chips/np2/compiler.h b/thirdparty/opnmidi/chips/np2/compiler.h new file mode 100644 index 0000000..083ec8f --- /dev/null +++ b/thirdparty/opnmidi/chips/np2/compiler.h @@ -0,0 +1,19 @@ +#ifndef OPNMIDI_FMGEN_COMPILER_H +#define OPNMIDI_FMGEN_COMPILER_H + +#if defined(_MSC_VER) && !defined(FASTCALL) +#define FASTCALL __fastcall +#elif defined(__GNUC__) && !defined(FASTCALL) +#define FASTCALL __attribute__((regparm(2))) +#endif + +#ifndef FASTCALL +#define FASTCALL +#endif +#define SOUNDCALL FASTCALL + +#ifndef MAX_PATH +#define MAX_PATH 256 +#endif + +#endif diff --git a/thirdparty/opnmidi/chips/np2/fmgen_diag.h b/thirdparty/opnmidi/chips/np2/fmgen_diag.h new file mode 100644 index 0000000..20dc370 --- /dev/null +++ b/thirdparty/opnmidi/chips/np2/fmgen_diag.h @@ -0,0 +1,15 @@ +#ifndef incl_diag_h +#define incl_diag_h + +#define LOG0(m) void (0) +#define LOG1(m,a) void (0) +#define LOG2(m,a,b) void (0) +#define LOG3(m,a,b,c) void (0) +#define LOG4(m,a,b,c,d) void (0) +#define LOG5(m,a,b,c,d,e) void (0) +#define LOG6(m,a,b,c,d,e,f) void (0) +#define LOG7(m,a,b,c,d,e,f,g) void (0) +#define LOG8(m,a,b,c,d,e,f,g,h) void (0) +#define LOG9(m,a,b,c,d,e,f,g,h,i) void (0) + +#endif // incl_diag_h diff --git a/thirdparty/opnmidi/chips/np2/fmgen_file.cpp b/thirdparty/opnmidi/chips/np2/fmgen_file.cpp new file mode 100644 index 0000000..1f7a1a0 --- /dev/null +++ b/thirdparty/opnmidi/chips/np2/fmgen_file.cpp @@ -0,0 +1,177 @@ +// $Id: file.cpp,v 1.6 1999/12/28 11:14:05 cisc Exp $ + +#include +#include "fmgen_types.h" +#include "fmgen_headers.h" +#include "fmgen_file.h" + +// --------------------------------------------------------------------------- +// 構築/消滅 +// --------------------------------------------------------------------------- + +FileIO::FileIO() +{ + flags = 0; +} + +FileIO::FileIO(const char* filename, uint flg) +{ + flags = 0; + Open(filename, flg); +} + +FileIO::~FileIO() +{ + Close(); +} + +// --------------------------------------------------------------------------- +// ファイルを開ã +// --------------------------------------------------------------------------- + +bool FileIO::Open(const char* filename, uint flg) +{ + char mode[5] = "rwb"; + Close(); + + strncpy(path, filename, MAX_PATH); + + if(flg & readonly) + strcpy(mode, "rb"); + else { + if(flg & create) + strcpy(mode, "rwb+"); + else + strcpy(mode, "rwb"); + } + + pfile = fopen(filename, mode); + + flags = (flg & readonly) | (pfile == NULL ? 0 : open); + + if (pfile == NULL) + error = file_not_found; + + SetLogicalOrigin(0); + + return !(pfile == NULL); +} + +// --------------------------------------------------------------------------- +// ファイルãŒãªã„å ´åˆã¯ä½œæˆ +// --------------------------------------------------------------------------- + +bool FileIO::CreateNew(const char* filename) +{ + uint flg = create; + + return Open(filename, flg); +} + +// --------------------------------------------------------------------------- +// ファイルを作り直㙠+// --------------------------------------------------------------------------- + +bool FileIO::Reopen(uint flg) +{ + if (!(flags & open)) return false; + if ((flags & readonly) && (flg & create)) return false; + + if (flags & readonly) flg |= readonly; + + return Open(path, flg); +} + +// --------------------------------------------------------------------------- +// ファイルを閉ã˜ã‚‹ +// --------------------------------------------------------------------------- + +void FileIO::Close() +{ + if (GetFlags() & open) + { + fclose(pfile); + flags = 0; + } +} + +// --------------------------------------------------------------------------- +// ファイル殻ã®èª­ã¿å‡ºã— +// --------------------------------------------------------------------------- + +int32 FileIO::Read(void* dest, int32 size) +{ + if (!(GetFlags() & open)) + return -1; + + size_t readsize; + if (!(readsize = fread(dest, 1, static_cast(size), pfile))) + return -1; + return size; +} + +// --------------------------------------------------------------------------- +// ファイルã¸ã®æ›¸ã出㗠+// --------------------------------------------------------------------------- + +int32 FileIO::Write(const void* dest, int32 size) +{ + if (!(GetFlags() & open) || (GetFlags() & readonly)) + return -1; + + size_t writtensize; + if (!(writtensize = fwrite(dest, 1, static_cast(size), pfile))) + return -1; + return static_cast(writtensize); +} + +// --------------------------------------------------------------------------- +// ファイルをシーク +// --------------------------------------------------------------------------- + +bool FileIO::Seek(int32 pos, SeekMethod method) +{ + if (!(GetFlags() & open)) + return false; + + int origin; + switch (method) + { + case begin: + origin = SEEK_SET; + break; + case current: + origin = SEEK_CUR; + break; + case end: + origin = SEEK_END; + break; + default: + return false; + } + + return (fseek(pfile, pos, origin) != 0); +} + +// --------------------------------------------------------------------------- +// ファイルã®ä½ç½®ã‚’å¾—ã‚‹ +// --------------------------------------------------------------------------- + +int32 FileIO::Tellp() +{ + if (!(GetFlags() & open)) + return 0; + + return static_cast(ftell(pfile)); +} + +// --------------------------------------------------------------------------- +// ç¾åœ¨ã®ä½ç½®ã‚’ファイルã®çµ‚端ã¨ã™ã‚‹ +// --------------------------------------------------------------------------- + +bool FileIO::SetEndOfFile() +{ + if (!(GetFlags() & open)) + return false; + return Seek(0, end); +} diff --git a/thirdparty/opnmidi/chips/np2/fmgen_file.h b/thirdparty/opnmidi/chips/np2/fmgen_file.h new file mode 100644 index 0000000..8f02f20 --- /dev/null +++ b/thirdparty/opnmidi/chips/np2/fmgen_file.h @@ -0,0 +1,64 @@ +// $Id: file.h,v 1.6 1999/11/26 10:14:09 cisc Exp $ + +#if !defined(win32_file_h) +#define win32_file_h + +#include "fmgen_types.h" + +// --------------------------------------------------------------------------- + +class FileIO +{ +public: + enum Flags + { + open = 0x000001, + readonly = 0x000002, + create = 0x000004 + }; + + enum SeekMethod + { + begin = 0, current = 1, end = 2 + }; + + enum Error + { + success = 0, + file_not_found, + sharing_violation, + unknown = -1 + }; + +public: + FileIO(); + FileIO(const char* filename, uint flg = 0); + virtual ~FileIO(); + + bool Open(const char* filename, uint flg = 0); + bool CreateNew(const char* filename); + bool Reopen(uint flg = 0); + void Close(); + Error GetError() { return error; } + + int32 Read(void* dest, int32 len); + int32 Write(const void* src, int32 len); + bool Seek(int32 fpos, SeekMethod method); + int32 Tellp(); + bool SetEndOfFile(); + + uint GetFlags() { return flags; } + void SetLogicalOrigin(int32 origin) { lorigin = origin; } + +private: + FILE* pfile; + uint flags; + uint32 lorigin; + Error error; + char path[MAX_PATH]; + + FileIO(const FileIO&); + const FileIO& operator=(const FileIO&); +}; + +#endif // diff --git a/thirdparty/opnmidi/chips/np2/fmgen_fmgen.cpp b/thirdparty/opnmidi/chips/np2/fmgen_fmgen.cpp new file mode 100644 index 0000000..5a09702 --- /dev/null +++ b/thirdparty/opnmidi/chips/np2/fmgen_fmgen.cpp @@ -0,0 +1,1156 @@ +// --------------------------------------------------------------------------- +// FM Sound Generator - Core Unit +// Copyright (C) cisc 1998, 2003. +// --------------------------------------------------------------------------- +// $Id: fmgen.cpp,v 1.49 2003/09/02 14:51:04 cisc Exp $ +// --------------------------------------------------------------------------- +// å‚考: +// FM sound generator for M.A.M.E., written by Tatsuyuki Satoh. +// +// 謎: +// OPNB ã® CSM モード(仕様ãŒã‚ˆãã‚ã‹ã‚‰ãªã„) +// +// 制é™: +// ・AR!=31 㧠SSGEC を使ã†ã¨æ³¢å½¢ãŒå®Ÿéš›ã¨ç•°ãªã‚‹å¯èƒ½æ€§ã‚ã‚Š +// +// è¬è¾ž: +// Tatsuyuki Satoh ã•ã‚“(fm.c) +// Hiromitsu Shioya ã•ã‚“(ADPCM-A) +// DMP-SOFT. ã•ã‚“(OPNB) +// KAJA ã•ã‚“(test program) +// ã»ã‹æŽ²ç¤ºæ¿ç­‰ã§æ§˜ã€…ãªã”助言，ã”支æ´ã‚’ãŠå¯„ã›ã„ãŸã ã„ãŸçš†æ§˜ã« +// --------------------------------------------------------------------------- + +#include "fmgen_headers.h" +#include "fmgen_misc.h" +#include "fmgen_fmgen.h" +#include "fmgen_fmgeninl.h" + +#define LOGNAME "fmgen" + +// --------------------------------------------------------------------------- + +#define FM_EG_BOTTOM 955 + +// --------------------------------------------------------------------------- +// Table/etc +// +namespace FM +{ + const uint8 Operator::notetable[128] = + { + 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 3, 3, 3, 3, 3, 3, + 4, 4, 4, 4, 4, 4, 4, 5, 6, 7, 7, 7, 7, 7, 7, 7, + 8, 8, 8, 8, 8, 8, 8, 9, 10, 11, 11, 11, 11, 11, 11, 11, + 12, 12, 12, 12, 12, 12, 12, 13, 14, 15, 15, 15, 15, 15, 15, 15, + 16, 16, 16, 16, 16, 16, 16, 17, 18, 19, 19, 19, 19, 19, 19, 19, + 20, 20, 20, 20, 20, 20, 20, 21, 22, 23, 23, 23, 23, 23, 23, 23, + 24, 24, 24, 24, 24, 24, 24, 25, 26, 27, 27, 27, 27, 27, 27, 27, + 28, 28, 28, 28, 28, 28, 28, 29, 30, 31, 31, 31, 31, 31, 31, 31, + }; + + const int8 Operator::dttable[256] = + { + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 2, 2, 2, 2, 2, 2, 2, 4, 4, 4, 4, + 4, 6, 6, 6, 8, 8, 8, 10, 10, 12, 12, 14, 16, 16, 16, 16, + 2, 2, 2, 2, 4, 4, 4, 4, 4, 6, 6, 6, 8, 8, 8, 10, + 10, 12, 12, 14, 16, 16, 18, 20, 22, 24, 26, 28, 32, 32, 32, 32, + 4, 4, 4, 4, 4, 6, 6, 6, 8, 8, 8, 10, 10, 12, 12, 14, + 16, 16, 18, 20, 22, 24, 26, 28, 32, 34, 38, 40, 44, 44, 44, 44, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, -2, -2, -2, -2, -2, -2, -2, -2, -4, -4, -4, -4, + -4, -6, -6, -6, -8, -8, -8,-10,-10,-12,-12,-14,-16,-16,-16,-16, + -2, -2, -2, -2, -4, -4, -4, -4, -4, -6, -6, -6, -8, -8, -8,-10, + -10,-12,-12,-14,-16,-16,-18,-20,-22,-24,-26,-28,-32,-32,-32,-32, + -4, -4, -4, -4, -4, -6, -6, -6, -8, -8, -8,-10,-10,-12,-12,-14, + -16,-16,-18,-20,-22,-24,-26,-28,-32,-34,-38,-40,-44,-44,-44,-44, + }; + + const int8 Operator::decaytable1[64][8] = + { + {0, 0, 0, 0, 0, 0, 0, 0}, {0, 0, 0, 0, 0, 0, 0, 0}, + {1, 1, 1, 1, 1, 1, 1, 1}, {1, 1, 1, 1, 1, 1, 1, 1}, + {1, 1, 1, 1, 1, 1, 1, 1}, {1, 1, 1, 1, 1, 1, 1, 1}, + {1, 1, 1, 0, 1, 1, 1, 0}, {1, 1, 1, 0, 1, 1, 1, 0}, + {1, 0, 1, 0, 1, 0, 1, 0}, {1, 1, 1, 0, 1, 0, 1, 0}, + {1, 1, 1, 0, 1, 1, 1, 0}, {1, 1, 1, 1, 1, 1, 1, 0}, + {1, 0, 1, 0, 1, 0, 1, 0}, {1, 1, 1, 0, 1, 0, 1, 0}, + {1, 1, 1, 0, 1, 1, 1, 0}, {1, 1, 1, 1, 1, 1, 1, 0}, + {1, 0, 1, 0, 1, 0, 1, 0}, {1, 1, 1, 0, 1, 0, 1, 0}, + {1, 1, 1, 0, 1, 1, 1, 0}, {1, 1, 1, 1, 1, 1, 1, 0}, + {1, 0, 1, 0, 1, 0, 1, 0}, {1, 1, 1, 0, 1, 0, 1, 0}, + {1, 1, 1, 0, 1, 1, 1, 0}, {1, 1, 1, 1, 1, 1, 1, 0}, + {1, 0, 1, 0, 1, 0, 1, 0}, {1, 1, 1, 0, 1, 0, 1, 0}, + {1, 1, 1, 0, 1, 1, 1, 0}, {1, 1, 1, 1, 1, 1, 1, 0}, + {1, 0, 1, 0, 1, 0, 1, 0}, {1, 1, 1, 0, 1, 0, 1, 0}, + {1, 1, 1, 0, 1, 1, 1, 0}, {1, 1, 1, 1, 1, 1, 1, 0}, + {1, 0, 1, 0, 1, 0, 1, 0}, {1, 1, 1, 0, 1, 0, 1, 0}, + {1, 1, 1, 0, 1, 1, 1, 0}, {1, 1, 1, 1, 1, 1, 1, 0}, + {1, 0, 1, 0, 1, 0, 1, 0}, {1, 1, 1, 0, 1, 0, 1, 0}, + {1, 1, 1, 0, 1, 1, 1, 0}, {1, 1, 1, 1, 1, 1, 1, 0}, + {1, 0, 1, 0, 1, 0, 1, 0}, {1, 1, 1, 0, 1, 0, 1, 0}, + {1, 1, 1, 0, 1, 1, 1, 0}, {1, 1, 1, 1, 1, 1, 1, 0}, + {1, 0, 1, 0, 1, 0, 1, 0}, {1, 1, 1, 0, 1, 0, 1, 0}, + {1, 1, 1, 0, 1, 1, 1, 0}, {1, 1, 1, 1, 1, 1, 1, 0}, + {1, 1, 1, 1, 1, 1, 1, 1}, {2, 1, 1, 1, 2, 1, 1, 1}, + {2, 1, 2, 1, 2, 1, 2, 1}, {2, 2, 2, 1, 2, 2, 2, 1}, + {2, 2, 2, 2, 2, 2, 2, 2}, {4, 2, 2, 2, 4, 2, 2, 2}, + {4, 2, 4, 2, 4, 2, 4, 2}, {4, 4, 4, 2, 4, 4, 4, 2}, + {4, 4, 4, 4, 4, 4, 4, 4}, {8, 4, 4, 4, 8, 4, 4, 4}, + {8, 4, 8, 4, 8, 4, 8, 4}, {8, 8, 8, 4, 8, 8, 8, 4}, + {16,16,16,16,16,16,16,16}, {16,16,16,16,16,16,16,16}, + {16,16,16,16,16,16,16,16}, {16,16,16,16,16,16,16,16}, + }; + + const int Operator::decaytable2[16] = + { + 1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2047, 2047, 2047, 2047, 2047 + }; + + const int8 Operator::attacktable[64][8] = + { + {-1,-1,-1,-1,-1,-1,-1,-1}, {-1,-1,-1,-1,-1,-1,-1,-1}, + { 4, 4, 4, 4, 4, 4, 4, 4}, { 4, 4, 4, 4, 4, 4, 4, 4}, + { 4, 4, 4, 4, 4, 4, 4, 4}, { 4, 4, 4, 4, 4, 4, 4, 4}, + { 4, 4, 4,-1, 4, 4, 4,-1}, { 4, 4, 4,-1, 4, 4, 4,-1}, + { 4,-1, 4,-1, 4,-1, 4,-1}, { 4, 4, 4,-1, 4,-1, 4,-1}, + { 4, 4, 4,-1, 4, 4, 4,-1}, { 4, 4, 4, 4, 4, 4, 4,-1}, + { 4,-1, 4,-1, 4,-1, 4,-1}, { 4, 4, 4,-1, 4,-1, 4,-1}, + { 4, 4, 4,-1, 4, 4, 4,-1}, { 4, 4, 4, 4, 4, 4, 4,-1}, + { 4,-1, 4,-1, 4,-1, 4,-1}, { 4, 4, 4,-1, 4,-1, 4,-1}, + { 4, 4, 4,-1, 4, 4, 4,-1}, { 4, 4, 4, 4, 4, 4, 4,-1}, + { 4,-1, 4,-1, 4,-1, 4,-1}, { 4, 4, 4,-1, 4,-1, 4,-1}, + { 4, 4, 4,-1, 4, 4, 4,-1}, { 4, 4, 4, 4, 4, 4, 4,-1}, + { 4,-1, 4,-1, 4,-1, 4,-1}, { 4, 4, 4,-1, 4,-1, 4,-1}, + { 4, 4, 4,-1, 4, 4, 4,-1}, { 4, 4, 4, 4, 4, 4, 4,-1}, + { 4,-1, 4,-1, 4,-1, 4,-1}, { 4, 4, 4,-1, 4,-1, 4,-1}, + { 4, 4, 4,-1, 4, 4, 4,-1}, { 4, 4, 4, 4, 4, 4, 4,-1}, + { 4,-1, 4,-1, 4,-1, 4,-1}, { 4, 4, 4,-1, 4,-1, 4,-1}, + { 4, 4, 4,-1, 4, 4, 4,-1}, { 4, 4, 4, 4, 4, 4, 4,-1}, + { 4,-1, 4,-1, 4,-1, 4,-1}, { 4, 4, 4,-1, 4,-1, 4,-1}, + { 4, 4, 4,-1, 4, 4, 4,-1}, { 4, 4, 4, 4, 4, 4, 4,-1}, + { 4,-1, 4,-1, 4,-1, 4,-1}, { 4, 4, 4,-1, 4,-1, 4,-1}, + { 4, 4, 4,-1, 4, 4, 4,-1}, { 4, 4, 4, 4, 4, 4, 4,-1}, + { 4,-1, 4,-1, 4,-1, 4,-1}, { 4, 4, 4,-1, 4,-1, 4,-1}, + { 4, 4, 4,-1, 4, 4, 4,-1}, { 4, 4, 4, 4, 4, 4, 4,-1}, + { 4, 4, 4, 4, 4, 4, 4, 4}, { 3, 4, 4, 4, 3, 4, 4, 4}, + { 3, 4, 3, 4, 3, 4, 3, 4}, { 3, 3, 3, 4, 3, 3, 3, 4}, + { 3, 3, 3, 3, 3, 3, 3, 3}, { 2, 3, 3, 3, 2, 3, 3, 3}, + { 2, 3, 2, 3, 2, 3, 2, 3}, { 2, 2, 2, 3, 2, 2, 2, 3}, + { 2, 2, 2, 2, 2, 2, 2, 2}, { 1, 2, 2, 2, 1, 2, 2, 2}, + { 1, 2, 1, 2, 1, 2, 1, 2}, { 1, 1, 1, 2, 1, 1, 1, 2}, + { 0, 0, 0, 0, 0, 0, 0, 0}, { 0, 0 ,0, 0, 0, 0, 0, 0}, + { 0, 0, 0, 0, 0, 0, 0, 0}, { 0, 0 ,0, 0, 0, 0, 0, 0}, + }; + +#if 0 // libOPNMIDI: experimental SSG-EG + const int Operator::ssgenvtable[8][2][3][2] = + { + {{{1, 1}, {1, 1}, {1, 1}}, // 08 + {{0, 1}, {1, 1}, {1, 1}}}, // 08 56~ + {{{0, 1}, {2, 0}, {2, 0}}, // 09 + {{0, 1}, {2, 0}, {2, 0}}}, // 09 + {{{1,-1}, {0, 1}, {1,-1}}, // 10 + {{0, 1}, {1,-1}, {0, 1}}}, // 10 60~ + {{{1,-1}, {0, 0}, {0, 0}}, // 11 + {{0, 1}, {0, 0}, {0, 0}}}, // 11 60~ + {{{2,-1}, {2,-1}, {2,-1}}, // 12 + {{1,-1}, {2,-1}, {2,-1}}}, // 12 56~ + {{{1,-1}, {0, 0}, {0, 0}}, // 13 + {{1,-1}, {0, 0}, {0, 0}}}, // 13 + {{{0, 1}, {1,-1}, {0, 1}}, // 14 + {{1,-1}, {0, 1}, {1,-1}}}, // 14 60~ + {{{0, 1}, {2, 0}, {2, 0}}, // 15 + {{1,-1}, {2, 0}, {2, 0}}}, // 15 60~ + }; +#endif + + // fixed equasion-based tables + int pmtable[2][8][FM_LFOENTS]; + uint amtable[2][4][FM_LFOENTS]; + + static bool tablemade = false; +} + +namespace FM +{ + +// --------------------------------------------------------------------------- +// ãƒ†ãƒ¼ãƒ–ãƒ«ä½œæˆ +// +void MakeLFOTable() +{ + if (tablemade) + return; + + tablemade = true; + + int i; + + static const double pms[2][8] = + { + { 0, 1/360., 2/360., 3/360., 4/360., 6/360., 12/360., 24/360., }, // OPNA +// { 0, 1/240., 2/240., 4/240., 10/240., 20/240., 80/240., 140/240., }, // OPM + { 0, 1/480., 2/480., 4/480., 10/480., 20/480., 80/480., 140/480., }, // OPM +// { 0, 1/960., 2/960., 4/960., 10/960., 20/960., 80/960., 140/960., }, // OPM + }; + // 3 6, 12 30 60 240 420 / 720 + // 1.000963 + // lfofref[level * max * wave]; + // pre = lfofref[level][pms * wave >> 8]; + static const uint8 amt[2][4] = + { + { 31, 6, 4, 3 }, // OPNA + { 31, 2, 1, 0 }, // OPM + }; + + for (int type = 0; type < 2; type++) + { + for (i=0; i<8; i++) + { + double pmb = pms[type][i]; + for (int j=0; j> amt[type][i]) * 2) << 2; + } + } + } +} + + +// --------------------------------------------------------------------------- +// ãƒãƒƒãƒ—内ã§å…±é€šãªéƒ¨åˆ† +// +Chip::Chip() +: ratio_(0), aml_(0), pml_(0), pmv_(0) +//, optype_(typeN) +{ +} + +// クロック・サンプリングレート比ã«ä¾å­˜ã™ã‚‹ãƒ†ãƒ¼ãƒ–ãƒ«ã‚’ä½œæˆ +void Chip::SetRatio(uint ratio) +{ + if (ratio_ != ratio) + { + ratio_ = ratio; + MakeTable(); + } +} + +void Chip::MakeTable() +{ + int h, l; + + // PG Part + static const float dt2lv[4] = { 1.f, 1.414f, 1.581f, 1.732f }; + for (h=0; h<4; h++) + { + assert(2 + FM_RATIOBITS - FM_PGBITS >= 0); + double rr = dt2lv[h] * double(ratio_) / (1 << (2 + FM_RATIOBITS - FM_PGBITS)); + for (l=0; l<16; l++) + { + int mul = l ? l * 2 : 1; + multable_[h][l] = uint(mul * rr); + } + } +} + +void Chip::DataSave(struct ChipData* data) +{ + data->ratio_ = ratio_; + data->aml_ = aml_; + data->pml_ = pml_; + data->pmv_ = pmv_; + memcpy(data->multable_, multable_, sizeof(uint32) * 4 * 16); +} + +void Chip::DataLoad(struct ChipData* data) +{ + ratio_ = data->ratio_; + aml_ = data->aml_; + pml_ = data->pml_; + pmv_ = data->pmv_; + memcpy(multable_, data->multable_, sizeof(uint32) * 4 * 16); +} + +// --------------------------------------------------------------------------- +// Operator +// +bool FM::Operator::tablehasmade = false; +uint FM::Operator::sinetable[1024]; +int32 FM::Operator::cltable[FM_CLENTS]; + +// 構築 +FM::Operator::Operator() +: chip_(0) +{ + if (!tablehasmade) + MakeTable(); + + // EG Part + ar_ = dr_ = sr_ = rr_ = key_scale_rate_ = 0; + ams_ = amtable[0][0]; + mute_ = false; + keyon_ = false; + tl_out_ = false; + ssg_type_ = 0; +#if 1 // libOPNMIDI: experimental SSG-EG + inverted_ = false; + held_ = false; +#endif + + // PG Part + multiple_ = 0; + detune_ = 0; + detune2_ = 0; + + // LFO + ms_ = 0; + +// Reset(); +} + +// åˆæœŸåŒ– +void FM::Operator::Reset() +{ + // EG part + tl_ = tl_latch_ = 127; + ShiftPhase(off); + eg_count_ = 0; + eg_curve_count_ = 0; +#if 1 // libOPNMIDI: experimental SSG-EG + inverted_ = false; + held_ = false; +#else + ssg_phase_ = 0; +#endif + + // PG part + pg_count_ = 0; + + // OP part + out_ = out2_ = 0; + + param_changed_ = true; + PARAMCHANGE(0); +} + +void Operator::MakeTable() +{ + // 対数テーブルã®ä½œæˆ + assert(FM_CLENTS >= 256); + + int* p = cltable; + int i; + for (i=0; i<256; i++) + { + int v = int(floor(pow(2., 13. - i / 256.))); + v = (v + 2) & ~3; + *p++ = v; + *p++ = -v; + } + while (p < cltable + FM_CLENTS) + { + //*p++ = p[-512] / 2; + *p = p[-512] / 2; + p++; + } + +// for (i=0; i<13*256; i++) +// printf("%4d, %d, %d\n", i, cltable[i*2], cltable[i*2+1]); + + // サインテーブルã®ä½œæˆ + double log2 = log(2.); + for (i=0; iGetMulValue(detune2_, multiple_); + pg_diff_lfo_ = pg_diff_ >> 11; + + // EG Part + key_scale_rate_ = bn_ >> (3-ks_); + tl_out_ = mute_ ? 0x3ff : tl_ * 8; + + switch (eg_phase_) + { + case attack: + SetEGRate(static_cast(ar_ ? Min(63, ar_ + key_scale_rate_) : 0)); + break; + case decay: + SetEGRate(static_cast(dr_ ? Min(63, dr_ + key_scale_rate_) : 0)); + eg_level_on_next_phase_ = sl_ * 8; + break; + case sustain: + SetEGRate(static_cast(sr_ ? Min(63, sr_ + key_scale_rate_) : 0)); + break; + case release: + SetEGRate(static_cast(Min(63, rr_ + key_scale_rate_))); + break; + default: + break; + } + + // SSG-EG + inverted_ = false; + held_ = false; + if (ssg_type_ && (eg_phase_ != release)) + { +#if 1 // libOPNMIDI: experimental SSG-EG + inverted_ = (ssg_type_ & 4) != 0; + inverted_ ^= (ssg_type_ & 2) && ar_ != 62; // try to match polarity with nuked OPN +#else + int m = static_cast(ar_ >= ((ssg_type_ == 8 || ssg_type_ == 12) ? 56u : 60u)); + + assert(0 <= ssg_phase_ && ssg_phase_ <= 2); + const int* table = ssgenvtable[ssg_type_ & 7][m][ssg_phase_]; + + ssg_offset_ = table[0] * 0x200; + ssg_vector_ = table[1]; +#endif + } + // LFO + ams_ = amtable[type_][amon_ ? (ms_ >> 4) & 3 : 0]; + EGUpdate(); + + dbgopout_ = 0; + } +} + +void Operator::DataSave(struct OperatorData* data) +{ + data->out_ = out_; + data->out2_ = out2_; + data->in2_ = in2_; + data->dp_ = dp_; + data->detune_ = detune_; + data->detune2_ = detune2_; + data->multiple_ = multiple_; + data->pg_count_ = pg_count_; + data->pg_diff_ = pg_diff_; + data->pg_diff_lfo_ = pg_diff_lfo_; + data->type_ = type_; + data->bn_ = bn_; + data->eg_level_ = eg_level_; + data->eg_level_on_next_phase_ = eg_level_on_next_phase_; + data->eg_count_ = eg_count_; + data->eg_count_diff_ = eg_count_diff_; + data->eg_out_ = eg_out_; + data->tl_out_ = tl_out_; + data->eg_rate_ = eg_rate_; + data->eg_curve_count_ = eg_curve_count_; +#if 0 // libOPNMIDI: experimental SSG-EG + data->ssg_offset_ = ssg_offset_; + data->ssg_vector_ = ssg_vector_; + data->ssg_phase_ = ssg_phase_; +#endif + data->key_scale_rate_ = key_scale_rate_; + data->eg_phase_ = eg_phase_; + data->ms_ = ms_; + data->tl_ = tl_; + data->tl_latch_ = tl_latch_; + data->ar_ = ar_; + data->dr_ = dr_; + data->sr_ = sr_; + data->sl_ = sl_; + data->rr_ = rr_; + data->ks_ = ks_; + data->ssg_type_ = ssg_type_; + data->keyon_ = keyon_; + data->amon_ = amon_; + data->param_changed_ = param_changed_; + data->mute_ = mute_; + data->inverted_ = inverted_; + data->held_ = held_; +} + +void Operator::DataLoad(struct OperatorData* data) +{ + out_ = data->out_; + out2_ = data->out2_; + in2_ = data->in2_; + dp_ = data->dp_; + detune_ = data->detune_; + detune2_ = data->detune2_; + multiple_ = data->multiple_; + pg_count_ = data->pg_count_; + pg_diff_ = data->pg_diff_; + pg_diff_lfo_ = data->pg_diff_lfo_; + type_ = data->type_; + bn_ = data->bn_; + eg_level_ = data->eg_level_; + eg_level_on_next_phase_ = data->eg_level_on_next_phase_; + eg_count_ = data->eg_count_; + eg_count_diff_ = data->eg_count_diff_; + eg_out_ = data->eg_out_; + tl_out_ = data->tl_out_; + eg_rate_ = data->eg_rate_; + eg_curve_count_ = data->eg_curve_count_; +#if 0 // libOPNMIDI: experimental SSG-EG + ssg_offset_ = data->ssg_offset_; + ssg_vector_ = data->ssg_vector_; + ssg_phase_ = data->ssg_phase_; +#endif + key_scale_rate_ = data->key_scale_rate_; + eg_phase_ = data->eg_phase_; + ms_ = data->ms_; + tl_ = data->tl_; + tl_latch_ = data->tl_latch_; + ar_ = data->ar_; + dr_ = data->dr_; + sr_ = data->sr_; + sl_ = data->sl_; + rr_ = data->rr_; + ks_ = data->ks_; + ssg_type_ = data->ssg_type_; + keyon_ = data->keyon_; + amon_ = data->amon_; + param_changed_ = data->param_changed_; + mute_ = data->mute_; + inverted_ = data->inverted_; + held_ = data->held_; + ams_ = amtable[type_][amon_ ? (ms_ >> 4) & 3 : 0]; +} + + +// envelop ã® eg_phase_ 変更 +void Operator::ShiftPhase(EGPhase nextphase) +{ + switch (nextphase) + { + case attack: // Attack Phase + tl_ = tl_latch_; + if (ssg_type_) + { +#if 0 // libOPNMIDI: experimental SSG-EG + ssg_phase_ = ssg_phase_ + 1; + if (ssg_phase_ > 2) + ssg_phase_ = 1; + + int m = static_cast(ar_ >= ((ssg_type_ == 8 || ssg_type_ == 12) ? 56u : 60u)); + + assert(0 <= ssg_phase_ && ssg_phase_ <= 2); + const int* table = ssgenvtable[ssg_type_ & 7][m][ssg_phase_]; + + ssg_offset_ = table[0] * 0x200; + ssg_vector_ = table[1]; +#endif + } + if ((ar_ + key_scale_rate_) < 62) + { + SetEGRate(static_cast(ar_ ? Min(63, ar_ + key_scale_rate_) : 0)); + eg_phase_ = attack; + break; + } + // fall through + case decay: // Decay Phase + if (sl_) + { + eg_level_ = 0; + eg_level_on_next_phase_ = ssg_type_ ? Min(sl_ * 8, 0x200) : sl_ * 8; + + SetEGRate(static_cast(dr_ ? Min(63, dr_ + key_scale_rate_) : 0)); + eg_phase_ = decay; + break; + } + // fall through + case sustain: // Sustain Phase + eg_level_ = sl_ * 8; + eg_level_on_next_phase_ = ssg_type_ ? 0x200 : 0x400; + + SetEGRate(static_cast(sr_ ? Min(63, sr_ + key_scale_rate_) : 0)); + eg_phase_ = sustain; + break; + + case release: // Release Phase + inverted_ = false; + held_ = false; +#if 0 // libOPNMIDI: experimental SSG-EG + if (ssg_type_) + { + eg_level_ = eg_level_ * ssg_vector_ + ssg_offset_; + ssg_vector_ = 1; + ssg_offset_ = 0; + } +#endif + if (eg_phase_ == attack || (eg_level_ < FM_EG_BOTTOM)) //0x400/* && eg_phase_ != off*/)) + { + eg_level_on_next_phase_ = 0x400; + SetEGRate(static_cast(Min(63, rr_ + key_scale_rate_))); + eg_phase_ = release; + break; + } + // fall through + case off: // off + default: + eg_level_ = FM_EG_BOTTOM; + eg_level_on_next_phase_ = FM_EG_BOTTOM; + EGUpdate(); + SetEGRate(0); + eg_phase_ = off; + break; + } +} + +// Block/F-Num +void Operator::SetFNum(uint f) +{ + dp_ = (f & 2047) << ((f >> 11) & 7); + bn_ = notetable[(f >> 7) & 127]; + param_changed_ = true; + PARAMCHANGE(2); +} + +// １サンプルåˆæˆ + +// ISample ã‚’ envelop count (2Ï€) ã«å¤‰æ›ã™ã‚‹ã‚·ãƒ•ãƒˆé‡ +#define IS2EC_SHIFT ((20 + FM_PGBITS) - 13) + + +// 入力: s = 20+FM_PGBITS = 29 +#define Sine(s) sinetable[((s) >> (20+FM_PGBITS-FM_OPSINBITS))&(FM_OPSINENTS-1)] +#define SINE(s) sinetable[(s) & (FM_OPSINENTS-1)] + +inline FM::ISample Operator::LogToLin(uint a) +{ +#if 1 // FM_CLENTS < 0xc00 // 400 for TL, 400 for ENV, 400 for LFO. + return (a < FM_CLENTS) ? cltable[a] : 0; +#else + return cltable[a]; +#endif +} + +inline void Operator::EGUpdate() +{ +#if 1 // libOPNMIDI: experimental SSG-EG + int level = eg_level_; + level = (!inverted_) ? level : (512 - level) & 0x3ff; + eg_out_ = Min(tl_out_ + level, 0x3ff) << (1 + 2); +#else + if (!ssg_type_) + { + eg_out_ = Min(tl_out_ + eg_level_, 0x3ff) << (1 + 2); + } + else + { + eg_out_ = Min(tl_out_ + eg_level_ * ssg_vector_ + ssg_offset_, 0x3ff) << (1 + 2); + } +#endif +} + +inline void Operator::SetEGRate(uint rate) +{ + eg_rate_ = rate; + eg_count_diff_ = decaytable2[rate / 4] * chip_->GetRatio(); +} + +// EG 計算 +void FM::Operator::EGCalc() +{ + eg_count_ = (2047 * 3) << FM_RATIOBITS; // ##ã“ã®æ‰‹æŠœãã¯å†ç¾æ€§ã‚’低下ã•ã›ã‚‹ + + if (eg_phase_ == attack) + { + int c = attacktable[eg_rate_][eg_curve_count_ & 7]; + if (c >= 0) + { + eg_level_ -= 1 + (eg_level_ >> c); + if (eg_level_ <= 0) + ShiftPhase(decay); + } + EGUpdate(); + } + else + { + if (!ssg_type_) + { + eg_level_ += decaytable1[eg_rate_][eg_curve_count_ & 7]; + if (eg_level_ >= eg_level_on_next_phase_) + ShiftPhase(EGPhase(eg_phase_+1)); + EGUpdate(); + } + else + { + if (!held_) + eg_level_ += 4 * decaytable1[eg_rate_][eg_curve_count_ & 7]; + else + eg_level_ = (((ssg_type_ & 4) != 0) ^ ((ssg_type_ & 2) != 0)) ? 0 : 1024;; + EGUpdate(); // libOPNMIDI: experimental SSG-EG + if (eg_level_ >= eg_level_on_next_phase_) + { + switch (eg_phase_) + { + case decay: + ShiftPhase(sustain); + break; + case sustain: +#if 1 // libOPNMIDI: experimental SSG-EG + if (ssg_type_ & 1) + { + inverted_ = false; + held_ = true; + } + if (!held_) + { + inverted_ ^= (ssg_type_ & 2) && (ar_ == 62); // try to match polarity with nuked OPN + ShiftPhase(attack); + } +#else + ShiftPhase(attack); +#endif + break; + case release: + ShiftPhase(off); + break; + default: + break; + } + } + } + } + eg_curve_count_++; +} + +inline void FM::Operator::EGStep() +{ + eg_count_ -= eg_count_diff_; + + // EG ã®å¤‰åŒ–ã¯å…¨ã‚¹ãƒ­ãƒƒãƒˆã§åŒæœŸã—ã¦ã„ã‚‹ã¨ã„ã†å™‚ã‚‚ã‚ã‚‹ + if (eg_count_ <= 0) + EGCalc(); +} + +// PG 計算 +// ret:2^(20+PGBITS) / cycle +inline uint32 FM::Operator::PGCalc() +{ + uint32 ret = pg_count_; + pg_count_ += pg_diff_; + dbgpgout_ = ret; + return ret; +} + +inline uint32 FM::Operator::PGCalcL() +{ + uint32 ret = pg_count_; + pg_count_ += pg_diff_ + ((pg_diff_lfo_ * chip_->GetPMV()) >> 5);// & -(1 << (2+IS2EC_SHIFT))); + dbgpgout_ = ret; + return ret /* + pmv * pg_diff_;*/; +} + +// OP 計算 +// in: ISample (最大 8Ï€) +inline FM::ISample FM::Operator::Calc(ISample in) +{ + EGStep(); + out2_ = out_; + + int pgin = PGCalc() >> (20+FM_PGBITS-FM_OPSINBITS); + pgin += in >> (20+FM_PGBITS-FM_OPSINBITS-(2+IS2EC_SHIFT)); + out_ = LogToLin(eg_out_ + SINE(pgin)); + + dbgopout_ = out_; + return out_; +} + +inline FM::ISample FM::Operator::CalcL(ISample in) +{ + EGStep(); + + int pgin = PGCalcL() >> (20+FM_PGBITS-FM_OPSINBITS); + pgin += in >> (20+FM_PGBITS-FM_OPSINBITS-(2+IS2EC_SHIFT)); + out_ = LogToLin(eg_out_ + SINE(pgin) + ams_[chip_->GetAML()]); + + dbgopout_ = out_; + return out_; +} + +inline FM::ISample FM::Operator::CalcN(uint noise) +{ + EGStep(); + + int lv = Max(0, 0x3ff - (tl_out_ + eg_level_)) << 1; + + // noise & 1 ? lv : -lv ã¨ç­‰ä¾¡ + noise = (noise & 1) - 1; + out_ = (lv + noise) ^ noise; + + dbgopout_ = out_; + return out_; +} + +// OP (FB) 計算 +// Self Feedback ã®å¤‰èª¿æœ€å¤§ = 4Ï€ +inline FM::ISample FM::Operator::CalcFB(uint fb) +{ + EGStep(); + + ISample in = out_ + out2_; + out2_ = out_; + + int pgin = PGCalc() >> (20+FM_PGBITS-FM_OPSINBITS); + if (fb < 31) + { + pgin += ((in << (1 + IS2EC_SHIFT)) >> fb) >> (20+FM_PGBITS-FM_OPSINBITS); + } + out_ = LogToLin(eg_out_ + SINE(pgin)); + dbgopout_ = out2_; + + return out2_; +} + +inline FM::ISample FM::Operator::CalcFBL(uint fb) +{ + EGStep(); + + ISample in = out_ + out2_; + out2_ = out_; + + int pgin = PGCalcL() >> (20+FM_PGBITS-FM_OPSINBITS); + if (fb < 31) + { + pgin += ((in << (1 + IS2EC_SHIFT)) >> fb) >> (20+FM_PGBITS-FM_OPSINBITS); + } + + out_ = LogToLin(eg_out_ + SINE(pgin) + ams_[chip_->GetAML()]); + dbgopout_ = out_; + + return out_; +} + +#undef Sine + +// --------------------------------------------------------------------------- +// 4-op Channel +// +const uint8 Channel4::fbtable[8] = { 31, 7, 6, 5, 4, 3, 2, 1 }; +int Channel4::kftable[64]; + +bool Channel4::tablehasmade = false; + + +Channel4::Channel4() +{ + if (!tablehasmade) + MakeTable(); + + SetAlgorithm(0); + pms = pmtable[0][0]; +} + +void Channel4::MakeTable() +{ + // 100/64 cent = 2^(i*100/64*1200) + for (int i=0; i<64; i++) + { + kftable[i] = int(0x10000 * pow(2., i / 768.) ); + } +} + +// リセット +void Channel4::Reset() +{ + op[0].Reset(); + op[1].Reset(); + op[2].Reset(); + op[3].Reset(); +} + +// Calc ã®ç”¨æ„ +int Channel4::Prepare() +{ + op[0].Prepare(); + op[1].Prepare(); + op[2].Prepare(); + op[3].Prepare(); + + pms = pmtable[op[0].type_][op[0].ms_ & 7]; + int key = (op[0].IsOn() | op[1].IsOn() | op[2].IsOn() | op[3].IsOn()) ? 1 : 0; + int lfo = op[0].ms_ & (op[0].amon_ | op[1].amon_ | op[2].amon_ | op[3].amon_ ? 0x37 : 7) ? 2 : 0; + return key | lfo; +} + +// F-Number/BLOCK を設定 +void Channel4::SetFNum(uint f) +{ + for (int i=0; i<4; i++) + op[i].SetFNum(f); +} + +// KC/KF を設定 +void Channel4::SetKCKF(uint kc, uint kf) +{ + const static uint kctable[16] = + { + 5197, 5506, 5833, 6180, 6180, 6547, 6937, 7349, + 7349, 7786, 8249, 8740, 8740, 9259, 9810, 10394, + }; + + int oct = 19 - ((kc >> 4) & 7); + +//printf("%p", this); + uint kcv = kctable[kc & 0x0f]; + kcv = (kcv + 2) / 4 * 4; +//printf(" %.4x", kcv); + uint dp = kcv * kftable[kf & 0x3f]; +//printf(" %.4x %.4x %.8x", kcv, kftable[kf & 0x3f], dp >> oct); + dp >>= 16 + 3; + dp <<= 16 + 3; + dp >>= oct; + uint bn = (kc >> 2) & 31; + op[0].SetDPBN(dp, bn); + op[1].SetDPBN(dp, bn); + op[2].SetDPBN(dp, bn); + op[3].SetDPBN(dp, bn); +//printf(" %.8x\n", dp); +} + +// キー制御 +void Channel4::KeyControl(uint key) +{ + if (key & 0x1) op[0].KeyOn(); else op[0].KeyOff(); + if (key & 0x2) op[1].KeyOn(); else op[1].KeyOff(); + if (key & 0x4) op[2].KeyOn(); else op[2].KeyOff(); + if (key & 0x8) op[3].KeyOn(); else op[3].KeyOff(); +} + +// アルゴリズムを設定 +void Channel4::SetAlgorithm(uint algo) +{ + static const uint8 table1[8][6] = + { + { 0, 1, 1, 2, 2, 3 }, { 1, 0, 0, 1, 1, 2 }, + { 1, 1, 1, 0, 0, 2 }, { 0, 1, 2, 1, 1, 2 }, + { 0, 1, 2, 2, 2, 1 }, { 0, 1, 0, 1, 0, 1 }, + { 0, 1, 2, 1, 2, 1 }, { 1, 0, 1, 0, 1, 0 }, + }; + + in [0] = &buf[table1[algo][0]]; + out[0] = &buf[table1[algo][1]]; + in [1] = &buf[table1[algo][2]]; + out[1] = &buf[table1[algo][3]]; + in [2] = &buf[table1[algo][4]]; + out[2] = &buf[table1[algo][5]]; + + op[0].ResetFB(); + algo_ = algo; +} + +// åˆæˆ +ISample Channel4::Calc() +{ + int r; + switch (algo_) + { + case 0: + op[2].Calc(op[1].Out()); + op[1].Calc(op[0].Out()); + r = op[3].Calc(op[2].Out()); + op[0].CalcFB(fb); + break; + case 1: + op[2].Calc(op[0].Out() + op[1].Out()); + op[1].Calc(0); + r = op[3].Calc(op[2].Out()); + op[0].CalcFB(fb); + break; + case 2: + op[2].Calc(op[1].Out()); + op[1].Calc(0); + r = op[3].Calc(op[0].Out() + op[2].Out()); + op[0].CalcFB(fb); + break; + case 3: + op[2].Calc(0); + op[1].Calc(op[0].Out()); + r = op[3].Calc(op[1].Out() + op[2].Out()); + op[0].CalcFB(fb); + break; + case 4: + op[2].Calc(0); + r = op[1].Calc(op[0].Out()); + r += op[3].Calc(op[2].Out()); + op[0].CalcFB(fb); + break; + case 5: + r = op[2].Calc(op[0].Out()); + r += op[1].Calc(op[0].Out()); + r += op[3].Calc(op[0].Out()); + op[0].CalcFB(fb); + break; + case 6: + r = op[2].Calc(0); + r += op[1].Calc(op[0].Out()); + r += op[3].Calc(0); + op[0].CalcFB(fb); + break; + case 7: + r = op[2].Calc(0); + r += op[1].Calc(0); + r += op[3].Calc(0); + r += op[0].CalcFB(fb); + break; + default: + assert(false); + r = 0; + break; + } + return r; +} + +// åˆæˆ +ISample Channel4::CalcL() +{ + chip_->SetPMV(pms[chip_->GetPML()]); + + int r; + switch (algo_) + { + case 0: + op[2].CalcL(op[1].Out()); + op[1].CalcL(op[0].Out()); + r = op[3].CalcL(op[2].Out()); + op[0].CalcFBL(fb); + break; + case 1: + op[2].CalcL(op[0].Out() + op[1].Out()); + op[1].CalcL(0); + r = op[3].CalcL(op[2].Out()); + op[0].CalcFBL(fb); + break; + case 2: + op[2].CalcL(op[1].Out()); + op[1].CalcL(0); + r = op[3].CalcL(op[0].Out() + op[2].Out()); + op[0].CalcFBL(fb); + break; + case 3: + op[2].CalcL(0); + op[1].CalcL(op[0].Out()); + r = op[3].CalcL(op[1].Out() + op[2].Out()); + op[0].CalcFBL(fb); + break; + case 4: + op[2].CalcL(0); + r = op[1].CalcL(op[0].Out()); + r += op[3].CalcL(op[2].Out()); + op[0].CalcFBL(fb); + break; + case 5: + r = op[2].CalcL(op[0].Out()); + r += op[1].CalcL(op[0].Out()); + r += op[3].CalcL(op[0].Out()); + op[0].CalcFBL(fb); + break; + case 6: + r = op[2].CalcL(0); + r += op[1].CalcL(op[0].Out()); + r += op[3].CalcL(0); + op[0].CalcFBL(fb); + break; + case 7: + r = op[2].CalcL(0); + r += op[1].CalcL(0); + r += op[3].CalcL(0); + r += op[0].CalcFBL(fb); + break; + default: + assert(false); + r = 0; + break; + } + return r; +} + +// åˆæˆ +ISample Channel4::CalcN(uint noise) +{ + buf[1] = buf[2] = buf[3] = 0; + + buf[0] = op[0].out_; op[0].CalcFB(fb); + *out[0] += op[1].Calc(*in[0]); + *out[1] += op[2].Calc(*in[1]); + int o = op[3].out_; + op[3].CalcN(noise); + return *out[2] + o; +} + +// åˆæˆ +ISample Channel4::CalcLN(uint noise) +{ + chip_->SetPMV(pms[chip_->GetPML()]); + buf[1] = buf[2] = buf[3] = 0; + + buf[0] = op[0].out_; op[0].CalcFBL(fb); + *out[0] += op[1].CalcL(*in[0]); + *out[1] += op[2].CalcL(*in[1]); + int o = op[3].out_; + op[3].CalcN(noise); + return *out[2] + o; +} + +void Channel4::DataSave(struct Channel4Data* data) { + data->fb = fb; + memcpy(data->buf, buf, sizeof(int) * 4); + data->algo_ = algo_; + for(int i = 0; i < 4; i++) { + op[i].DataSave(&data->op[i]); + } +} + +void Channel4::DataLoad(struct Channel4Data* data) { + fb = data->fb; + memcpy(buf, data->buf, sizeof(int) * 4); + algo_ = data->algo_; + SetAlgorithm(algo_); + for(int i = 0; i < 4; i++) { + op[i].DataLoad(&data->op[i]); + } + pms = pmtable[op[0].type_][op[0].ms_ & 7]; +} +} // namespace FM diff --git a/thirdparty/opnmidi/chips/np2/fmgen_fmgen.h b/thirdparty/opnmidi/chips/np2/fmgen_fmgen.h new file mode 100644 index 0000000..2a89729 --- /dev/null +++ b/thirdparty/opnmidi/chips/np2/fmgen_fmgen.h @@ -0,0 +1,342 @@ +// --------------------------------------------------------------------------- +// FM Sound Generator +// Copyright (C) cisc 1998, 2001. +// --------------------------------------------------------------------------- +// $Id: fmgen.h,v 1.37 2003/08/25 13:33:11 cisc Exp $ + +#ifndef FM_GEN_H +#define FM_GEN_H + +#include "fmgen_types.h" + +// --------------------------------------------------------------------------- +// 出力サンプルã®åž‹ +// +// libOPNMIDI: change int32 to int16 +#define FM_SAMPLETYPE int16 // int16 or int32 + +// --------------------------------------------------------------------------- +// 定数ãã®ï¼‘ +// é™çš„テーブルã®ã‚µã‚¤ã‚º + +#define FM_LFOBITS 8 // 変更ä¸å¯ +#define FM_TLBITS 7 + +// --------------------------------------------------------------------------- + +#define FM_TLENTS (1 << FM_TLBITS) +#define FM_LFOENTS (1 << FM_LFOBITS) +#define FM_TLPOS (FM_TLENTS/4) + +// サイン波ã®ç²¾åº¦ã¯ 2^(1/256) +#define FM_CLENTS (0x1000 * 2) // sin + TL + LFO + +// --------------------------------------------------------------------------- + +namespace FM +{ + // Types ---------------------------------------------------------------- + typedef FM_SAMPLETYPE Sample; + typedef int32 ISample; + + enum OpType { typeN=0, typeM=1 }; + enum EGPhase { next, attack, decay, sustain, release, off }; + + void StoreSample(ISample& dest, int data); + + class Chip; + struct ChipData; + + // Operator ------------------------------------------------------------- + struct OperatorData { + ISample out_; + ISample out2_; + ISample in2_; + uint dp_; + uint detune_; + uint detune2_; + uint multiple_; + uint32 pg_count_; + uint32 pg_diff_; + int32 pg_diff_lfo_; + OpType type_; + uint bn_; + int eg_level_; + int eg_level_on_next_phase_; + int eg_count_; + int eg_count_diff_; + int eg_out_; + int tl_out_; + int eg_rate_; + int eg_curve_count_; +#if 0 // libOPNMIDI: experimental SSG-EG + int ssg_offset_; + int ssg_vector_; + int ssg_phase_; +#endif + uint key_scale_rate_; + EGPhase eg_phase_; + uint ms_; + + uint tl_; + uint tl_latch_; + uint ar_; + uint dr_; + uint sr_; + uint sl_; + uint rr_; + uint ks_; + uint ssg_type_; + + bool keyon_; + bool amon_; + bool param_changed_; + bool mute_; + bool inverted_; + bool held_; + }; + + class Operator + { + public: + Operator(); + void SetChip(Chip* chip) { chip_ = chip; } + + static void MakeTimeTable(uint ratio); + + ISample Calc(ISample in); + ISample CalcL(ISample in); + ISample CalcFB(uint fb); + ISample CalcFBL(uint fb); + ISample CalcN(uint noise); + void Prepare(); + void KeyOn(); + void KeyOff(); + void Reset(); + void ResetFB(); + int IsOn(); + + void SetDT(uint dt); + void SetDT2(uint dt2); + void SetMULTI(uint multi); + void SetTL(uint tl, bool csm); + void SetKS(uint ks); + void SetAR(uint ar); + void SetDR(uint dr); + void SetSR(uint sr); + void SetRR(uint rr); + void SetSL(uint sl); + void SetSSGEC(uint ssgec); + void SetFNum(uint fnum); + void SetDPBN(uint dp, uint bn); + void SetMode(bool modulator); + void SetAMON(bool on); + void SetMS(uint ms); + void Mute(bool); + +// static void SetAML(uint l); +// static void SetPML(uint l); + + int Out() { return out_; } + + int dbgGetIn2() { return in2_; } + void dbgStopPG() { pg_diff_ = 0; pg_diff_lfo_ = 0; } + + void DataSave(struct OperatorData* data); + void DataLoad(struct OperatorData* data); + + private: + typedef uint32 Counter; + + Chip* chip_; + ISample out_, out2_; + ISample in2_; + + // Phase Generator ------------------------------------------------------ + uint32 PGCalc(); + uint32 PGCalcL(); + + uint dp_; // ΔP + uint detune_; // Detune + uint detune2_; // DT2 + uint multiple_; // Multiple + uint32 pg_count_; // Phase ç¾åœ¨å€¤ + uint32 pg_diff_; // Phase 差分値 + int32 pg_diff_lfo_; // Phase 差分値 >> x + + // Envelop Generator --------------------------------------------------- + void EGCalc(); + void EGStep(); + void ShiftPhase(EGPhase nextphase); + void SSGShiftPhase(int mode); + void SetEGRate(uint); + void EGUpdate(); + int FBCalc(int fb); + ISample LogToLin(uint a); + + + OpType type_; // OP ã®ç¨®é¡ž (M, N...) + uint bn_; // Block/Note + int eg_level_; // EG ã®å‡ºåŠ›å€¤ + int eg_level_on_next_phase_; // 次㮠eg_phase_ ã«ç§»ã‚‹å€¤ + int eg_count_; // EG ã®æ¬¡ã®å¤‰ç§»ã¾ã§ã®æ™‚é–“ + int eg_count_diff_; // eg_count_ ã®å·®åˆ† + int eg_out_; // EG+TL ã‚’åˆã‚ã›ãŸå‡ºåŠ›å€¤ + int tl_out_; // TL 分ã®å‡ºåŠ›å€¤ +// int pm_depth_; // PM depth +// int am_depth_; // AM depth + int eg_rate_; + int eg_curve_count_; +#if 0 // libOPNMIDI: experimental SSG-EG + int ssg_offset_; + int ssg_vector_; + int ssg_phase_; +#endif + + uint key_scale_rate_; // key scale rate + EGPhase eg_phase_; + uint* ams_; + uint ms_; + + uint tl_; // Total Level (0-127) + uint tl_latch_; // Total Level Latch (for CSM mode) + uint ar_; // Attack Rate (0-63) + uint dr_; // Decay Rate (0-63) + uint sr_; // Sustain Rate (0-63) + uint sl_; // Sustain Level (0-127) + uint rr_; // Release Rate (0-63) + uint ks_; // Keyscale (0-3) + uint ssg_type_; // SSG-Type Envelop Control + + bool keyon_; + bool amon_; // enable Amplitude Modulation + bool param_changed_; // パラメータãŒæ›´æ–°ã•ã‚ŒãŸ + bool mute_; + bool inverted_; + bool held_; + + // Tables --------------------------------------------------------------- + static Counter rate_table[16]; + static uint32 multable[4][16]; + + static const uint8 notetable[128]; + static const int8 dttable[256]; + static const int8 decaytable1[64][8]; + static const int decaytable2[16]; + static const int8 attacktable[64][8]; + static const int ssgenvtable[8][2][3][2]; + + static uint sinetable[1024]; + static int32 cltable[FM_CLENTS]; + + static bool tablehasmade; + static void MakeTable(); + + + + // friends -------------------------------------------------------------- + friend class Channel4; + + public: + int dbgopout_; + int dbgpgout_; + static const int32* dbgGetClTable() { return cltable; } + static const uint* dbgGetSineTable() { return sinetable; } + }; + + // 4-op Channel --------------------------------------------------------- + struct Channel4Data { + uint fb; + int buf[4]; + int algo_; + struct OperatorData op[4]; + }; + + class Channel4 + { + public: + Channel4(); + void SetChip(Chip* chip); + void SetType(OpType type); + + ISample Calc(); + ISample CalcL(); + ISample CalcN(uint noise); + ISample CalcLN(uint noise); + void SetFNum(uint fnum); + void SetFB(uint fb); + void SetKCKF(uint kc, uint kf); + void SetAlgorithm(uint algo); + int Prepare(); + void KeyControl(uint key); + void Reset(); + void SetMS(uint ms); + void Mute(bool); + void Refresh(); + + void dbgStopPG() { for (int i=0; i<4; i++) op[i].dbgStopPG(); } + + void DataSave(struct Channel4Data* data); + void DataLoad(struct Channel4Data* data); + + private: + static const uint8 fbtable[8]; + uint fb; + int buf[4]; + int* in[3]; // å„ OP ã®å…¥åŠ›ãƒã‚¤ãƒ³ã‚¿ + int* out[3]; // å„ OP ã®å‡ºåŠ›ãƒã‚¤ãƒ³ã‚¿ + int* pms; + int algo_; + Chip* chip_; + + static void MakeTable(); + + static bool tablehasmade; + static int kftable[64]; + + + public: + Operator op[4]; + }; + + // Chip resource + struct ChipData { + uint ratio_; + uint aml_; + uint pml_; + int pmv_; + OpType optype_; + uint32 multable_[4][16]; + }; + + class Chip + { + public: + Chip(); + void SetRatio(uint ratio); + void SetAML(uint l); + void SetPML(uint l); + void SetPMV(int pmv) { pmv_ = pmv; } + + uint32 GetMulValue(uint dt2, uint mul) { return multable_[dt2][mul]; } + uint GetAML() { return aml_; } + uint GetPML() { return pml_; } + int GetPMV() { return pmv_; } + uint GetRatio() { return ratio_; } + + void DataSave(struct ChipData* data); + void DataLoad(struct ChipData* data); + + private: + void MakeTable(); + + uint ratio_; + uint aml_; + uint pml_; + int pmv_; +// OpType optype_; + uint32 multable_[4][16]; + }; +} + +#endif // FM_GEN_H diff --git a/thirdparty/opnmidi/chips/np2/fmgen_fmgeninl.h b/thirdparty/opnmidi/chips/np2/fmgen_fmgeninl.h new file mode 100644 index 0000000..229c4d9 --- /dev/null +++ b/thirdparty/opnmidi/chips/np2/fmgen_fmgeninl.h @@ -0,0 +1,274 @@ +// --------------------------------------------------------------------------- +// FM Sound Generator +// Copyright (C) cisc 1998, 2003. +// --------------------------------------------------------------------------- +// $Id: fmgeninl.h,v 1.26 2003/06/12 13:14:36 cisc Exp $ + +#ifndef FM_GEN_INL_H +#define FM_GEN_INL_H + +// --------------------------------------------------------------------------- +// 定数ãã®ï¼’ +// +#define FM_PI 3.14159265358979323846 + +#define FM_SINEPRESIS 2 // EGã¨ã‚µã‚¤ãƒ³æ³¢ã®ç²¾åº¦ã®å·® 0(低)-2(高) + + +#define FM_OPSINBITS 10 +#define FM_OPSINENTS (1 << FM_OPSINBITS) + +#define FM_EGCBITS 18 // eg ã® count ã®ã‚·ãƒ•ãƒˆå€¤ +#define FM_LFOCBITS 14 + +#ifdef FM_TUNEBUILD + #define FM_PGBITS 2 + #define FM_RATIOBITS 0 +#else + #define FM_PGBITS 9 + #define FM_RATIOBITS 7 // 8-12 ãらã„ã¾ã§ï¼Ÿ +#endif + +#define FM_EGBITS 16 + +//extern int paramcount[]; +//#define PARAMCHANGE(i) paramcount[i]++; +#define PARAMCHANGE(i) + +namespace FM +{ + +// --------------------------------------------------------------------------- +// Operator +// +// フィードãƒãƒƒã‚¯ãƒãƒƒãƒ•ã‚¡ã‚’クリア +inline void Operator::ResetFB() +{ + out_ = out2_ = 0; +} + +// キーオン +inline void Operator::KeyOn() +{ + if (!keyon_) + { + keyon_ = true; + held_ = false; + if (eg_phase_ == off || eg_phase_ == release) + { +#if 1 // libOPNMIDI: experimental SSG-EG + inverted_ = (ssg_type_ & 4) != 0; + inverted_ ^= (ssg_type_ & 2) && ar_ != 62; // try to match polarity with nuked OPN +#else + ssg_phase_ = -1; +#endif + ShiftPhase(attack); + EGUpdate(); + in2_ = out_ = out2_ = 0; + pg_count_ = 0; + } + } +} + +// キーオフ +inline void Operator::KeyOff() +{ + if (keyon_) + { + keyon_ = false; + ShiftPhase(release); + } +} + +// オペレータã¯ç¨¼åƒä¸­ã‹ï¼Ÿ +inline int Operator::IsOn() +{ + return eg_phase_ - off; +} + +// Detune (0-7) +inline void Operator::SetDT(uint dt) +{ + detune_ = dt * 0x20, param_changed_ = true; + PARAMCHANGE(4); +} + +// DT2 (0-3) +inline void Operator::SetDT2(uint dt2) +{ + detune2_ = dt2 & 3, param_changed_ = true; + PARAMCHANGE(5); +} + +// Multiple (0-15) +inline void Operator::SetMULTI(uint mul) +{ + multiple_ = mul, param_changed_ = true; + PARAMCHANGE(6); +} + +// Total Level (0-127) (0.75dB step) +inline void Operator::SetTL(uint tl, bool csm) +{ + if (!csm) + { + tl_ = tl, param_changed_ = true; + PARAMCHANGE(7); + } + tl_latch_ = tl; +} + +// Attack Rate (0-63) +inline void Operator::SetAR(uint ar) +{ + ar_ = ar; + param_changed_ = true; + PARAMCHANGE(8); +} + +// Decay Rate (0-63) +inline void Operator::SetDR(uint dr) +{ + dr_ = dr; + param_changed_ = true; + PARAMCHANGE(9); +} + +// Sustain Rate (0-63) +inline void Operator::SetSR(uint sr) +{ + sr_ = sr; + param_changed_ = true; + PARAMCHANGE(10); +} + +// Sustain Level (0-127) +inline void Operator::SetSL(uint sl) +{ + sl_ = sl; + param_changed_ = true; + PARAMCHANGE(11); +} + +// Release Rate (0-63) +inline void Operator::SetRR(uint rr) +{ + rr_ = rr; + param_changed_ = true; + PARAMCHANGE(12); +} + +// Keyscale (0-3) +inline void Operator::SetKS(uint ks) +{ + ks_ = ks; + param_changed_ = true; + PARAMCHANGE(13); +} + +// SSG-type Envelop (0-15) +inline void Operator::SetSSGEC(uint ssgec) +{ + if (ssgec & 8) + ssg_type_ = ssgec; + else + ssg_type_ = 0; +} + +inline void Operator::SetAMON(bool amon) +{ + amon_ = amon; + param_changed_ = true; + PARAMCHANGE(14); +} + +inline void Operator::Mute(bool mute) +{ + mute_ = mute; + param_changed_ = true; + PARAMCHANGE(15); +} + +inline void Operator::SetMS(uint ms) +{ + ms_ = ms; + param_changed_ = true; + PARAMCHANGE(16); +} + +// --------------------------------------------------------------------------- +// 4-op Channel + +// オペレータã®ç¨®é¡ž (LFO) を設定 +inline void Channel4::SetType(OpType type) +{ + for (int i=0; i<4; i++) + op[i].type_ = type; +} + +// セルフ・フィードãƒãƒƒã‚¯ãƒ¬ãƒ¼ãƒˆã®è¨­å®š (0-7) +inline void Channel4::SetFB(uint feedback) +{ + fb = fbtable[feedback]; +} + +// OPNA ç³» LFO ã®è¨­å®š +inline void Channel4::SetMS(uint ms) +{ + op[0].SetMS(ms); + op[1].SetMS(ms); + op[2].SetMS(ms); + op[3].SetMS(ms); +} + +// ãƒãƒ£ãƒ³ãƒãƒ«ãƒ»ãƒžã‚¹ã‚¯ +inline void Channel4::Mute(bool m) +{ + for (int i=0; i<4; i++) + op[i].Mute(m); +} + +// 内部パラメータをå†è¨ˆç®— +inline void Channel4::Refresh() +{ + for (int i=0; i<4; i++) + op[i].param_changed_ = true; + PARAMCHANGE(3); +} + +inline void Channel4::SetChip(Chip* chip) +{ + chip_ = chip; + for (int i=0; i<4; i++) + op[i].SetChip(chip); +} + +// --------------------------------------------------------------------------- +// +// +inline void StoreSample(Sample& dest, ISample data) +{ + if (sizeof(Sample) == 2) + dest = (Sample) Limit(dest + data, 0x7fff, -0x8000); + else + dest += data; +} + + +// --------------------------------------------------------------------------- +// AM ã®ãƒ¬ãƒ™ãƒ«ã‚’設定 +inline void Chip::SetAML(uint l) +{ + aml_ = l & (FM_LFOENTS - 1); +} + +// PM ã®ãƒ¬ãƒ™ãƒ«ã‚’設定 +inline void Chip::SetPML(uint l) +{ + pml_ = l & (FM_LFOENTS - 1); +} + + +} + +#endif // FM_GEN_INL_H diff --git a/thirdparty/opnmidi/chips/np2/fmgen_fmtimer.cpp b/thirdparty/opnmidi/chips/np2/fmgen_fmtimer.cpp new file mode 100644 index 0000000..7bbfc3e --- /dev/null +++ b/thirdparty/opnmidi/chips/np2/fmgen_fmtimer.cpp @@ -0,0 +1,217 @@ +// --------------------------------------------------------------------------- +// FM sound generator common timer module +// Copyright (C) cisc 1998, 2000. +// --------------------------------------------------------------------------- +// $Id: fmtimer.cpp,v 1.1 2000/09/08 13:45:56 cisc Exp $ + +#include "fmgen_headers.h" +#include "fmgen_fmtimer.h" + +using namespace FM; + +// --------------------------------------------------------------------------- +// タイマー制御 +// +void Timer::SetTimerControl(uint data) +{ + uint tmp = regtc ^ data; + regtc = uint8(data); + + if (data & 0x10) + ResetStatus(1); + if (data & 0x20) + ResetStatus(2); + + if (tmp & 0x01) + timera_count = (data & 1) ? timera : 0; + if (tmp & 0x02) + timerb_count = (data & 2) ? timerb : 0; +} + +#if 1 + +// --------------------------------------------------------------------------- +// タイマーA 周期設定 +// +void Timer::SetTimerA(uint addr, uint data) +{ + uint tmp; + regta[addr & 1] = uint8(data); + tmp = (regta[0] << 2) + (regta[1] & 3); + timera = (1024-tmp) * timer_step; +// LOG2("Timer A = %d %d us\n", tmp, timera >> 16); +} + +// --------------------------------------------------------------------------- +// タイマーB 周期設定 +// +void Timer::SetTimerB(uint data) +{ + timerb = (256-data) * timer_step; +// LOG2("Timer B = %d %d us\n", data, timerb >> 12); +} + +// --------------------------------------------------------------------------- +// ã‚¿ã‚¤ãƒžãƒ¼æ™‚é–“å‡¦ç† +// +bool Timer::Count(int32 us) +{ + bool event = false; + + if (timera_count) + { + timera_count -= us << 16; + if (timera_count <= 0) + { + event = true; + TimerA(); + + while (timera_count <= 0) + timera_count += timera; + + if (regtc & 4) + SetStatus(1); + } + } + if (timerb_count) + { + timerb_count -= us << 12; + if (timerb_count <= 0) + { + event = true; + while (timerb_count <= 0) + timerb_count += timerb; + + if (regtc & 8) + SetStatus(2); + } + } + return event; +} + +// --------------------------------------------------------------------------- +// 次ã«ã‚¿ã‚¤ãƒžãƒ¼ãŒç™ºç”Ÿã™ã‚‹ã¾ã§ã®æ™‚間を求ã‚ã‚‹ +// +int32 Timer::GetNextEvent() +{ + uint32 ta = ((timera_count + 0xffff) >> 16) - 1; + uint32 tb = ((timerb_count + 0xfff) >> 12) - 1; + return (ta < tb ? ta : tb) + 1; +} + +// --------------------------------------------------------------------------- +void Timer::DataSave(struct TimerData* data) +{ + data->status = status; + data->regtc = regtc; + data->regta[0] = regta[0]; + data->regta[1] = regta[1]; + data->timera = timera; + data->timera_count = timera_count; + data->timerb = timerb; + data->timerb_count = timerb_count; + data->timer_step = timer_step; +} + +// --------------------------------------------------------------------------- +void Timer::DataLoad(struct TimerData* data) +{ + status = data->status; + regtc = data->regtc; + regta[0] = data->regta[0]; + regta[1] = data->regta[1]; + timera = data->timera; + timera_count = data->timera_count; + timerb = data->timerb; + timerb_count = data->timerb_count; + timer_step = data->timer_step; +} + +// --------------------------------------------------------------------------- +// タイマー基準値設定 +// +void Timer::SetTimerBase(uint clock) +{ + timer_step = int32(1000000. * 65536 / clock); +} + +#else + +// --------------------------------------------------------------------------- +// タイマーA 周期設定 +// +void Timer::SetTimerA(uint addr, uint data) +{ + regta[addr & 1] = uint8(data); + timera = (1024 - ((regta[0] << 2) + (regta[1] & 3))) << 16; +} + +// --------------------------------------------------------------------------- +// タイマーB 周期設定 +// +void Timer::SetTimerB(uint data) +{ + timerb = (256-data) << (16 + 4); +} + +// --------------------------------------------------------------------------- +// ã‚¿ã‚¤ãƒžãƒ¼æ™‚é–“å‡¦ç† +// +bool Timer::Count(int32 us) +{ + bool event = false; + + int tick = us * timer_step; + + if (timera_count) + { + timera_count -= tick; + if (timera_count <= 0) + { + event = true; + TimerA(); + + while (timera_count <= 0) + timera_count += timera; + + if (regtc & 4) + SetStatus(1); + } + } + if (timerb_count) + { + timerb_count -= tick; + if (timerb_count <= 0) + { + event = true; + while (timerb_count <= 0) + timerb_count += timerb; + + if (regtc & 8) + SetStatus(2); + } + } + return event; +} + +// --------------------------------------------------------------------------- +// 次ã«ã‚¿ã‚¤ãƒžãƒ¼ãŒç™ºç”Ÿã™ã‚‹ã¾ã§ã®æ™‚間を求ã‚ã‚‹ +// +int32 Timer::GetNextEvent() +{ + uint32 ta = timera_count - 1; + uint32 tb = timerb_count - 1; + uint32 t = (ta < tb ? ta : tb) + 1; + + return (t+timer_step-1) / timer_step; +} + +// --------------------------------------------------------------------------- +// タイマー基準値設定 +// +void Timer::SetTimerBase(uint clock) +{ + timer_step = clock * 1024 / 15625; +} + +#endif diff --git a/thirdparty/opnmidi/chips/np2/fmgen_fmtimer.h b/thirdparty/opnmidi/chips/np2/fmgen_fmtimer.h new file mode 100644 index 0000000..38e880c --- /dev/null +++ b/thirdparty/opnmidi/chips/np2/fmgen_fmtimer.h @@ -0,0 +1,67 @@ +// --------------------------------------------------------------------------- +// FM sound generator common timer module +// Copyright (C) cisc 1998, 2000. +// --------------------------------------------------------------------------- +// $Id: fmtimer.h,v 1.2 2003/04/22 13:12:53 cisc Exp $ + +#ifndef FM_TIMER_H +#define FM_TIMER_H + +#include "fmgen_types.h" + +// --------------------------------------------------------------------------- + +namespace FM +{ + struct TimerData { + uint8 status; + uint8 regtc; + uint8 regta[2]; + int32 timera, timera_count; + int32 timerb, timerb_count; + int32 timer_step; + }; + + class Timer + { + public: + void Reset(); + bool Count(int32 us); + int32 GetNextEvent(); + + void DataSave(struct TimerData* data); + void DataLoad(struct TimerData* data); + + protected: + virtual void SetStatus(uint bit) = 0; + virtual void ResetStatus(uint bit) = 0; + + void SetTimerBase(uint clock); + void SetTimerA(uint addr, uint data); + void SetTimerB(uint data); + void SetTimerControl(uint data); + + uint8 status; + uint8 regtc; + + private: + virtual void TimerA() {} + uint8 regta[2]; + + int32 timera, timera_count; + int32 timerb, timerb_count; + int32 timer_step; + }; + +// --------------------------------------------------------------------------- +// ‰Šú‰» +// +inline void Timer::Reset() +{ + timera_count = 0; + timerb_count = 0; +} + +} // namespace FM + +#endif // FM_TIMER_H diff --git a/thirdparty/opnmidi/chips/np2/fmgen_headers.h b/thirdparty/opnmidi/chips/np2/fmgen_headers.h new file mode 100644 index 0000000..b432aed --- /dev/null +++ b/thirdparty/opnmidi/chips/np2/fmgen_headers.h @@ -0,0 +1,10 @@ +#ifndef WIN_HEADERS_H +#define WIN_HEADERS_H + +#include +#include +#include +#include +#include + +#endif // WIN_HEADERS_H diff --git a/thirdparty/opnmidi/chips/np2/fmgen_misc.h b/thirdparty/opnmidi/chips/np2/fmgen_misc.h new file mode 100644 index 0000000..a156572 --- /dev/null +++ b/thirdparty/opnmidi/chips/np2/fmgen_misc.h @@ -0,0 +1,69 @@ +// --------------------------------------------------------------------------- +// misc.h +// Copyright (C) cisc 1998, 1999. +// --------------------------------------------------------------------------- +// $Id: misc.h,v 1.5 2002/05/31 09:45:20 cisc Exp $ + +#ifndef MISC_H +#define MISC_H + +inline int Max(int x, int y) { return (x > y) ? x : y; } +inline int Min(int x, int y) { return (x < y) ? x : y; } +inline int Abs(int x) { return x >= 0 ? x : -x; } + +inline int Limit(int v, int max, int min) +{ + return v > max ? max : (v < min ? min : v); +} + +inline unsigned int BSwap(unsigned int a) +{ + return (a >> 24) | ((a >> 8) & 0xff00) | ((a << 8) & 0xff0000) | (a << 24); +} + +inline unsigned int NtoBCD(unsigned int a) +{ + return ((a / 10) << 4) + (a % 10); +} + +inline unsigned int BCDtoN(unsigned int v) +{ + return (v >> 4) * 10 + (v & 15); +} + + +template +inline T gcd(T x, T y) +{ + T t; + while (y) + { + t = x % y; + x = y; + y = t; + } + return x; +} + + +template +T bessel0(T x) +{ + T p, r, s; + + r = 1.0; + s = 1.0; + p = (x / 2.0) / s; + + while (p > 1.0E-10) + { + r += p * p; + s += 1.0; + p *= (x / 2.0) / s; + } + return r; +} + + +#endif // MISC_H + diff --git a/thirdparty/opnmidi/chips/np2/fmgen_opna.cpp b/thirdparty/opnmidi/chips/np2/fmgen_opna.cpp new file mode 100644 index 0000000..b128275 --- /dev/null +++ b/thirdparty/opnmidi/chips/np2/fmgen_opna.cpp @@ -0,0 +1,2142 @@ +// --------------------------------------------------------------------------- +// OPN/A/B interface with ADPCM support +// Copyright (C) cisc 1998, 2001. +// --------------------------------------------------------------------------- +// $Id: opna.cpp,v 1.68 2003/06/12 14:03:44 cisc Exp $ + +#include "fmgen_types.h" +#include "fmgen_headers.h" +#include "fmgen_misc.h" +#include "fmgen_opna.h" +#include "fmgen_fmgeninl.h" + +#define BUILD_OPN +#define BUILD_OPNA +#define BUILD_OPNB + + +// TOFIX: +// OPN ch3 �����Prepare�̑ÎۂƂȂ��Ă��܂���Q + + +// --------------------------------------------------------------------------- +// OPNA: ADPCM �f�[�^�̊i�[�����̈Ⴂ (8bit/1bit) ���G�~�����[�g���Ȃ� +// ���̃I�v�V������L���ɂ���� ADPCM �������ւ̃A�N�Z�X(���� 8bit ���[�h)�� +// �����y���Ȃ邩�� +// +//#define NO_BITTYPE_EMULATION + +#ifdef BUILD_OPNA +#include "fmgen_file.h" +#endif + +namespace FM +{ + +// --------------------------------------------------------------------------- +// OPNBase + +#if defined(BUILD_OPN) || defined(BUILD_OPNA) || defined (BUILD_OPNB) + +uint32 OPNBase::lfotable[8]; // OPNA/B �p + +OPNBase::OPNBase() +{ + prescale = 0; +} + +// �p�����[�^�Z�b�g +void OPNBase::SetParameter(Channel4* ch, uint addr, uint data) +{ + const static uint slottable[4] = { 0, 2, 1, 3 }; + const static uint8 sltable[16] = + { + 0, 4, 8, 12, 16, 20, 24, 28, + 32, 36, 40, 44, 48, 52, 56, 124, + }; + + if ((addr & 3) < 3) + { + uint slot = slottable[(addr >> 2) & 3]; + Operator* op = &ch->op[slot]; + + switch ((addr >> 4) & 15) + { + case 3: // 30-3E DT/MULTI + op->SetDT((data >> 4) & 0x07); + op->SetMULTI(data & 0x0f); + break; + + case 4: // 40-4E TL + op->SetTL(data & 0x7f, (regtc & 0x80) && (csmch == ch)); + break; + + case 5: // 50-5E KS/AR + op->SetKS((data >> 6) & 3); + op->SetAR((data & 0x1f) * 2); + break; + + case 6: // 60-6E DR/AMON + op->SetDR((data & 0x1f) * 2); + op->SetAMON((data & 0x80) != 0); + break; + + case 7: // 70-7E SR + op->SetSR((data & 0x1f) * 2); + break; + + case 8: // 80-8E SL/RR + op->SetSL(sltable[(data >> 4) & 15]); + op->SetRR((data & 0x0f) * 4 + 2); + break; + + case 9: // 90-9E SSG-EC + op->SetSSGEC(data & 0x0f); + break; + } + } +} + +// ���Z�b�g +void OPNBase::Reset() +{ + status = 0; + SetPrescaler(0); + Timer::Reset(); + psg.Reset(); +} + +// �v���X�P�[���ݒ� +void OPNBase::SetPrescaler(uint p) +{ + static const char table[3][2] = { { 6, 4 }, { 3, 2 }, { 2, 1 } }; + static const uint8 table2[8] = { 108, 77, 71, 67, 62, 44, 8, 5 }; + // 512 + if (prescale != p) + { + prescale = p; + /*warning: comparison is always true due to limited range of data type [-Wtype-limits]*/ + // assert(0 <= prescale && prescale < 3); + assert(prescale < 3); + + uint fmclock = clock / table[p][0] / 12; + + rate = psgrate; + + // �������g���Æo�͎��g���̔� + assert(fmclock < (0x80000000 >> FM_RATIOBITS)); + uint ratio = ((fmclock << FM_RATIOBITS) + rate/2) / rate; + + SetTimerBase(fmclock); +// MakeTimeTable(ratio); + chip.SetRatio(ratio); + psg.SetClock(clock / table[p][1], psgrate); + + for (int i=0; i<8; i++) + { + lfotable[i] = (ratio << (2+FM_LFOCBITS-FM_RATIOBITS)) / table2[i]; + } + } +} + +// ������ +bool OPNBase::Init(uint c, uint r) +{ + clock = c; + psgrate = r; + + return true; +} + +// ���Êݒ� +void OPNBase::SetVolumeFM(int db) +{ + db = Min(db, 20); + if (db > -192) + fmvolume = int(16384.0 * pow(10.0, db / 40.0)); + else + fmvolume = 0; +} + +// �^�C�}�[���Ô��� +void OPNBase::TimerA() +{ + if (regtc & 0x80) + { + csmch->KeyControl(0x00); + csmch->KeyControl(0x0f); + } +} + +void OPNBase::DataSave(struct OPNBaseData* data) { + Timer::DataSave(&data->timer); + data->fmvolume = fmvolume; + data->clock = clock; + data->rate = rate; + data->psgrate = psgrate; + data->status = status; + data->prescale = prescale; + chip.DataSave(&data->chip); + psg.DataSave(&data->psg); +} + +void OPNBase::DataLoad(struct OPNBaseData* data) { + Timer::DataLoad(&data->timer); + fmvolume = data->fmvolume; + clock = data->clock; + rate = data->rate; + psgrate = data->psgrate; + status = data->status; + prescale = data->prescale; + chip.DataLoad(&data->chip); + psg.DataLoad(&data->psg); +} + +#endif // defined(BUILD_OPN) || defined(BUILD_OPNA) || defined (BUILD_OPNB) + +// --------------------------------------------------------------------------- +// YM2203 +// +#ifdef BUILD_OPN + +OPN::OPN() +{ + SetVolumeFM(0); + SetVolumePSG(0); + + csmch = &ch[2]; + + for (int i=0; i<3; i++) + { + ch[i].SetChip(&chip); + ch[i].SetType(typeN); + } +} + +// ������ +bool OPN::Init(uint c, uint r, bool ip, const char*) +{ + if (!SetRate(c, r, ip)) + return false; + + Reset(); + + SetVolumeFM(0); + SetVolumePSG(0); + SetChannelMask(0); + return true; +} + +// �T���v�����O���[�g�ÏX +bool OPN::SetRate(uint c, uint r, bool) +{ + OPNBase::Init(c, r); + RebuildTimeTable(); + return true; +} + + +// ���Z�b�g +void OPN::Reset() +{ + int i; + for (i=0x20; i<0x28; i++) SetReg(i, 0); + for (i=0x30; i<0xc0; i++) SetReg(i, 0); + OPNBase::Reset(); + ch[0].Reset(); + ch[1].Reset(); + ch[2].Reset(); +} + + +// ���W�X�^�ǂÝ��� +uint OPN::GetReg(uint addr) +{ + if (addr < 0x10) + return psg.GetReg(addr); + else + return 0; +} + + +// ���W�X�^�A���C�Ƀf�[�^��ݒ� +void OPN::SetReg(uint addr, uint data) +{ +// LOG2("reg[%.2x] <- %.2x\n", addr, data); + if (addr >= 0x100) + return; + + int c = addr & 3; + switch (addr) + { + case 0: case 1: case 2: case 3: case 4: case 5: case 6: case 7: + case 8: case 9: case 10: case 11: case 12: case 13: case 14: case 15: + psg.SetReg(addr, data); + break; + + case 0x24: case 0x25: + SetTimerA(addr, data); + break; + + case 0x26: + SetTimerB(data); + break; + + case 0x27: + SetTimerControl(data); + break; + + case 0x28: // Key On/Off + if ((data & 3) < 3) + ch[data & 3].KeyControl(data >> 4); + break; + + case 0x2d: case 0x2e: case 0x2f: + SetPrescaler(addr-0x2d); + break; + + // F-Number + case 0xa0: case 0xa1: case 0xa2: + fnum[c] = data + fnum2[c] * 0x100; + break; + + case 0xa4: case 0xa5: case 0xa6: + fnum2[c] = uint8(data); + break; + + case 0xa8: case 0xa9: case 0xaa: + fnum3[c] = data + fnum2[c+3] * 0x100; + break; + + case 0xac: case 0xad: case 0xae: + fnum2[c+3] = uint8(data); + break; + + case 0xb0: case 0xb1: case 0xb2: + ch[c].SetFB((data >> 3) & 7); + ch[c].SetAlgorithm(data & 7); + break; + + default: + if (c < 3) + { + if ((addr & 0xf0) == 0x60) + data &= 0x1f; + OPNBase::SetParameter(&ch[c], addr, data); + } + break; + } +} + +// �X�e�[�^�X�t���O�ݒ� +void OPN::SetStatus(uint bits) +{ + if (!(status & bits)) + { + status |= bits; + Intr(true); + } +} + +void OPN::ResetStatus(uint bit) +{ + status &= ~bit; + if (!status) + Intr(false); +} + +// �}�X�N�ݒ� +void OPN::SetChannelMask(uint mask) +{ + for (int i=0; i<3; i++) + ch[i].Mute(!!(mask & (1 << i))); + psg.SetChannelMask(mask >> 6); +} + +void OPN::DataSave(struct OPNData* data) { + OPNBase::DataSave(&data->opnbase); + memcpy(data->fnum, fnum, sizeof(uint) * 3); + memcpy(data->fnum3, fnum3, sizeof(uint) * 3); + memcpy(data->fnum2, fnum2, 6); + for(int i = 0; i < 3; i++) { + ch[i].DataSave(&data->ch[i]); + } +} + +void OPN::DataLoad(struct OPNData* data) { + OPNBase::DataLoad(&data->opnbase); + memcpy(fnum, data->fnum, sizeof(uint) * 3); + memcpy(fnum3, data->fnum3, sizeof(uint) * 3); + memcpy(fnum2, data->fnum2, 6); + for(int i = 0; i < 3; i++) { + ch[i].DataLoad(&data->ch[i]); + } + csmch = &ch[2]; + for (int i=0; i<3; i++) + { + ch[i].SetChip(&chip); + ch[i].SetType(typeN); + } +} + +// ����(2ch) +void OPN::Mix(Sample* buffer, int nsamples) +{ +//printf("M:%d\n",nsamples); +#define IStoSample(s) ((Limit(s, 0x7fff, -0x8000) * fmvolume) >> 14) + + psg.Mix(buffer, nsamples); + + // Set F-Number + ch[0].SetFNum(fnum[0]); + ch[1].SetFNum(fnum[1]); + if (!(regtc & 0xc0)) + ch[2].SetFNum(fnum[2]); + else + { // ���ʉ� + ch[2].op[0].SetFNum(fnum3[1]); + ch[2].op[1].SetFNum(fnum3[2]); + ch[2].op[2].SetFNum(fnum3[0]); + ch[2].op[3].SetFNum(fnum[2]); + } + + int actch = (((ch[2].Prepare() << 2) | ch[1].Prepare()) << 2) | ch[0].Prepare(); +//printf("a %X\n",actch); + if (actch & 0x15) + { + Sample* limit = buffer + nsamples * 2; + for (Sample* dest = buffer; dest < limit; dest+=2) + { + ISample s = 0; + if (actch & 0x01) s = ch[0].Calc(); + if (actch & 0x04) s += ch[1].Calc(); + if (actch & 0x10) s += ch[2].Calc(); + s = IStoSample(s); + StoreSample(dest[0], s); + StoreSample(dest[1], s); +//printf("%08X,%08X\n",dest[0],dest[1]); + } + } +#undef IStoSample +} + +#endif // BUILD_OPN + +// --------------------------------------------------------------------------- +// YM2608/2610 common part +// --------------------------------------------------------------------------- + +#if defined(BUILD_OPNA) || defined(BUILD_OPNB) + +int OPNABase::amtable[FM_LFOENTS] = { -1, }; +int OPNABase::pmtable[FM_LFOENTS]; + +int32 OPNABase::tltable[FM_TLENTS+FM_TLPOS]; +bool OPNABase::tablehasmade = false; + +OPNABase::OPNABase() +{ + adpcmbuf = 0; + memaddr = 0; + startaddr = 0; + deltan = 256; + + adpcmvol = 0; + control2 = 0; + + MakeTable2(); + BuildLFOTable(); + for (int i=0; i<6; i++) + { + ch[i].SetChip(&chip); + ch[i].SetType(typeN); + } +} + +OPNABase::~OPNABase() +{ +} + +// --------------------------------------------------------------------------- +// ������ +// +bool OPNABase::Init(uint, uint, bool) +{ + RebuildTimeTable(); + + Reset(); + + SetVolumeFM(0); + SetVolumePSG(0); + SetChannelMask(0); + return true; +} + +// --------------------------------------------------------------------------- +// �e�[�uï¿½ï¿½ï¿½ì¬ +// +void OPNABase::MakeTable2() +{ + if (!tablehasmade) + { + for (int i=-FM_TLPOS; i> 16; + + RebuildTimeTable(); + + lfodcount = reg22 & 0x08 ? lfotable[reg22 & 7] : 0; + return true; +} + + +// --------------------------------------------------------------------------- +// �`�����l���}�X�N�Ìݒ� +// +void OPNABase::SetChannelMask(uint mask) +{ + for (int i=0; i<6; i++) + ch[i].Mute(!!(mask & (1 << i))); + psg.SetChannelMask(mask >> 6); + adpcmmask_ = (mask & (1 << 9)) != 0; + rhythmmask_ = (mask >> 10) & ((1 << 6) - 1); +} + +void OPNABase::SetPan(uint c, uint8 p) +{ + panvolume_l[c] = panlawtable[p & 0x7f]; + panvolume_r[c] = panlawtable[0x7f - (p & 0x7f)]; +} + +// --------------------------------------------------------------------------- +void OPNABase::DataSave(struct OPNABaseData* data) { + OPNBase::DataSave(&data->opnbase); + memcpy(data->pan, pan, 6); + memcpy(data->panvolume_l, panvolume_l, sizeof(uint16) * 6); + memcpy(data->panvolume_r, panvolume_r, sizeof(uint16) * 6); + memcpy(data->fnum2, fnum2, 9); + data->reg22 = reg22; + data->reg29 = reg29; + data->stmask = stmask; + data->statusnext = statusnext; + data->lfocount = lfocount; + data->lfodcount = lfodcount; + memcpy(data->fnum, fnum, sizeof(uint) * 6); + memcpy(data->fnum3, fnum3, sizeof(uint) * 3); + data->is_adpcmbuf = 0; + if(adpcmbuf) { + data->is_adpcmbuf = 1; + memcpy(data->adpcmbuf, adpcmbuf, 0x40000); + } + data->adpcmmask = adpcmmask; + data->adpcmnotice = adpcmnotice; + data->startaddr = startaddr; + data->stopaddr = stopaddr; + data->memaddr = memaddr; + data->limitaddr = limitaddr; + data->adpcmlevel = adpcmlevel; + data->adpcmvolume = adpcmvolume; + data->adpcmvol = adpcmvol; + data->deltan = deltan; + data->adplc = adplc; + data->adpld = adpld; + data->adplbase = adplbase; + data->adpcmx = adpcmx; + data->adpcmd = adpcmd; + data->adpcmout = adpcmout; + data->apout0 = apout0; + data->apout1 = apout1; + data->adpcmreadbuf = adpcmreadbuf; + data->adpcmplay = adpcmplay; + data->granuality = granuality; + data->control1 = control1; + data->control2 = control2; + memcpy(data->adpcmreg, adpcmreg, 8); + data->rhythmmask_ = rhythmmask_; + for(int i = 0; i < 6; i++) { + ch[i].DataSave(&data->ch[i]); + } +} + +// --------------------------------------------------------------------------- +void OPNABase::DataLoad(struct OPNABaseData* data) { + OPNBase::DataLoad(&data->opnbase); + memcpy(pan, data->pan, 6); + memcpy(panvolume_l, data->panvolume_l, sizeof(uint16) * 6); + memcpy(panvolume_r, data->panvolume_r, sizeof(uint16) * 6); + memcpy(fnum2, data->fnum2, 9); + reg22 = data->reg22; + reg29 = data->reg29; + stmask = data->stmask; + statusnext = data->statusnext; + lfocount = data->lfocount; + lfodcount = data->lfodcount; + memcpy(fnum, data->fnum, sizeof(uint) * 6); + memcpy(fnum3, data->fnum3, sizeof(uint) * 3); + if(data->is_adpcmbuf) { + if(!adpcmbuf) + adpcmbuf = new uint8[0x40000]; + memcpy(adpcmbuf, data->adpcmbuf, 0x40000); + } + adpcmmask = data->adpcmmask; + adpcmnotice = data->adpcmnotice; + startaddr = data->startaddr; + stopaddr = data->stopaddr; + memaddr = data->memaddr; + limitaddr = data->limitaddr; + adpcmlevel = data->adpcmlevel; + adpcmvolume = data->adpcmvolume; + adpcmvol = data->adpcmvol; + deltan = data->deltan; + adplc = data->adplc; + adpld = data->adpld; + adplbase = data->adplbase; + adpcmx = data->adpcmx; + adpcmd = data->adpcmd; + adpcmout = data->adpcmout; + apout0 = data->apout0; + apout1 = data->apout1; + adpcmreadbuf = data->adpcmreadbuf; + adpcmplay = data->adpcmplay; + granuality = data->granuality; + control1 = data->control1; + control2 = data->control2; + memcpy(adpcmreg, data->adpcmreg, 8); + rhythmmask_ = data->rhythmmask_; + for(int i = 0; i < 6; i++) { + ch[i].DataLoad(&data->ch[i]); + ch[i].SetChip(&chip); + } +} + +// --------------------------------------------------------------------------- +// ���W�X�^�A���C�Ƀf�[�^��ݒ� +// +void OPNABase::SetReg(uint addr, uint data) +{ + int c = addr & 3; + switch (addr) + { + uint modified; + + // Timer ----------------------------------------------------------------- + case 0x24: case 0x25: + SetTimerA(addr, data); + break; + + case 0x26: + SetTimerB(data); + break; + + case 0x27: + SetTimerControl(data); + break; + + // Misc ------------------------------------------------------------------ + case 0x28: // Key On/Off + if ((data & 3) < 3) + { + c = (data & 3) + (data & 4 ? 3 : 0); + ch[c].KeyControl(data >> 4); + } + break; + + // Status Mask ----------------------------------------------------------- + case 0x29: + reg29 = data; +// UpdateStatus(); //? + break; + + // Prescaler ------------------------------------------------------------- + case 0x2d: case 0x2e: case 0x2f: + SetPrescaler(addr-0x2d); + break; + + // F-Number -------------------------------------------------------------- + case 0x1a0: case 0x1a1: case 0x1a2: + c += 3; + // fall through + case 0xa0: case 0xa1: case 0xa2: + fnum[c] = data + fnum2[c] * 0x100; + ch[c].SetFNum(fnum[c]); + break; + + case 0x1a4: case 0x1a5: case 0x1a6: + c += 3; + // fall through + case 0xa4 : case 0xa5: case 0xa6: + fnum2[c] = uint8(data); + break; + + case 0xa8: case 0xa9: case 0xaa: + fnum3[c] = data + fnum2[c+6] * 0x100; + break; + + case 0xac : case 0xad: case 0xae: + fnum2[c+6] = uint8(data); + break; + + // Algorithm ------------------------------------------------------------- + + case 0x1b0: case 0x1b1: case 0x1b2: + c += 3; + // fall through + case 0xb0: case 0xb1: case 0xb2: + ch[c].SetFB((data >> 3) & 7); + ch[c].SetAlgorithm(data & 7); + break; + + case 0x1b4: case 0x1b5: case 0x1b6: + c += 3; + // fall through + case 0xb4: case 0xb5: case 0xb6: + pan[c] = (data >> 6) & 3; + ch[c].SetMS(data); + break; + + // LFO ------------------------------------------------------------------- + case 0x22: + modified = reg22 ^ data; + reg22 = data; + if (modified & 0x8) + lfocount = 0; + lfodcount = reg22 & 8 ? lfotable[reg22 & 7] : 0; + break; + + // PSG ------------------------------------------------------------------- + case 0: case 1: case 2: case 3: case 4: case 5: case 6: case 7: + case 8: case 9: case 10: case 11: case 12: case 13: case 14: case 15: + psg.SetReg(addr, data); + break; + + // ���F ------------------------------------------------------------------ + default: + if (c < 3) + { + if (addr & 0x100) + c += 3; + OPNBase::SetParameter(&ch[c], addr, data); + } + break; + } +} + +// --------------------------------------------------------------------------- +// ADPCM B +// +void OPNABase::SetADPCMBReg(uint addr, uint data) +{ + switch (addr) + { + case 0x00: // Control Register 1 + if ((data & 0x80) && !adpcmplay) + { + adpcmplay = true; + memaddr = startaddr; + adpcmx = 0, adpcmd = 127; + adplc = 0; + } + if (data & 1) + { + adpcmplay = false; + } + control1 = data; + break; + + case 0x01: // Control Register 2 + control2 = data; + granuality = control2 & 2 ? 1 : 4; + break; + + case 0x02: // Start Address L + case 0x03: // Start Address H + adpcmreg[addr - 0x02 + 0] = data; + startaddr = (adpcmreg[1]*256+adpcmreg[0]) << 6; + memaddr = startaddr; +// LOG1(" startaddr %.6x", startaddr); + break; + + case 0x04: // Stop Address L + case 0x05: // Stop Address H + adpcmreg[addr - 0x04 + 2] = data; + stopaddr = (adpcmreg[3]*256+adpcmreg[2] + 1) << 6; +// LOG1(" stopaddr %.6x", stopaddr); + break; + + case 0x08: // ADPCM data + if ((control1 & 0x60) == 0x60) + { +// LOG2(" Wr [0x%.5x] = %.2x", memaddr, data); + WriteRAM(data); + } + break; + + case 0x09: // delta-N L + case 0x0a: // delta-N H + adpcmreg[addr - 0x09 + 4] = data; + deltan = adpcmreg[5]*256+adpcmreg[4]; + deltan = Max(256, deltan); + adpld = deltan * adplbase >> 16; + break; + + case 0x0b: // Level Control + adpcmlevel = data; + adpcmvolume = (adpcmvol * adpcmlevel) >> 12; + break; + + case 0x0c: // Limit Address L + case 0x0d: // Limit Address H + adpcmreg[addr - 0x0c + 6] = data; + limitaddr = (adpcmreg[7]*256+adpcmreg[6] + 1) << 6; +// LOG1(" limitaddr %.6x", limitaddr); + break; + + case 0x10: // Flag Control + if (data & 0x80) + { + status = 0; + UpdateStatus(); + } + else + { + stmask = ~(data & 0x1f); +// UpdateStatus(); //??? + } + break; + } +} + + +// --------------------------------------------------------------------------- +// ���W�X�^�擾 +// +uint OPNA::GetReg(uint addr) +{ + if (addr < 0x10) + return psg.GetReg(addr); + + if (addr == 0x108) + { +// LOG1("%d:reg[108] -> ", Diag::GetCPUTick()); + + uint data = adpcmreadbuf & 0xff; + adpcmreadbuf >>= 8; + if ((control1 & 0x60) == 0x20) + { + adpcmreadbuf |= ReadRAM() << 8; +// LOG2("Rd [0x%.6x:%.2x] ", memaddr, adpcmreadbuf >> 8); + } +// LOG0("%.2x\n"); + return data; + } + + if (addr == 0xff) + return 1; + + return 0; +} + + + + +// --------------------------------------------------------------------------- +// �X�e�[�^�X�t���O�ݒ� +// +void OPNABase::SetStatus(uint bits) +{ + if (!(status & bits)) + { +// LOG2("SetStatus(%.2x %.2x)\n", bits, stmask); + status |= bits & stmask; + UpdateStatus(); + } +// else +// LOG1("SetStatus(%.2x) - ignored\n", bits); +} + +void OPNABase::ResetStatus(uint bits) +{ + status &= ~bits; +// LOG1("ResetStatus(%.2x)\n", bits); + UpdateStatus(); +} + +inline void OPNABase::UpdateStatus() +{ +// LOG2("%d:INT = %d\n", Diag::GetCPUTick(), (status & stmask & reg29) != 0); + Intr((status & stmask & reg29) != 0); +} + +// --------------------------------------------------------------------------- +// ADPCM RAM �ւÌ����ݑ��� +// +void OPNABase::WriteRAM(uint data) +{ +#ifndef NO_BITTYPE_EMULATION + if (!(control2 & 2)) + { + // 1 bit mode + adpcmbuf[(memaddr >> 4) & 0x3ffff] = data; + memaddr += 16; + } + else + { + // 8 bit mode + uint8* p = &adpcmbuf[(memaddr >> 4) & 0x7fff]; + uint bank = (memaddr >> 1) & 7; + uint8 mask = 1 << bank; + data <<= bank; + + p[0x00000] = (p[0x00000] & ~mask) | (uint8(data) & mask); data >>= 1; + p[0x08000] = (p[0x08000] & ~mask) | (uint8(data) & mask); data >>= 1; + p[0x10000] = (p[0x10000] & ~mask) | (uint8(data) & mask); data >>= 1; + p[0x18000] = (p[0x18000] & ~mask) | (uint8(data) & mask); data >>= 1; + p[0x20000] = (p[0x20000] & ~mask) | (uint8(data) & mask); data >>= 1; + p[0x28000] = (p[0x28000] & ~mask) | (uint8(data) & mask); data >>= 1; + p[0x30000] = (p[0x30000] & ~mask) | (uint8(data) & mask); data >>= 1; + p[0x38000] = (p[0x38000] & ~mask) | (uint8(data) & mask); + memaddr += 2; + } +#else + adpcmbuf[(memaddr >> granuality) & 0x3ffff] = data; + memaddr += 1 << granuality; +#endif + + if (memaddr == stopaddr) + { + SetStatus(4); + statusnext = 0x04; // EOS + memaddr &= 0x3fffff; + } + if (memaddr == limitaddr) + { +// LOG1("Limit ! (%.8x)\n", limitaddr); + memaddr = 0; + } + SetStatus(8); +} + +// --------------------------------------------------------------------------- +// ADPCM RAM ����̓ǂÝ��ݑ��� +// +uint OPNABase::ReadRAM() +{ + uint data; +#ifndef NO_BITTYPE_EMULATION + if (!(control2 & 2)) + { + // 1 bit mode + data = adpcmbuf[(memaddr >> 4) & 0x3ffff]; + memaddr += 16; + } + else + { + // 8 bit mode + uint8* p = &adpcmbuf[(memaddr >> 4) & 0x7fff]; + uint bank = (memaddr >> 1) & 7; + uint8 mask = 1 << bank; + + data = (p[0x38000] & mask); + data = data * 2 + (p[0x30000] & mask); + data = data * 2 + (p[0x28000] & mask); + data = data * 2 + (p[0x20000] & mask); + data = data * 2 + (p[0x18000] & mask); + data = data * 2 + (p[0x10000] & mask); + data = data * 2 + (p[0x08000] & mask); + data = data * 2 + (p[0x00000] & mask); + data >>= bank; + memaddr += 2; + } +#else + data = adpcmbuf[(memaddr >> granuality) & 0x3ffff]; + memaddr += 1 << granuality; +#endif + if (memaddr == stopaddr) + { + SetStatus(4); + statusnext = 0x04; // EOS + memaddr &= 0x3fffff; + } + if (memaddr == limitaddr) + { +// LOG1("Limit ! (%.8x)\n", limitaddr); + memaddr = 0; + } + if (memaddr < stopaddr) + SetStatus(8); + return data; +} + + +inline int OPNABase::DecodeADPCMBSample(uint data) +{ + static const int table1[16] = + { + 1, 3, 5, 7, 9, 11, 13, 15, + -1, -3, -5, -7, -9, -11, -13, -15, + }; + static const int table2[16] = + { + 57, 57, 57, 57, 77, 102, 128, 153, + 57, 57, 57, 57, 77, 102, 128, 153, + }; + adpcmx = Limit(adpcmx + table1[data] * adpcmd / 8, 32767, -32768); + adpcmd = Limit(adpcmd * table2[data] / 64, 24576, 127); + return adpcmx; +} + + +// --------------------------------------------------------------------------- +// ADPCM RAM ����� nibble �ǂÝ��݋y�� ADPCM �W�J +// +int OPNABase::ReadRAMN() +{ + uint data; + if (granuality > 0) + { +#ifndef NO_BITTYPE_EMULATION + if (!(control2 & 2)) + { + data = adpcmbuf[(memaddr >> 4) & 0x3ffff]; + memaddr += 8; + if (memaddr & 8) + return DecodeADPCMBSample(data >> 4); + data &= 0x0f; + } + else + { + uint8* p = &adpcmbuf[(memaddr >> 4) & 0x7fff] + ((~memaddr & 1) << 17); + uint bank = (memaddr >> 1) & 7; + uint8 mask = 1 << bank; + + data = (p[0x18000] & mask); + data = data * 2 + (p[0x10000] & mask); + data = data * 2 + (p[0x08000] & mask); + data = data * 2 + (p[0x00000] & mask); + data >>= bank; + memaddr ++; + if (memaddr & 1) + return DecodeADPCMBSample(data); + } +#else + data = adpcmbuf[(memaddr >> granuality) & adpcmmask]; + memaddr += 1 << (granuality-1); + if (memaddr & (1 << (granuality-1))) + return DecodeADPCMBSample(data >> 4); + data &= 0x0f; +#endif + } + else + { + data = adpcmbuf[(memaddr >> 1) & adpcmmask]; + ++memaddr; + if (memaddr & 1) + return DecodeADPCMBSample(data >> 4); + data &= 0x0f; + } + + DecodeADPCMBSample(data); + + // check + if (memaddr == stopaddr) + { + if (control1 & 0x10) + { + memaddr = startaddr; + data = adpcmx; + adpcmx = 0, adpcmd = 127; + return data; + } + else + { + memaddr &= adpcmmask; //0x3fffff; + SetStatus(adpcmnotice); + adpcmplay = false; + } + } + + if (memaddr == limitaddr) + memaddr = 0; + + return adpcmx; +} + +// --------------------------------------------------------------------------- +// �g���X�e�[�^�X��ǂ݂��� +// +uint OPNABase::ReadStatusEx() +{ + uint r = ((status | 8) & stmask) | (adpcmplay ? 0x20 : 0); + status |= statusnext; + statusnext = 0; + return r; +} + +// --------------------------------------------------------------------------- +// ADPCM �W�J +// +inline void OPNABase::DecodeADPCMB() +{ + apout0 = apout1; + int n = (ReadRAMN() * adpcmvolume) >> 13; + apout1 = adpcmout + n; + adpcmout = n; +} + +// --------------------------------------------------------------------------- +// ADPCM ���� +// +void OPNABase::ADPCMBMix(Sample* dest, uint count) +{ + uint maskl = control2 & 0x80 ? -1 : 0; + uint maskr = control2 & 0x40 ? -1 : 0; + if (adpcmmask_) + { + maskl = maskr = 0; + } + + if (adpcmplay) + { +// LOG2("ADPCM Play: %d DeltaN: %d\n", adpld, deltan); + if (adpld <= 8192) // fplay < fsamp + { + for (; count>0; count--) + { + if (adplc < 0) + { + adplc += 8192; + DecodeADPCMB(); + if (!adpcmplay) + break; + } + int s = (adplc * apout0 + (8192-adplc) * apout1) >> 13; + StoreSample(dest[0], s & maskl); + StoreSample(dest[1], s & maskr); + dest += 2; + adplc -= adpld; + } + for (; count>0 && apout0; count--) + { + if (adplc < 0) + { + apout0 = apout1, apout1 = 0; + adplc += 8192; + } + int s = (adplc * apout1) >> 13; + StoreSample(dest[0], s & maskl); + StoreSample(dest[1], s & maskr); + dest += 2; + adplc -= adpld; + } + } + else // fplay > fsamp (adpld = fplay/famp*8192) + { + int t = (-8192*8192)/adpld; + for (; count>0; count--) + { + int s = apout0 * (8192+adplc); + while (adplc < 0) + { + DecodeADPCMB(); + if (!adpcmplay) + goto stop; + s -= apout0 * Max(adplc, t); + adplc -= t; + } + adplc -= 8192; + s >>= 13; + StoreSample(dest[0], s & maskl); + StoreSample(dest[1], s & maskr); + dest += 2; + } +stop: + ; + } + } + if (!adpcmplay) + { + apout0 = apout1 = adpcmout = 0; + adplc = 0; + } +} + +// --------------------------------------------------------------------------- +// ���� +// in: buffer ������ +// nsamples �����T���v���� +// +void OPNABase::FMMix(Sample* buffer, int nsamples) +{ + if (fmvolume > 0) + { + // ���� + // Set F-Number + if (!(regtc & 0xc0)) + csmch->SetFNum(fnum[csmch-ch]); + else + { + // ���ʉ����[�h + csmch->op[0].SetFNum(fnum3[1]); csmch->op[1].SetFNum(fnum3[2]); + csmch->op[2].SetFNum(fnum3[0]); csmch->op[3].SetFNum(fnum[2]); + } + + int act = (((ch[2].Prepare() << 2) | ch[1].Prepare()) << 2) | ch[0].Prepare(); + if (reg29 & 0x80) + act |= (ch[3].Prepare() | ((ch[4].Prepare() | (ch[5].Prepare() << 2)) << 2)) << 6; + if (!(reg22 & 0x08)) + act &= 0x555; + + if (act & 0x555) + { + Mix6(buffer, nsamples, act); + } + } +} + +// --------------------------------------------------------------------------- + +void OPNABase::MixSubSL(int activech, ISample** dest) +{ + if (activech & 0x001) (*dest[0] = ch[0].CalcL()); + if (activech & 0x004) (*dest[1] += ch[1].CalcL()); + if (activech & 0x010) (*dest[2] += ch[2].CalcL()); + if (activech & 0x040) (*dest[3] += ch[3].CalcL()); + if (activech & 0x100) (*dest[4] += ch[4].CalcL()); + if (activech & 0x400) (*dest[5] += ch[5].CalcL()); +} + +inline void OPNABase::MixSubS(int activech, ISample** dest) +{ + if (activech & 0x001) (*dest[0] = ch[0].Calc()); + if (activech & 0x004) (*dest[1] += ch[1].Calc()); + if (activech & 0x010) (*dest[2] += ch[2].Calc()); + if (activech & 0x040) (*dest[3] += ch[3].Calc()); + if (activech & 0x100) (*dest[4] += ch[4].Calc()); + if (activech & 0x400) (*dest[5] += ch[5].Calc()); +} + +// --------------------------------------------------------------------------- + +void OPNABase::BuildLFOTable() +{ + if (amtable[0] == -1) + { + for (int c=0; c<256; c++) + { + int v; + if (c < 0x40) v = c * 2 + 0x80; + else if (c < 0xc0) v = 0x7f - (c - 0x40) * 2 + 0x80; + else v = (c - 0xc0) * 2; + pmtable[c] = c; + + if (c < 0x80) v = 0xff - c * 2; + else v = (c - 0x80) * 2; + amtable[c] = v & ~3; + } + } +} + +// --------------------------------------------------------------------------- + +inline void OPNABase::LFO() +{ +// LOG3("%4d - %8d, %8d\n", c, lfocount, lfodcount); + +// Operator::SetPML(pmtable[(lfocount >> (FM_LFOCBITS+1)) & 0xff]); +// Operator::SetAML(amtable[(lfocount >> (FM_LFOCBITS+1)) & 0xff]); + chip.SetPML(pmtable[(lfocount >> (FM_LFOCBITS+1)) & 0xff]); + chip.SetAML(amtable[(lfocount >> (FM_LFOCBITS+1)) & 0xff]); + lfocount += lfodcount; +} + +// --------------------------------------------------------------------------- +// ���� +// +#define IStoSample(s) ((Limit(s, 0x7fff, -0x8000) * fmvolume) >> 14) + +void OPNABase::Mix6(Sample* buffer, int nsamples, int activech) +{ + // Mix + // libOPNMIDI: rewrite for panning support + + const uint activechmask[6] = {0x001, 0x004, 0x010, 0x040, 0x100, 0x400}; + + Sample* limit = buffer + nsamples * 2; + for (Sample* dest = buffer; dest < limit; dest+=2) + { + ISample out[6]; + if (activech & 0xaaa) + { + LFO(); + for (uint c = 0; c<6; ++c) + out[c] = (activechmask[c] & activech) ? ch[c].CalcL() : 0; + } + else + { + for (uint c = 0; c<6; ++c) + out[c] = (activechmask[c] & activech) ? ch[c].Calc() : 0; + } + + int lrouts[2] = {0, 0}; + for (uint c = 0; c<6; ++c) + { + int panl = panvolume_l[c]; + int panr = panvolume_r[c]; + panl = (pan[c] & 2) ? panl : 0; + panr = (pan[c] & 1) ? panr : 0; + lrouts[0] += out[c] * panl / 65535; + lrouts[1] += out[c] * panr / 65535; + } + + StoreSample(dest[0], lrouts[0]); + StoreSample(dest[1], lrouts[1]); + } +} + +#endif // defined(BUILD_OPNA) || defined(BUILD_OPNB) + +// --------------------------------------------------------------------------- +// YM2608(OPNA) +// --------------------------------------------------------------------------- + +#ifdef BUILD_OPNA + +// --------------------------------------------------------------------------- +// �\�z +// +OPNA::OPNA() +{ + for (int i=0; i<6; i++) + { + rhythm[i].sample = 0; + rhythm[i].pos = 0; + rhythm[i].size = 0; + rhythm[i].volume = 0; + } + rhythmtvol = 0; + adpcmmask = 0x3ffff; + adpcmnotice = 4; + csmch = &ch[2]; +} + +// --------------------------------------------------------------------------- + +OPNA::~OPNA() +{ + delete[] adpcmbuf; + for (int i=0; i<6; i++) + delete[] rhythm[i].sample; +} + + + +// --------------------------------------------------------------------------- +// ������ +// +bool OPNA::Init(uint c, uint r, bool ipflag, const char* path) +{ + rate = 8000; + LoadRhythmSample(path); + + if (!adpcmbuf) + adpcmbuf = new uint8[0x40000]; + if (!adpcmbuf) + return false; + + if (!SetRate(c, r, ipflag)) + return false; + if (!OPNABase::Init(c, r, ipflag)) + return false; + + Reset(); + + SetVolumeADPCM(0); + SetVolumeRhythmTotal(0); + for (int i=0; i<6; i++) + SetVolumeRhythm(0, 0); + return true; +} + +// --------------------------------------------------------------------------- +// ���Z�b�g +// +void OPNA::Reset() +{ + reg29 = 0x1f; + rhythmkey = 0; + limitaddr = 0x3ffff; + OPNABase::Reset(); +} + +// --------------------------------------------------------------------------- +// �T���v�����O���[�g�ÏX +// +bool OPNA::SetRate(uint c, uint r, bool ipflag) +{ + if (!OPNABase::SetRate(c, r, ipflag)) + return false; + + for (int i=0; i<6; i++) + { + rhythm[i].step = rhythm[i].rate * 1024 / r; + } + return true; +} + + +// --------------------------------------------------------------------------- +// ���Y������ǂ݂��� +// +bool OPNA::LoadRhythmSample(const char* path) +{ + static const char* rhythmname[6] = + { + "bd", "sd", "top", "hh", "tom", "rim", + }; + + int i; + for (i=0; i<6; i++) + rhythm[i].pos = ~0u; + + for (i=0; i<6; i++) + { + FileIO file; + uint32 fsize; + char buf[MAX_PATH + 1] = ""; + if (path) + strncpy(buf, path, MAX_PATH); + strncat(buf, "2608_", MAX_PATH); + strncat(buf, rhythmname[i], MAX_PATH); + strncat(buf, ".wav", MAX_PATH); + + if (!file.Open(buf, FileIO::readonly)) + { + if (i != 5) + break; + if (path) + strncpy(buf, path, MAX_PATH); + strncpy(buf, "2608_rym.wav", MAX_PATH); + if (!file.Open(buf, FileIO::readonly)) + break; + } + + struct + { + uint32 chunksize; + uint16 tag; + uint16 nch; + uint32 rate; + uint32 avgbytes; + uint16 align; + uint16 bps; + uint16 size; + } whdr; + + file.Seek(0x10, FileIO::begin); + file.Read(&whdr, sizeof(whdr)); + + uint8 subchunkname[4]; + fsize = 4 + whdr.chunksize - sizeof(whdr); + do + { + file.Seek(fsize, FileIO::current); + file.Read(&subchunkname, 4); + file.Read(&fsize, 4); + } while (memcmp("data", subchunkname, 4)); + + fsize /= 2; + if (fsize >= 0x100000 || whdr.tag != 1 || whdr.nch != 1) + break; + fsize = Max(fsize, (1<<31)/1024); + + if(!rhythm[i].sample) + delete rhythm[i].sample; + rhythm[i].sample = new int16[fsize]; + if (!rhythm[i].sample) + break; + + file.Read(rhythm[i].sample, fsize * 2); + + rhythm[i].rate = whdr.rate; + rhythm[i].step = rhythm[i].rate * 1024 / rate; + rhythm[i].pos = rhythm[i].size = fsize * 1024; + } + if (i != 6) + { + for (i=0; i<6; i++) + { + delete[] rhythm[i].sample; + rhythm[i].sample = 0; + } + return false; + } + return true; +} + + + +// --------------------------------------------------------------------------- +// ���W�X�^�A���C�Ƀf�[�^��ݒ� +// +void OPNA::SetReg(uint addr, uint data) +{ + addr &= 0x1ff; + + switch (addr) + { + case 0x29: + reg29 = data; +// UpdateStatus(); //? + break; + + // Rhythm ---------------------------------------------------------------- + case 0x10: // DM/KEYON + if (!(data & 0x80)) // KEY ON + { + rhythmkey |= data & 0x3f; + if (data & 0x01) rhythm[0].pos = 0; + if (data & 0x02) rhythm[1].pos = 0; + if (data & 0x04) rhythm[2].pos = 0; + if (data & 0x08) rhythm[3].pos = 0; + if (data & 0x10) rhythm[4].pos = 0; + if (data & 0x20) rhythm[5].pos = 0; + } + else + { // DUMP + rhythmkey &= ~data; + } + break; + + case 0x11: + rhythmtl = ~data & 63; + break; + + case 0x18: // Bass Drum + case 0x19: // Snare Drum + case 0x1a: // Top Cymbal + case 0x1b: // Hihat + case 0x1c: // Tom-tom + case 0x1d: // Rim shot + rhythm[addr & 7].pan = (data >> 6) & 3; + rhythm[addr & 7].level = ~data & 31; + break; + + case 0x100: case 0x101: + case 0x102: case 0x103: + case 0x104: case 0x105: + case 0x108: case 0x109: + case 0x10a: case 0x10b: + case 0x10c: case 0x10d: + case 0x110: + OPNABase::SetADPCMBReg(addr - 0x100, data); + break; + + default: + OPNABase::SetReg(addr, data); + break; + } +} + +// --------------------------------------------------------------------------- +void OPNA::DataSave(struct OPNAData* data) { + OPNABase::DataSave(&data->opnabase); + memcpy(data->rhythm, rhythm, sizeof(Rhythm) * 6); + data->rhythmtl = rhythmtl; + data->rhythmtvol = rhythmtvol; + data->rhythmkey = rhythmkey; +} + +// --------------------------------------------------------------------------- +void OPNA::DataLoad(struct OPNAData* data) { + OPNABase::DataLoad(&data->opnabase); + memcpy(rhythm, data->rhythm, sizeof(Rhythm) * 6); + rhythmtl = data->rhythmtl; + rhythmtvol = data->rhythmtvol; + rhythmkey = data->rhythmkey; + csmch = &ch[2]; +} + +// --------------------------------------------------------------------------- +// ���Y������ +// +void OPNA::RhythmMix(Sample* buffer, uint count) +{ + if (rhythmtvol < 128 && rhythm[0].sample && (rhythmkey & 0x3f)) + { + Sample* limit = buffer + count * 2; + for (int i=0; i<6; i++) + { + Rhythm& r = rhythm[i]; + if ((rhythmkey & (1 << i)) /*&& r.level < 128*/) // libOPNMIDI: Useless condition, signed int 8t has 127 max + { + int db = Limit(rhythmtl+rhythmtvol+r.level+r.volume, 127, -31); + int vol = tltable[FM_TLPOS+(db << (FM_TLBITS-7))] >> 4; + int maskl = -((r.pan >> 1) & 1); + int maskr = -(r.pan & 1); + + if (rhythmmask_ & (1 << i)) + { + maskl = maskr = 0; + } + + for (Sample* dest = buffer; dest> 12; + r.pos += r.step; + StoreSample(dest[0], sample & maskl); + StoreSample(dest[1], sample & maskr); + } + } + } + } +} + +// --------------------------------------------------------------------------- +// ���Êݒ� +// +void OPNA::SetVolumeRhythmTotal(int db) +{ + db = Min(db, 20); + rhythmtvol = -(db * 2 / 3); +} + +void OPNA::SetVolumeRhythm(int index, int db) +{ + db = Min(db, 20); + rhythm[index].volume = -(db * 2 / 3); +} + +void OPNA::SetVolumeADPCM(int db) +{ + db = Min(db, 20); + if (db > -192) + adpcmvol = int(65536.0 * pow(10.0, db / 40.0)); + else + adpcmvol = 0; + + adpcmvolume = (adpcmvol * adpcmlevel) >> 12; +} + +// --------------------------------------------------------------------------- +// ���� +// in: buffer ������ +// nsamples �����T���v���� +// +void OPNA::Mix(Sample* buffer, int nsamples) +{ + FMMix(buffer, nsamples); + psg.Mix(buffer, nsamples); + ADPCMBMix(buffer, nsamples); + RhythmMix(buffer, nsamples); +} + +#endif // BUILD_OPNA + +// --------------------------------------------------------------------------- +// YM2610(OPNB) +// --------------------------------------------------------------------------- + +#ifdef BUILD_OPNB + +// --------------------------------------------------------------------------- +// �\�z +// +OPNB::OPNB() +{ + adpcmabuf = 0; + adpcmasize = 0; + for (int i=0; i<6; i++) + { + adpcma[i].pan = 0; + adpcma[i].level = 0; + adpcma[i].volume = 0; + adpcma[i].pos = 0; + adpcma[i].step = 0; + adpcma[i].volume = 0; + adpcma[i].start = 0; + adpcma[i].stop = 0; + adpcma[i].adpcmx = 0; + adpcma[i].adpcmd = 0; + } + adpcmatl = 0; + adpcmakey = 0; + adpcmatvol = 0; + adpcmmask = 0; + adpcmnotice = 0x8000; + granuality = -1; + csmch = &ch[2]; + + InitADPCMATable(); +} + +OPNB::~OPNB() +{ +} + +// --------------------------------------------------------------------------- +// ������ +// +bool OPNB::Init(uint c, uint r, bool ipflag, + uint8 *_adpcma, int _adpcma_size, + uint8 *_adpcmb, int _adpcmb_size) +{ + int i; + if (!SetRate(c, r, ipflag)) + return false; + if (!OPNABase::Init(c, r, ipflag)) + return false; + + adpcmabuf = _adpcma; + adpcmasize = _adpcma_size; + adpcmbuf = _adpcmb; + + for (i=0; i<=24; i++) // max 16M bytes + { + if (_adpcmb_size <= (1 << i)) + { + adpcmmask = (1 << i) - 1; + break; + } + } + +// adpcmmask = _adpcmb_size - 1; + limitaddr = adpcmmask; + + Reset(); + + SetVolumeFM(0); + SetVolumePSG(0); + SetVolumeADPCMB(0); + SetVolumeADPCMATotal(0); + for (i=0; i<6; i++) + SetVolumeADPCMA(0, 0); + SetChannelMask(0); + return true; +} + +// --------------------------------------------------------------------------- +// ���Z�b�g +// +void OPNB::Reset() +{ + OPNABase::Reset(); + + stmask = ~0; + adpcmakey = 0; + reg29 = ~0; + + for (int i=0; i<6; i++) + { + adpcma[i].pan = 0; + adpcma[i].level = 0; + adpcma[i].volume = 0; + adpcma[i].pos = 0; + adpcma[i].step = 0; + adpcma[i].volume = 0; + adpcma[i].start = 0; + adpcma[i].stop = 0; + adpcma[i].adpcmx = 0; + adpcma[i].adpcmd = 0; + } +} + +// --------------------------------------------------------------------------- +// �T���v�����O���[�g�ÏX +// +bool OPNB::SetRate(uint c, uint r, bool ipflag) +{ + if (!OPNABase::SetRate(c, r, ipflag)) + return false; + + adpcmastep = int(double(c) / 54 * 8192 / r); + return true; +} + +// --------------------------------------------------------------------------- +// ���W�X�^�A���C�Ƀf�[�^��ݒ� +// +void OPNB::SetReg(uint addr, uint data) +{ + addr &= 0x1ff; + + switch (addr) + { + // omitted registers + case 0x29: + case 0x2d: case 0x2e: case 0x2f: + break; + + // ADPCM A --------------------------------------------------------------- + case 0x100: // DM/KEYON + if (!(data & 0x80)) // KEY ON + { + adpcmakey |= data & 0x3f; + for (int c=0; c<6; c++) + { + if (data & (1<> 6) & 3; + adpcma[addr & 7].level = ~data & 31; + break; + + case 0x110: case 0x111: case 0x112: // START ADDRESS (L) + case 0x113: case 0x114: case 0x115: + case 0x118: case 0x119: case 0x11a: // START ADDRESS (H) + case 0x11b: case 0x11c: case 0x11d: + adpcmareg[addr - 0x110] = data; + adpcma[addr & 7].pos = adpcma[addr & 7].start = + (adpcmareg[(addr&7)+8]*256+adpcmareg[addr&7]) << 9; + break; + + case 0x120: case 0x121: case 0x122: // END ADDRESS (L) + case 0x123: case 0x124: case 0x125: + case 0x128: case 0x129: case 0x12a: // END ADDRESS (H) + case 0x12b: case 0x12c: case 0x12d: + adpcmareg[addr - 0x110] = data; + adpcma[addr & 7].stop = + (adpcmareg[(addr&7)+24]*256+adpcmareg[(addr&7)+16] + 1) << 9; + break; + + // ADPCMB ----------------------------------------------------------------- + case 0x10: + if ((data & 0x80) && !adpcmplay) + { + adpcmplay = true; + memaddr = startaddr; + adpcmx = 0, adpcmd = 127; + adplc = 0; + } + if (data & 1) + adpcmplay = false; + control1 = data & 0x91; + break; + + + case 0x11: // Control Register 2 + control2 = data & 0xc0; + break; + + case 0x12: // Start Address L + case 0x13: // Start Address H + adpcmreg[addr - 0x12 + 0] = data; + startaddr = (adpcmreg[1]*256+adpcmreg[0]) << 9; + memaddr = startaddr; + break; + + case 0x14: // Stop Address L + case 0x15: // Stop Address H + adpcmreg[addr - 0x14 + 2] = data; + stopaddr = (adpcmreg[3]*256+adpcmreg[2] + 1) << 9; +// LOG1(" stopaddr %.6x", stopaddr); + break; + + case 0x19: // delta-N L + case 0x1a: // delta-N H + adpcmreg[addr - 0x19 + 4] = data; + deltan = adpcmreg[5]*256+adpcmreg[4]; + deltan = Max(256, deltan); + adpld = deltan * adplbase >> 16; + break; + + case 0x1b: // Level Control + adpcmlevel = data; + adpcmvolume = (adpcmvol * adpcmlevel) >> 12; + break; + + case 0x1c: // Flag Control + stmask = ~((data & 0xbf) << 8); + status &= stmask; + UpdateStatus(); + break; + + default: + OPNABase::SetReg(addr, data); + break; + } +// LOG0("\n"); +} + +// --------------------------------------------------------------------------- +// ���W�X�^�擾 +// +uint OPNB::GetReg(uint addr) +{ + if (addr < 0x10) + return psg.GetReg(addr); + + return 0; +} + +// --------------------------------------------------------------------------- +// �g���X�e�[�^�X��ǂ݂��� +// +uint OPNB::ReadStatusEx() +{ + return (status & stmask) >> 8; +} + +// --------------------------------------------------------------------------- +// YM2610 +// +int OPNB::jedi_table[(48+1)*16]; + +void OPNB::InitADPCMATable() +{ + const static int8 table2[] = + { + 1, 3, 5, 7, 9, 11, 13, 15, + -1, -3, -5, -7, -9,-11,-13,-15, + }; + + for (int i=0; i<=48; i++) + { + int s = int(16.0 * pow (1.1, i) * 3); + for (int j=0; j<16; j++) + { + jedi_table[i*16+j] = s * table2[j] / 8; + } + } +} + +// --------------------------------------------------------------------------- +// ADPCMA ���� +// +void OPNB::ADPCMAMix(Sample* buffer, uint count) +{ + const static int decode_tableA1[16] = + { + -1*16, -1*16, -1*16, -1*16, 2*16, 5*16, 7*16, 9*16, + -1*16, -1*16, -1*16, -1*16, 2*16, 5*16, 7*16, 9*16 + }; + + if (adpcmatvol < 128 && (adpcmakey & 0x3f)) + { + Sample* limit = buffer + count * 2; + for (int i=0; i<6; i++) + { + ADPCMA& r = adpcma[i]; + if ((adpcmakey & (1 << i))/* && r.level < 128*/) // libOPNMIDI: Useless condition, signed int 8t has 127 max + { + uint maskl = r.pan & 2 ? -1 : 0; + uint maskr = r.pan & 1 ? -1 : 0; + if (rhythmmask_ & (1 << i)) + { + maskl = maskr = 0; + } + + int db = Limit(adpcmatl+adpcmatvol+r.level+r.volume, 127, -31); + int vol = tltable[FM_TLPOS+(db << (FM_TLBITS-7))] >> 4; + + Sample* dest = buffer; + for ( ; dest= r.stop) + { + SetStatus(0x100 << i); + adpcmakey &= ~(1< 0x10000; r.step -= 0x10000) + { + int data; + if (!(r.pos & 1)) + { + r.nibble = adpcmabuf[r.pos>>1]; + data = r.nibble >> 4; + } + else + { + data = r.nibble & 0x0f; + } + r.pos++; + + r.adpcmx += jedi_table[r.adpcmd + data]; + r.adpcmx = Limit(r.adpcmx, 2048*3-1, -2048*3); + r.adpcmd += decode_tableA1[data]; + r.adpcmd = Limit(r.adpcmd, 48*16, 0); + } + int sample = (r.adpcmx * vol) >> 10; + StoreSample(dest[0], sample & maskl); + StoreSample(dest[1], sample & maskr); + } + } + } + } +} + +// --------------------------------------------------------------------------- +// ���Êݒ� +// +void OPNB::SetVolumeADPCMATotal(int db) +{ + db = Min(db, 20); + adpcmatvol = -(db * 2 / 3); +} + +void OPNB::SetVolumeADPCMA(int index, int db) +{ + db = Min(db, 20); + adpcma[index].volume = -(db * 2 / 3); +} + +void OPNB::SetVolumeADPCMB(int db) +{ + db = Min(db, 20); + if (db > -192) + adpcmvol = int(65536.0 * pow(10, db / 40.0)); + else + adpcmvol = 0; +} + +// --------------------------------------------------------------------------- +void OPNB::DataSave(struct OPNBData* data, void* adpcmadata) { + OPNABase::DataSave(&data->opnabase); + if(adpcmasize) { + adpcmadata = malloc(adpcmasize); + memcpy(adpcmadata, adpcmabuf, adpcmasize); + } + data->adpcmasize = adpcmasize; + memcpy(data->adpcma, adpcma, sizeof(ADPCMA) * 6); + data->adpcmatl = adpcmatl; + data->adpcmatvol = adpcmatvol; + data->adpcmakey = adpcmakey; + data->adpcmastep = adpcmastep; + memcpy(data->adpcmareg, adpcmareg, 32); + for(int i = 0; i < 6; i++) { + ch[i].DataSave(&data->ch[i]); + } +} + +// --------------------------------------------------------------------------- +void OPNB::DataLoad(struct OPNBData* data, void* adpcmadata) { + OPNABase::DataLoad(&data->opnabase); // libOPNMIDI: bugfix DataLoad (was DataSave here) + if(data->adpcmasize) { + adpcmabuf = (uint8*)malloc(data->adpcmasize); + memcpy(adpcmabuf, adpcmadata, data->adpcmasize); + } + adpcmasize = data->adpcmasize; + memcpy(adpcma, data->adpcma, sizeof(ADPCMA) * 6); + adpcmatl = data->adpcmatl; + adpcmatvol = data->adpcmatvol; + adpcmakey = data->adpcmakey; + adpcmastep = data->adpcmastep; + memcpy(adpcmareg, data->adpcmareg, 32); + for(int i = 0; i < 6; i++) { + ch[i].DataLoad(&data->ch[i]); + } + csmch = &ch[2]; +} + +// --------------------------------------------------------------------------- +// ���� +// in: buffer ������ +// nsamples �����T���v���� +// +void OPNB::Mix(Sample* buffer, int nsamples) +{ + FMMix(buffer, nsamples); + psg.Mix(buffer, nsamples); + ADPCMBMix(buffer, nsamples); + ADPCMAMix(buffer, nsamples); +} + +#endif // BUILD_OPNB + +} // namespace FM diff --git a/thirdparty/opnmidi/chips/np2/fmgen_opna.h b/thirdparty/opnmidi/chips/np2/fmgen_opna.h new file mode 100644 index 0000000..634a0cb --- /dev/null +++ b/thirdparty/opnmidi/chips/np2/fmgen_opna.h @@ -0,0 +1,523 @@ +// --------------------------------------------------------------------------- +// OPN/A/B interface with ADPCM support +// Copyright (C) cisc 1998, 2003. +// --------------------------------------------------------------------------- +// $Id: opna.h,v 1.33 2003/06/12 13:14:37 cisc Exp $ + +#ifndef FM_OPNA_H +#define FM_OPNA_H + +#include "fmgen_fmgen.h" +#include "fmgen_fmtimer.h" +#include "fmgen_psg.h" + +// --------------------------------------------------------------------------- +// class OPN/OPNA +// OPN/OPNA ã«è‰¯ãä¼¼ãŸéŸ³ã‚’生æˆã™ã‚‹éŸ³æºãƒ¦ãƒ‹ãƒƒãƒˆ +// +// interface: +// bool Init(uint clock, uint rate, bool, const char* path); +// åˆæœŸåŒ–．ã“ã®ã‚¯ãƒ©ã‚¹ã‚’使用ã™ã‚‹å‰ã«ã‹ãªã‚‰ãšå‘¼ã‚“ã§ãŠãã“ã¨ï¼Ž +// OPNA ã®å ´åˆã¯ã“ã®é–¢æ•°ã§ãƒªã‚ºãƒ ã‚µãƒ³ãƒ—ルを読ã¿è¾¼ã‚€ +// +// clock: OPN/OPNA/OPNB ã®ã‚¯ãƒ­ãƒƒã‚¯å‘¨æ³¢æ•°(Hz) +// +// rate: 生æˆã™ã‚‹ PCM ã®æ¨™æœ¬å‘¨æ³¢æ•°(Hz) +// +// path: リズムサンプルã®ãƒ‘ス(OPNA ã®ã¿æœ‰åŠ¹) +// çœç•¥æ™‚ã¯ã‚«ãƒ¬ãƒ³ãƒˆãƒ‡ã‚£ãƒ¬ã‚¯ãƒˆãƒªã‹ã‚‰èª­ã¿è¾¼ã‚€ +// 文字列ã®æœ«å°¾ã«ã¯ 'Â¥' ã‚„ '/' ãªã©ã‚’ã¤ã‘ã‚‹ã“㨠+// +// 返り値 åˆæœŸåŒ–ã«æˆåŠŸã™ã‚Œã° true +// +// bool LoadRhythmSample(const char* path) +// (OPNA ONLY) +// Rhythm サンプルを読ã¿ç›´ã™ï¼Ž +// path 㯠Init ã® path ã¨åŒã˜ï¼Ž +// +// bool SetRate(uint clock, uint rate, bool) +// クロックや PCM レートを変更ã™ã‚‹ +// 引数等㯠Init ã‚’å‚ç…§ã®ã“ã¨ï¼Ž +// +// void Mix(FM_SAMPLETYPE* dest, int nsamples) +// Stereo PCM データを nsamples 分åˆæˆã—， dest ã§å§‹ã¾ã‚‹é…列㫠+// 加ãˆã‚‹(加算ã™ã‚‹) +// ・dest ã«ã¯ sample*2 個分ã®é ˜åŸŸãŒå¿…è¦ +// ・格ç´å½¢å¼ã¯ L, R, L, R... ã¨ãªã‚‹ï¼Ž +// ・ã‚ãã¾ã§åŠ ç®—ãªã®ã§ï¼Œã‚らã‹ã˜ã‚é…列をゼロクリアã™ã‚‹å¿…è¦ãŒã‚ã‚‹ +// ・FM_SAMPLETYPE ㌠short åž‹ã®å ´åˆã‚¯ãƒªãƒƒãƒ”ングãŒè¡Œã‚れる. +// ・ã“ã®é–¢æ•°ã¯éŸ³æºå†…部ã®ã‚¿ã‚¤ãƒžãƒ¼ã¨ã¯ç‹¬ç«‹ã—ã¦ã„る． +// Timer 㯠Count 㨠GetNextEvent ã§æ“作ã™ã‚‹å¿…è¦ãŒã‚る． +// +// void Reset() +// 音æºã‚’リセット(åˆæœŸåŒ–)ã™ã‚‹ +// +// void SetReg(uint reg, uint data) +// 音æºã®ãƒ¬ã‚¸ã‚¹ã‚¿ reg ã« data を書ã込む +// +// uint GetReg(uint reg) +// 音æºã®ãƒ¬ã‚¸ã‚¹ã‚¿ reg ã®å†…容を読ã¿å‡ºã™ +// 読ã¿è¾¼ã‚€ã“ã¨ãŒå‡ºæ¥ã‚‹ãƒ¬ã‚¸ã‚¹ã‚¿ã¯ PSG, ADPCM ã®ä¸€éƒ¨ï¼ŒID(0xff) ã¨ã‹ +// +// uint ReadStatus()/ReadStatusEx() +// 音æºã®ã‚¹ãƒ†ãƒ¼ã‚¿ã‚¹ãƒ¬ã‚¸ã‚¹ã‚¿ã‚’読ã¿å‡ºã™ +// ReadStatusEx ã¯æ‹¡å¼µã‚¹ãƒ†ãƒ¼ã‚¿ã‚¹ãƒ¬ã‚¸ã‚¹ã‚¿ã®èª­ã¿å‡ºã—(OPNA) +// busy フラグã¯å¸¸ã« 0 +// +// bool Count(uint32 t) +// 音æºã®ã‚¿ã‚¤ãƒžãƒ¼ã‚’ t [μ秒] 進ã‚る． +// 音æºã®å†…部状態ã«å¤‰åŒ–ãŒã‚ã£ãŸæ™‚(timer オーãƒãƒ¼ãƒ•ãƒ­ãƒ¼) +// true を返㙠+// +// uint32 GetNextEvent() +// 音æºã®ã‚¿ã‚¤ãƒžãƒ¼ã®ã©ã¡ã‚‰ã‹ãŒã‚ªãƒ¼ãƒãƒ¼ãƒ•ãƒ­ãƒ¼ã™ã‚‹ã¾ã§ã«å¿…è¦ãª +// 時間[μ秒]を返㙠+// タイマーãŒåœæ­¢ã—ã¦ã„ã‚‹å ´åˆã¯ ULONG_MAX ã‚’è¿”ã™â€¦ ã¨æ€ã† +// +// void SetVolumeFM(int db)/SetVolumePSG(int db) ... +// å„音æºã®éŸ³é‡ã‚’＋−方å‘ã«èª¿ç¯€ã™ã‚‹ï¼Žæ¨™æº–値㯠0. +// å˜ä½ã¯ç´„ 1/2 dB，有効範囲ã®ä¸Šé™ã¯ 20 (10dB) +// +namespace FM +{ + // OPN Base ------------------------------------------------------- + struct OPNBaseData { + struct TimerData timer; + int fmvolume; + uint clock; + uint rate; + uint psgrate; + uint status; + uint8 prescale; + struct ChipData chip; + struct PSGData psg; + }; + + class OPNBase : public Timer + { + public: + OPNBase(); + + bool Init(uint c, uint r); + virtual void Reset(); + + void SetVolumeFM(int db); + void SetVolumePSG(int db); + + void DataSave(struct OPNBaseData* data); + void DataLoad(struct OPNBaseData* data); + + protected: + void SetParameter(Channel4* ch, uint addr, uint data); + void SetPrescaler(uint p); + void RebuildTimeTable(); + + int fmvolume; + + uint clock; // OPN クロック + uint rate; // FM 音æºåˆæˆãƒ¬ãƒ¼ãƒˆ + uint psgrate; // FMGen 出力レート + uint status; + Channel4* csmch; + + + static uint32 lfotable[8]; + + private: + void TimerA(); + uint8 prescale; + + protected: + Chip chip; + PSG psg; + }; + + // OPN2 Base ------------------------------------------------------ + struct OPNABaseData { + struct OPNBaseData opnbase; + uint8 pan[6]; + uint16 panvolume_l[6]; // libOPNMIDI: soft panning + uint16 panvolume_r[6]; // libOPNMIDI: soft panning + uint8 fnum2[9]; + uint8 reg22; + uint reg29; + uint stmask; + uint statusnext; + uint32 lfocount; + uint32 lfodcount; + uint fnum[6]; + uint fnum3[3]; + bool is_adpcmbuf; + uint8 adpcmbuf[0x40000]; + uint adpcmmask; + uint adpcmnotice; + uint startaddr; + uint stopaddr; + uint memaddr; + uint limitaddr; + int adpcmlevel; + int adpcmvolume; + int adpcmvol; + uint deltan; + int adplc; + int adpld; + uint adplbase; + int adpcmx; + int adpcmd; + int adpcmout; + int apout0; + int apout1; + uint adpcmreadbuf; + bool adpcmplay; + int8 granuality; + bool adpcmmask_; + uint8 control1; + uint8 control2; + uint8 adpcmreg[8]; + int rhythmmask_; + struct Channel4Data ch[6]; + }; + + class OPNABase : public OPNBase + { + public: + OPNABase(); + ~OPNABase(); + + uint ReadStatus() { return status & 0x03; } + uint ReadStatusEx(); + void SetChannelMask(uint mask); + + // libOPNMIDI: soft panning + void SetPan(uint c, uint8 p); + + void DataSave(struct OPNABaseData* data); + void DataLoad(struct OPNABaseData* data); + + private: + virtual void Intr(bool) {} + + void MakeTable2(); + + protected: + bool Init(uint c, uint r, bool); + bool SetRate(uint c, uint r, bool); + + void Reset(); + void SetReg(uint addr, uint data); + void SetADPCMBReg(uint reg, uint data); + uint GetReg(uint addr); + + protected: + void FMMix(Sample* buffer, int nsamples); + void Mix6(Sample* buffer, int nsamples, int activech); + + void MixSubS(int activech, ISample**); + void MixSubSL(int activech, ISample**); + + void SetStatus(uint bit); + void ResetStatus(uint bit); + void UpdateStatus(); + void LFO(); + + void DecodeADPCMB(); + void ADPCMBMix(Sample* dest, uint count); + + void WriteRAM(uint data); + uint ReadRAM(); + int ReadRAMN(); + int DecodeADPCMBSample(uint); + + // FM 音æºé–¢ä¿‚ + uint8 pan[6]; + uint16 panvolume_l[6]; // libOPNMIDI: soft panning + uint16 panvolume_r[6]; // libOPNMIDI: soft panning + uint8 fnum2[9]; + + uint8 reg22; + uint reg29; // OPNA only? + + uint stmask; + uint statusnext; + + uint32 lfocount; + uint32 lfodcount; + + uint fnum[6]; + uint fnum3[3]; + + // ADPCM 関係 + uint8* adpcmbuf; // ADPCM RAM + uint adpcmmask; // メモリアドレスã«å¯¾ã™ã‚‹ãƒ“ットマスク + uint adpcmnotice; // ADPCM å†ç”Ÿçµ‚了時ã«ãŸã¤ãƒ“ット + uint startaddr; // Start address + uint stopaddr; // Stop address + uint memaddr; // å†ç”Ÿä¸­ã‚¢ãƒ‰ãƒ¬ã‚¹ + uint limitaddr; // Limit address/mask + int adpcmlevel; // ADPCM éŸ³é‡ + int adpcmvolume; + int adpcmvol; + uint deltan; // N + int adplc; // 周波数変æ›ç”¨å¤‰æ•° + int adpld; // 周波数変æ›ç”¨å¤‰æ•°å·®åˆ†å€¤ + uint adplbase; // adpld ã®å…ƒ + int adpcmx; // ADPCM åˆæˆç”¨ x + int adpcmd; // ADPCM åˆæˆç”¨ + int adpcmout; // ADPCM åˆæˆå¾Œã®å‡ºåŠ› + int apout0; // out(t-2)+out(t-1) + int apout1; // out(t-1)+out(t) + + uint adpcmreadbuf; // ADPCM リード用ãƒãƒƒãƒ•ã‚¡ + bool adpcmplay; // ADPCM å†ç”Ÿä¸­ + int8 granuality; + bool adpcmmask_; + + uint8 control1; // ADPCM コントロールレジスタ１ + uint8 control2; // ADPCM コントロールレジスタ２ + uint8 adpcmreg[8]; // ADPCM レジスタã®ä¸€éƒ¨åˆ† + + int rhythmmask_; + + Channel4 ch[6]; + + static void BuildLFOTable(); + static int amtable[FM_LFOENTS]; + static int pmtable[FM_LFOENTS]; + static int32 tltable[FM_TLENTS+FM_TLPOS]; + static bool tablehasmade; + }; + + // YM2203(OPN) ---------------------------------------------------- + struct OPNData { + struct OPNBaseData opnbase; + uint fnum[3]; + uint fnum3[3]; + uint8 fnum2[6]; + struct Channel4Data ch[3]; + }; + + class OPN : public OPNBase + { + public: + OPN(); + virtual ~OPN() {} + + bool Init(uint c, uint r, bool=false, const char* =0); + bool SetRate(uint c, uint r, bool=false); + + void Reset(); + void Mix(Sample* buffer, int nsamples); + void SetReg(uint addr, uint data); + uint GetReg(uint addr); + uint ReadStatus() { return status & 0x03; } + uint ReadStatusEx() { return 0xff; } + + void SetChannelMask(uint mask); + + int dbgGetOpOut(int c, int s) { return ch[c].op[s].dbgopout_; } + int dbgGetPGOut(int c, int s) { return ch[c].op[s].dbgpgout_; } + Channel4* dbgGetCh(int c) { return &ch[c]; } + + void DataSave(struct OPNData* data); + void DataLoad(struct OPNData* data); + + private: + virtual void Intr(bool) {} + + void SetStatus(uint bit); + void ResetStatus(uint bit); + + uint fnum[3]; + uint fnum3[3]; + uint8 fnum2[6]; + + Channel4 ch[3]; + }; + + // YM2608(OPNA) --------------------------------------------------- + struct Rhythm + { + uint8 pan; // ã±ã‚“ + int8 level; // ãŠã‚“りょㆠ+ int volume; // ãŠã‚“りょã†ã›ã£ã¦ã„ + int16* sample; // ã•ã‚“ã·ã‚‹ + uint size; // ã•ã„ãš + uint pos; // ã„ã¡ + uint step; // ã™ã¦ã£ã·ã¡ + uint rate; // ã•ã‚“ã·ã‚‹ã®ã‚Œãƒ¼ã¨ + }; + + struct OPNAData { + struct OPNABaseData opnabase; + Rhythm rhythm[6]; + int8 rhythmtl; + int rhythmtvol; + uint8 rhythmkey; + }; + + class OPNA : public OPNABase + { + public: + OPNA(); + virtual ~OPNA(); + + bool Init(uint c, uint r, bool = false, const char* rhythmpath=0); + bool LoadRhythmSample(const char*); + + bool SetRate(uint c, uint r, bool = false); + void Mix(Sample* buffer, int nsamples); + + void Reset(); + void SetReg(uint addr, uint data); + uint GetReg(uint addr); + + void SetVolumeADPCM(int db); + void SetVolumeRhythmTotal(int db); + void SetVolumeRhythm(int index, int db); + + uint8* GetADPCMBuffer() { return adpcmbuf; } + + int dbgGetOpOut(int c, int s) { return ch[c].op[s].dbgopout_; } + int dbgGetPGOut(int c, int s) { return ch[c].op[s].dbgpgout_; } + Channel4* dbgGetCh(int c) { return &ch[c]; } + + void DataSave(struct OPNAData* data); + void DataLoad(struct OPNAData* data); + + private: + void RhythmMix(Sample* buffer, uint count); + + // リズム音æºé–¢ä¿‚ + Rhythm rhythm[6]; + int8 rhythmtl; // リズム全体ã®éŸ³é‡ + int rhythmtvol; + uint8 rhythmkey; // リズムã®ã‚­ãƒ¼ + }; + + // YM2610/B(OPNB) --------------------------------------------------- + struct ADPCMA + { + uint8 pan; // ã±ã‚“ + int8 level; // ãŠã‚“りょㆠ+ int volume; // ãŠã‚“りょã†ã›ã£ã¦ã„ + uint pos; // ã„ã¡ + uint step; // ã™ã¦ã£ã·ã¡ + + uint start; // 開始 + uint stop; // 終了 + uint nibble; // 次㮠4 bit + int adpcmx; // 変æ›ç”¨ + int adpcmd; // 変æ›ç”¨ + }; + + struct OPNBData { + struct OPNABaseData opnabase; +// uint8* adpcmabuf; + int adpcmasize; + ADPCMA adpcma[6]; + int8 adpcmatl; + int adpcmatvol; + uint8 adpcmakey; + int adpcmastep; + uint8 adpcmareg[32]; + struct Channel4Data ch[6]; + }; + + class OPNB : public OPNABase + { + public: + OPNB(); + virtual ~OPNB(); + + bool Init(uint c, uint r, bool = false, + uint8 *_adpcma = 0, int _adpcma_size = 0, + uint8 *_adpcmb = 0, int _adpcmb_size = 0); + + bool SetRate(uint c, uint r, bool = false); + void Mix(Sample* buffer, int nsamples); + + void Reset(); + void SetReg(uint addr, uint data); + uint GetReg(uint addr); + uint ReadStatusEx(); + + void SetVolumeADPCMATotal(int db); + void SetVolumeADPCMA(int index, int db); + void SetVolumeADPCMB(int db); + +// void SetChannelMask(uint mask); + + void DataSave(struct OPNBData* data, void* adpcmdata); + void DataLoad(struct OPNBData* data, void* adpcmdata); + + private: + int DecodeADPCMASample(uint); + void ADPCMAMix(Sample* buffer, uint count); + static void InitADPCMATable(); + + // ADPCMA 関係 + uint8* adpcmabuf; // ADPCMA ROM + int adpcmasize; + ADPCMA adpcma[6]; + int8 adpcmatl; // ADPCMA 全体ã®éŸ³é‡ + int adpcmatvol; + uint8 adpcmakey; // ADPCMA ã®ã‚­ãƒ¼ + int adpcmastep; + uint8 adpcmareg[32]; + + static int jedi_table[(48+1)*16]; + + Channel4 ch[6]; + }; + + // YM2612/3438(OPN2) ---------------------------------------------------- + class OPN2 : public OPNBase + { + public: + OPN2(); + virtual ~OPN2() {} + + bool Init(uint c, uint r, bool=false, const char* =0); + bool SetRate(uint c, uint r, bool); + + void Reset(); + void Mix(Sample* buffer, int nsamples); + void SetReg(uint addr, uint data); + uint GetReg(uint addr); + uint ReadStatus() { return status & 0x03; } + uint ReadStatusEx() { return 0xff; } + + void SetChannelMask(uint mask); + + private: + virtual void Intr(bool) {} + + void SetStatus(uint bit); + void ResetStatus(uint bit); + + uint fnum[3]; + uint fnum3[3]; + uint8 fnum2[6]; + + // 線形補間用ワーク + int32 mixc, mixc1; + + Channel4 ch[3]; + }; +} + +// --------------------------------------------------------------------------- + +inline void FM::OPNBase::RebuildTimeTable() +{ + int p = prescale; + prescale = -1; + SetPrescaler(p); +} + +inline void FM::OPNBase::SetVolumePSG(int db) +{ + psg.SetVolume(db); +} + +#endif // FM_OPNA_H diff --git a/thirdparty/opnmidi/chips/np2/fmgen_psg.cpp b/thirdparty/opnmidi/chips/np2/fmgen_psg.cpp new file mode 100644 index 0000000..e3b88d5 --- /dev/null +++ b/thirdparty/opnmidi/chips/np2/fmgen_psg.cpp @@ -0,0 +1,395 @@ +// --------------------------------------------------------------------------- +// PSG Sound Implementation +// Copyright (C) cisc 1997, 1999. +// --------------------------------------------------------------------------- +// $Id: psg.cpp,v 1.10 2002/05/15 21:38:01 cisc Exp $ + +#include "fmgen_headers.h" +#include "fmgen_misc.h" +#include "fmgen_psg.h" + +// --------------------------------------------------------------------------- +// コンストラクタ・デストラクタ +// +PSG::PSG() +{ + SetVolume(0); + MakeNoiseTable(); + Reset(); + mask = 0x3f; +} + +PSG::~PSG() +{ + +} + +// --------------------------------------------------------------------------- +// PSG ã‚’åˆæœŸåŒ–ã™ã‚‹(RESET) +// +void PSG::Reset() +{ + for (int i=0; i<14; i++) + SetReg(i, 0); + SetReg(7, 0xff); + SetReg(14, 0xff); + SetReg(15, 0xff); +} + +// --------------------------------------------------------------------------- +// クロック周波数ã®è¨­å®š +// +void PSG::SetClock(int clock, int rate) +{ + tperiodbase = int((1 << toneshift ) / 4.0 * clock / rate); + eperiodbase = int((1 << envshift ) / 4.0 * clock / rate); + nperiodbase = int((1 << noiseshift) / 4.0 * clock / rate); + + // å„データã®æ›´æ–° + int tmp; + tmp = ((reg[0] + reg[1] * 256) & 0xfff); + speriod[0] = tmp ? tperiodbase / tmp : tperiodbase; + tmp = ((reg[2] + reg[3] * 256) & 0xfff); + speriod[1] = tmp ? tperiodbase / tmp : tperiodbase; + tmp = ((reg[4] + reg[5] * 256) & 0xfff); + speriod[2] = tmp ? tperiodbase / tmp : tperiodbase; + tmp = reg[6] & 0x1f; + nperiod = tmp ? nperiodbase / tmp / 2 : nperiodbase / 2; + tmp = ((reg[11] + reg[12] * 256) & 0xffff); + eperiod = tmp ? eperiodbase / tmp : eperiodbase * 2; +} + +// --------------------------------------------------------------------------- +// ノイズテーブルを作æˆã™ã‚‹ +// +void PSG::MakeNoiseTable() +{ + if (!noisetable[0]) + { + int noise = 14321; + for (int i=0; i> 1) | (((noise << 14) ^ (noise << 16)) & 0x10000); + } + noisetable[i] = n; + } + } +} + +// --------------------------------------------------------------------------- +// å‡ºåŠ›ãƒ†ãƒ¼ãƒ–ãƒ«ã‚’ä½œæˆ +// ç´ ç›´ã«ãƒ†ãƒ¼ãƒ–ルã§æŒã£ãŸã»ã†ãŒçœã‚¹ãƒšãƒ¼ã‚¹ã€‚ +// +void PSG::SetVolume(int volume) +{ + double base = 0x4000 / 3.0 * pow(10.0, volume / 40.0); + for (int i=31; i>=2; i--) + { + EmitTable[i] = int(base); + base /= 1.189207115; + } + EmitTable[1] = 0; + EmitTable[0] = 0; + MakeEnvelopTable(); + + SetChannelMask(~mask); +} + +void PSG::SetChannelMask(int c) +{ + mask = ~c; + for (int i=0; i<3; i++) + olevel[i] = mask & (1 << i) ? EmitTable[(reg[8+i] & 15) * 2 + 1] : 0; +} + +// --------------------------------------------------------------------------- +// エンベロープ波形テーブル +// +void PSG::MakeEnvelopTable() +{ + // 0 lo 1 up 2 down 3 hi + static uint8 table1[16*2] = + { + 2,0, 2,0, 2,0, 2,0, 1,0, 1,0, 1,0, 1,0, + 2,2, 2,0, 2,1, 2,3, 1,1, 1,3, 1,2, 1,0, + }; + static uint8 table2[4] = { 0, 0, 31, 31 }; + static int8 table3[4] = { 0, 1, -1, 0 }; + + uint* ptr = enveloptable[0]; + + for (int i=0; i<16*2; i++) + { + uint8 v = table2[table1[i]]; + + for (int j=0; j<32; j++) + { + *ptr++ = EmitTable[v]; + v += table3[table1[i]]; + } + } +} + +// --------------------------------------------------------------------------- +// PSG ã®ãƒ¬ã‚¸ã‚¹ã‚¿ã«å€¤ã‚’セットã™ã‚‹ +// regnum レジスタã®ç•ªå· (0 - 15) +// data セットã™ã‚‹å€¤ +// +void PSG::SetReg(uint regnum, uint8 data) +{ + if (regnum < 0x10) + { + reg[regnum] = data; + switch (regnum) + { + int tmp; + + case 0: // ChA Fine Tune + case 1: // ChA Coarse Tune + tmp = ((reg[0] + reg[1] * 256) & 0xfff); + speriod[0] = tmp ? tperiodbase / tmp : tperiodbase; + break; + + case 2: // ChB Fine Tune + case 3: // ChB Coarse Tune + tmp = ((reg[2] + reg[3] * 256) & 0xfff); + speriod[1] = tmp ? tperiodbase / tmp : tperiodbase; + break; + + case 4: // ChC Fine Tune + case 5: // ChC Coarse Tune + tmp = ((reg[4] + reg[5] * 256) & 0xfff); + speriod[2] = tmp ? tperiodbase / tmp : tperiodbase; + break; + + case 6: // Noise generator control + data &= 0x1f; + nperiod = data ? nperiodbase / data : nperiodbase; + break; + + case 8: + olevel[0] = mask & 1 ? EmitTable[(data & 15) * 2 + 1] : 0; + break; + + case 9: + olevel[1] = mask & 2 ? EmitTable[(data & 15) * 2 + 1] : 0; + break; + + case 10: + olevel[2] = mask & 4 ? EmitTable[(data & 15) * 2 + 1] : 0; + break; + + case 11: // Envelop period + case 12: + tmp = ((reg[11] + reg[12] * 256) & 0xffff); + eperiod = tmp ? eperiodbase / tmp : eperiodbase * 2; + break; + + case 13: // Envelop shape + ecount = 0; + envelop = enveloptable[data & 15]; + break; + } + } +} + +// --------------------------------------------------------------------------- +void PSG::DataSave(struct PSGData* data) { + memcpy(data->reg, reg, 16); + memcpy(data->olevel, olevel, sizeof(uint) * 6); + memcpy(data->scount, scount, sizeof(uint32) * 3); + memcpy(data->speriod, speriod, sizeof(uint32) * 3); + data->ecount = ecount; + data->eperiod = eperiod; + data->ncount = ncount; + data->nperiod = nperiod; + data->tperiodbase = tperiodbase; + data->eperiodbase = eperiodbase; + data->nperiodbase = nperiodbase; + data->volume = volume; + data->mask = mask; +} + +// --------------------------------------------------------------------------- +void PSG::DataLoad(struct PSGData* data) { + memcpy(reg, data->reg, 16); + memcpy(olevel, data->olevel, sizeof(uint) * 6); + memcpy(scount, data->scount, sizeof(uint32) * 3); + memcpy(speriod, data->speriod, sizeof(uint32) * 3); + ecount = data->ecount; + eperiod = data->eperiod; + ncount = data->ncount; + nperiod = data->nperiod; + tperiodbase = data->tperiodbase; + eperiodbase = data->eperiodbase; + nperiodbase = data->nperiodbase; + volume = data->volume; + mask = data->mask; +} + +// --------------------------------------------------------------------------- +// +// +inline void PSG::StoreSample(Sample& dest, int32 data) +{ + if (sizeof(Sample) == 2) + dest = (Sample) Limit(dest + data, 0x7fff, -0x8000); + else + dest += data; +} + +// --------------------------------------------------------------------------- +// PCM データをåã出ã™(2ch) +// dest PCM データを展開ã™ã‚‹ãƒã‚¤ãƒ³ã‚¿ +// nsamples 展開ã™ã‚‹ PCM ã®ã‚µãƒ³ãƒ—ル数 +// +void PSG::Mix(Sample* dest, int nsamples) +{ + uint8 chenable[3], nenable[3]; + uint8 r7 = ~reg[7]; + + if ((r7 & 0x3f) | ((reg[8] | reg[9] | reg[10]) & 0x1f)) + { + chenable[0] = (r7 & 0x01) && (speriod[0] <= (1 << toneshift)); + chenable[1] = (r7 & 0x02) && (speriod[1] <= (1 << toneshift)); + chenable[2] = (r7 & 0x04) && (speriod[2] <= (1 << toneshift)); + nenable[0] = (r7 >> 3) & 1; + nenable[1] = (r7 >> 4) & 1; + nenable[2] = (r7 >> 5) & 1; + + int noise, sample; + uint env; + uint* p1 = ((mask & 1) && (reg[ 8] & 0x10)) ? &env : &olevel[0]; + uint* p2 = ((mask & 2) && (reg[ 9] & 0x10)) ? &env : &olevel[1]; + uint* p3 = ((mask & 4) && (reg[10] & 0x10)) ? &env : &olevel[2]; + + #define SCOUNT(ch) (scount[ch] >> (toneshift+oversampling)) + + if (p1 != &env && p2 != &env && p3 != &env) + { + // エンベロープ無㗠+ if ((r7 & 0x38) == 0) + { + // ノイズ無㗠+ for (int i=0; i> (noiseshift+oversampling+6)) & (noisetablesize-1)] + >> (ncount >> (noiseshift+oversampling+1)); +#else + noise = noisetable[(ncount >> (noiseshift+oversampling+6)) & (noisetablesize-1)] + >> (ncount >> (noiseshift+oversampling+1) & 31); +#endif + ncount += nperiod; + + int x, y, z; + x = ((SCOUNT(0) & chenable[0]) | (nenable[0] & noise)) - 1; // 0 or -1 + sample += (olevel[0] + x) ^ x; + scount[0] += speriod[0]; + y = ((SCOUNT(1) & chenable[1]) | (nenable[1] & noise)) - 1; + sample += (olevel[1] + y) ^ y; + scount[1] += speriod[1]; + z = ((SCOUNT(2) & chenable[2]) | (nenable[2] & noise)) - 1; + sample += (olevel[2] + z) ^ z; + scount[2] += speriod[2]; + } + sample /= (1 << oversampling); + StoreSample(dest[0], sample); + StoreSample(dest[1], sample); + dest += 2; + } + } + + // エンベロープã®è¨ˆç®—ã‚’ã•ã¼ã£ãŸå¸³å°»ã‚ã‚ã› + ecount = (ecount >> 8) + (eperiod >> (8-oversampling)) * nsamples; + if (ecount >= (1 << (envshift+6+oversampling-8))) + { + if ((reg[0x0d] & 0x0b) != 0x0a) + ecount |= (1 << (envshift+5+oversampling-8)); + ecount &= (1 << (envshift+6+oversampling-8)) - 1; + } + ecount <<= 8; + } + else + { + // エンベロープã‚ã‚Š + for (int i=0; i> (envshift+oversampling)]; + ecount += eperiod; + if (ecount >= (1 << (envshift+6+oversampling))) + { + if ((reg[0x0d] & 0x0b) != 0x0a) + ecount |= (1 << (envshift+5+oversampling)); + ecount &= (1 << (envshift+6+oversampling)) - 1; + } +#ifdef _M_IX86 + noise = noisetable[(ncount >> (noiseshift+oversampling+6)) & (noisetablesize-1)] + >> (ncount >> (noiseshift+oversampling+1)); +#else + noise = noisetable[(ncount >> (noiseshift+oversampling+6)) & (noisetablesize-1)] + >> (ncount >> (noiseshift+oversampling+1) & 31); +#endif + ncount += nperiod; + + int x, y, z; + x = ((SCOUNT(0) & chenable[0]) | (nenable[0] & noise)) - 1; // 0 or -1 + sample += (*p1 + x) ^ x; + scount[0] += speriod[0]; + y = ((SCOUNT(1) & chenable[1]) | (nenable[1] & noise)) - 1; + sample += (*p2 + y) ^ y; + scount[1] += speriod[1]; + z = ((SCOUNT(2) & chenable[2]) | (nenable[2] & noise)) - 1; + sample += (*p3 + z) ^ z; + scount[2] += speriod[2]; + } + sample /= (1 << oversampling); + StoreSample(dest[0], sample); + StoreSample(dest[1], sample); + dest += 2; + } + } + } +} + +// --------------------------------------------------------------------------- +// テーブル +// +uint PSG::noisetable[noisetablesize] = { 0, }; +int PSG::EmitTable[0x20] = { -1, }; +uint PSG::enveloptable[16][64] = { {0, } }; diff --git a/thirdparty/opnmidi/chips/np2/fmgen_psg.h b/thirdparty/opnmidi/chips/np2/fmgen_psg.h new file mode 100644 index 0000000..39d72f0 --- /dev/null +++ b/thirdparty/opnmidi/chips/np2/fmgen_psg.h @@ -0,0 +1,115 @@ +// --------------------------------------------------------------------------- +// PSG-like sound generator +// Copyright (C) cisc 1997, 1999. +// --------------------------------------------------------------------------- +// $Id: psg.h,v 1.8 2003/04/22 13:12:53 cisc Exp $ + +#ifndef PSG_H +#define PSG_H + +#include "fmgen_types.h" + +// libOPNMIDI: change int32 to int16 +#define PSG_SAMPLETYPE int16 // int32 or int16 + +// --------------------------------------------------------------------------- +// class PSG +// PSG ã«è‰¯ãä¼¼ãŸéŸ³ã‚’生æˆã™ã‚‹éŸ³æºãƒ¦ãƒ‹ãƒƒãƒˆ +// +// interface: +// bool SetClock(uint clock, uint rate) +// åˆæœŸåŒ–．ã“ã®ã‚¯ãƒ©ã‚¹ã‚’使用ã™ã‚‹å‰ã«ã‹ãªã‚‰ãšå‘¼ã‚“ã§ãŠãã“ã¨ï¼Ž +// PSG ã®ã‚¯ãƒ­ãƒƒã‚¯ã‚„ PCM レートを設定ã™ã‚‹ +// +// clock: PSG ã®å‹•ä½œã‚¯ãƒ­ãƒƒã‚¯ +// rate: 生æˆã™ã‚‹ PCM ã®ãƒ¬ãƒ¼ãƒˆ +// retval åˆæœŸåŒ–ã«æˆåŠŸã™ã‚Œã° true +// +// void Mix(Sample* dest, int nsamples) +// PCM ã‚’ nsamples 分åˆæˆã—， dest ã§å§‹ã¾ã‚‹é…列ã«åŠ ãˆã‚‹(加算ã™ã‚‹) +// ã‚ãã¾ã§åŠ ç®—ãªã®ã§ï¼Œæœ€åˆã«é…列をゼロクリアã™ã‚‹å¿…è¦ãŒã‚ã‚‹ +// +// void Reset() +// リセットã™ã‚‹ +// +// void SetReg(uint reg, uint8 data) +// レジスタ reg ã« data を書ã込む +// +// uint GetReg(uint reg) +// レジスタ reg ã®å†…容を読ã¿å‡ºã™ +// +// void SetVolume(int db) +// å„音æºã®éŸ³é‡ã‚’調節ã™ã‚‹ +// å˜ä½ã¯ç´„ 1/2 dB +// +struct PSGData { + uint8 reg[16]; + uint olevel[3]; + uint32 scount[3]; + uint32 speriod[3]; + uint32 ecount; + uint32 eperiod; + uint32 ncount; + uint32 nperiod; + uint32 tperiodbase; + uint32 eperiodbase; + uint32 nperiodbase; + int volume; + int mask; +}; + +class PSG +{ +public: + typedef PSG_SAMPLETYPE Sample; + + enum + { + noisetablesize = 1 << 11, // â†ãƒ¡ãƒ¢ãƒªä½¿ç”¨é‡ã‚’減らã—ãŸã„ãªã‚‰æ¸›ã‚‰ã—㦠+ toneshift = 24, + envshift = 22, + noiseshift = 14, + oversampling = 2 // ↠音質より速度ãŒå„ªå…ˆãªã‚‰æ¸›ã‚‰ã™ã¨ã„ã„ã‹ã‚‚ + }; + +public: + PSG(); + ~PSG(); + + void Mix(Sample* dest, int nsamples); + void SetClock(int clock, int rate); + + void SetVolume(int vol); + void SetChannelMask(int c); + + void Reset(); + void SetReg(uint regnum, uint8 data); + uint GetReg(uint regnum) { return reg[regnum & 0x0f]; } + + void DataSave(struct PSGData* data); + void DataLoad(struct PSGData* data); + +protected: + void MakeNoiseTable(); + void MakeEnvelopTable(); + static void StoreSample(Sample& dest, int32 data); + + uint8 reg[16]; + + const uint* envelop; + uint olevel[3]; + uint32 scount[3], speriod[3]; + uint32 ecount, eperiod; + uint32 ncount, nperiod; + uint32 tperiodbase; + uint32 eperiodbase; + uint32 nperiodbase; + int volume; + int mask; + + static uint enveloptable[16][64]; + static uint noisetable[noisetablesize]; + static int EmitTable[32]; +}; + +#endif // PSG_H diff --git a/thirdparty/opnmidi/chips/np2/fmgen_readme.txt b/thirdparty/opnmidi/chips/np2/fmgen_readme.txt new file mode 100644 index 0000000..1d42c24 --- /dev/null +++ b/thirdparty/opnmidi/chips/np2/fmgen_readme.txt @@ -0,0 +1,93 @@ +------------------------------------------------------------------------------ + FM Sound Generator with OPN/OPM interface + Copyright (C) by cisc 1998, 2003. +------------------------------------------------------------------------------ + +ã€æ¦‚è¦ã€‘ + C++ ã«ã‚ˆã‚‹ FM/PSG 音æºã®å®Ÿè£…ã§ã™ã€‚ + + AY8910, YM2203, YM2151, YM2608, YM2610 相当ã®ã‚¤ãƒ³ã‚¿ãƒ¼ãƒ•ã‚§ãƒ¼ã‚¹ã‚‚ + 実装ã—ã¦ã‚ã‚Šã¾ã™ã€‚ + + +ã€ä½¿ã„方】 + (TODO:中身を書ã) + +ã€æ³¨æ„】 + 以å‰ã®ãƒãƒ¼ã‚¸ãƒ§ãƒ³ã‹ã‚‰å¹¾åˆ†æ‰‹ã‚’加ãˆã¾ã—ãŸã€‚インターフェース㯠+ ã„ã˜ã£ã¦ã„ãªã„ã¤ã‚‚ã‚Šã§ã™ãŒã€ä½•ã‹ã—らã®ãƒã‚°ãŒéš ã‚Œã¦ã„ã‚‹ã‹ã‚‚ã—ã‚Œã¾ã›ã‚“。 + + YM2610 ã¯å‹•ä½œãƒã‚§ãƒƒã‚¯ã™ã‚‰ã—ã¦ã„ã¾ã›ã‚“。 + + 線形補完モード(interpolation)ã¯å»ƒæ­¢ã•ã‚Œã¾ã—ãŸã€‚ + Init() ã®å¼•æ•°ä»•æ§˜ã¯å¤‰ã‚ã£ã¦ã„ã¾ã›ã‚“ãŒã€interpolation = true ã«ã—ã¦ã‚‚ + 動作ã¯å¤‰ã‚ã‚Šã¾ã›ã‚“。 + + OPNA::Init/SetRate ã§ä¸Žãˆã‚‹ãƒãƒƒãƒ—クロックã®å€¤ã®ä»•æ§˜ãŒ + 以å‰ã® M88 ã«æ­è¼‰ã•ã‚Œã¦ã„ãŸãƒãƒ¼ã‚¸ãƒ§ãƒ³ã¨ç•°ãªã£ã¦ã„ã¾ã™ï¼Ž + + +ã€è‘—作権ã€å…責è¦å®šã€‘ + + ・本ソースコードã¯ä½œè€…(cisc@retropc.net) ãŒè‘—作権を所有ã—ã¦ã„ã¾ã™ã€‚ + + ・本ソースコードã¯ã‚ã‚‹ãŒã¾ã¾ã«æä¾›ã•ã‚Œã‚‹ã‚‚ã®ã§ã‚り， + æš—é»™åŠã³æ˜Žç¤ºçš„ãªä¿è¨¼ã‚’一切å«ã¿ã¾ã›ã‚“． + + ・本ソースコードを利用ã—ãŸã“ã¨ï¼Œåˆ©ç”¨ã—ãªã‹ã£ãŸã“ã¨ï¼Œ + 利用ã§ããªã‹ã£ãŸã“ã¨ã«é–¢ã—ã¦ç”Ÿã˜ãŸã‚ã‚‹ã„ã¯ç”Ÿã˜ã‚‹ã¨äºˆæ¸¬ã•ã‚Œã‚‹ + æ害ã«ã¤ã„ã¦ï¼Œä½œè€…ã¯ä¸€åˆ‡è²¬ä»»ã‚’è² ã„ã¾ã›ã‚“． + + ・本ソースコードã¯ï¼Œä»¥ä¸‹ã®åˆ¶é™ã‚’満ãŸã™é™ã‚Šè‡ªç”±ã«æ”¹å¤‰ãƒ»çµ„ã¿è¾¼ã¿ãƒ» + é…布・利用ã™ã‚‹ã“ã¨ãŒã§ãã¾ã™ï¼Ž + + 1. 本ソフトã®ç”±æ¥(作者, 著作権)を明記ã™ã‚‹ã“ã¨. + 2. é…布ã™ã‚‹éš›ã«ã¯ãƒ•ãƒªãƒ¼ã‚½ãƒ•ãƒˆã¨ã™ã‚‹ã“ã¨ï¼Ž + 3. 改変ã—ãŸã‚½ãƒ¼ã‚¹ã‚³ãƒ¼ãƒ‰ã‚’é…布ã™ã‚‹éš›ã¯æ”¹å¤‰å†…容を明示ã™ã‚‹ã“ã¨. + 4. ソースコードをé…布ã™ã‚‹éš›ã«ã¯ã“ã®ãƒ†ã‚­ã‚¹ãƒˆã‚’一切改変ã›ãšã« + ãã®ã¾ã¾æ·»ä»˜ã™ã‚‹ã“ã¨ï¼Ž + + ・公開ã®éš›ã«ä½œè€…ã¸ã®é€£çµ¡ã‚’é ‚ã‘ã‚Œã°å¹¸ã„ã§ã™ï¼Ž + + ・商用ソフト(シェアウェアå«ã‚€) ã«æœ¬ã‚½ãƒ¼ã‚¹ã‚³ãƒ¼ãƒ‰ã®ä¸€éƒ¨ï¼Œã¾ãŸã¯ + 全部を組ã¿è¾¼ã‚€éš›ã«ã¯ï¼Œäº‹å‰ã«ä½œè€…ã®åˆæ„ã‚’å¾—ã‚‹å¿…è¦ãŒã‚ã‚Šã¾ã™ï¼Ž + + +ã€å¤‰æ›´ç‚¹ã€‘ +008 030902 ・出力サンプリングレートã®è¨­å®šã‚’ã€ãƒãƒƒãƒ—å…ƒæ¥ã®åˆæˆã‚µãƒ³ãƒ— + リングレートã¨ç•°ãªã‚‹è¨­å®šã«ã™ã‚‹ã¨ã‚¨ãƒ³ãƒ™ãƒ­ãƒ¼ãƒ—ãŒãŠã‹ã—ã + ãªã‚‹å•é¡Œã‚’修正。 + +007a 030608 ・領域外アクセスãŒã‚ã£ãŸã®ã‚’修正 (Thanks to ＰＩ．様) + +007 030607 ・å†ç¾æ€§ã®å‘上 + ・OPN: SSG-EG ã®ã‚µãƒãƒ¼ãƒˆ + ・線形補完ã®å»ƒæ­¢ + ・asm 版ã®å»ƒæ­¢ + ・マルãƒã‚¹ãƒ¬ãƒƒãƒ‰ãƒ•ãƒªãƒ¼ã«ãªã£ãŸï¼Ÿ + +006 010330 ・å†ç¾æ€§ã«é–¢ã—ã¦ã„ãらã‹æ‰‹ç›´ã—(正弦波，出力タイミング等) + +005 010317 ・OPN: FM 音æºã®åˆæˆå‘¨æ³¢æ•°ãŒå‡ºåŠ›å‘¨æ³¢æ•°ã‚ˆã‚Šã‚‚低ã„ã¨ãã«ï¼Œ + 補完を使ã†ã¨éŸ³ç—´ã«ãªã‚‹/音ãŒã¾ã¨ã‚‚ã«å‡ºãªããªã‚‹å•é¡Œã‚’修正. + ・FM: 補完を使ã‚ãªã„時ã®ç²¾åº¦ã‚’上ã’ã¦ã¿ã‚‹ï¼Ž + å•é¡ŒãŒèµ·ããŸã‚‰ fmgeninl.h ã® FM_RATIOBITS ã‚’ 8 ã«æˆ»ã™ã¨å‰ï¼Ž + +004a 010311 ・OPM: ノイズをãã“ãã“èžã‘るレベル(？)ã¾ã§ä¿®æ­£. + ・OPNA/OPM: FM_USE_CALC2 廃止. + ・デグレ修正, ãªã‚“ã®ãŸã‚ã« cvs ã§ç®¡ç†ã—ã¦ã„ã‚‹ã‚“ã ã‹â€¦(T-T + OPNB: ADPCMB ROM マスク作æˆãƒŸã‚¹. + OPNB: ADPCMA ステータスフラグ関係ã®æŒ™å‹•ä¿®å¾©. + OPM: LFO パラメータã®åˆæœŸåŒ–を忘れã¦ã„ãŸã®ã‚’修正. + +003 010124 ・OPNA/OPM： 実際ã«ã¯è£œå®Œå‰ã®å€¤ã‚’出力ã—ã¦ã„ãŸãƒã‚°ã‚’修正. + +002 010123 ・åˆæˆå‘¨æ³¢æ•°ãŒå‡ºåŠ›å‘¨æ³¢æ•°ã‚ˆã‚Šä½Žã„ã¨ãã§ã‚‚補間ãŒåŠ¹ãよã†ã«ã™ã‚‹. + ・OPN: 補間時ã«ãƒ—リスケーラã®è¨­å®šã‚’変更ã—ãŸã¨ãã«éŸ³åŒ–ã‘ã™ã‚‹ + ãƒã‚°ã‚’修正. + ・OPNA/B: LFO ãŒåŠ¹ã‹ãªã„ãƒã‚°ã‚’修正. + +001 000928 ・åˆæœŸãƒãƒ¼ã‚¸ãƒ§ãƒ³ + + +$Id: readme.txt,v 1.1 2003/06/07 08:25:20 cisc Exp $ diff --git a/thirdparty/opnmidi/chips/np2/fmgen_readme_kai.txt b/thirdparty/opnmidi/chips/np2/fmgen_readme_kai.txt new file mode 100644 index 0000000..9481c9c --- /dev/null +++ b/thirdparty/opnmidi/chips/np2/fmgen_readme_kai.txt @@ -0,0 +1,24 @@ +NP2kai ã«ãŠã„㦠fmgen 008 ã¸è¡Œã£ãŸæ”¹å¤‰ï¼Ž by AZO + +１．ファイルåã®å¤‰æ›´ï¼Ž （fmgen_*.*） + +２．fmgen.cpp Operator::MakeTable() ã®ã‚¤ãƒ³ã‚¯ãƒªãƒ¡ãƒ³ãƒˆä¿®æ­£ï¼Ž + +[修正å‰] +*p++ = p[-512] / 2; + +[修正後] +//*p++ = p[-512] / 2; +*p = p[-512] / 2; +p++; + +３．å„クラスã®ã‚¹ãƒ†ãƒ¼ãƒˆã‚»ãƒ¼ãƒ–用構造体ã¨ã€ã‚¹ãƒ†ãƒ¼ãƒˆã‚»ãƒ¼ãƒ–ï¼ãƒ­ãƒ¼ãƒ‰å®Ÿè£… + +struct xxxData : ステートセーブ用構造体 + +xxx_DataSave() : ステートセーブ +xxx_DataLoad() : ステートロード + +４．C言語用ラッパー fmgen_fmgwrap.cpp/.h + +以上． diff --git a/thirdparty/opnmidi/chips/np2/fmgen_types.h b/thirdparty/opnmidi/chips/np2/fmgen_types.h new file mode 100644 index 0000000..db1ebfb --- /dev/null +++ b/thirdparty/opnmidi/chips/np2/fmgen_types.h @@ -0,0 +1,23 @@ +#if !defined(win32_types_h) +#define win32_types_h + +#include "compiler.h" + +typedef unsigned char uchar; +typedef unsigned short ushort; +typedef unsigned int uint; +typedef unsigned long ulong; + +typedef unsigned char uint8; +typedef unsigned short uint16; +typedef unsigned int uint32; + +typedef signed char sint8; +typedef signed short sint16; +typedef signed int sint32; + +typedef signed char int8; +typedef signed short int16; +typedef signed int int32; + +#endif // win32_types_h diff --git a/thirdparty/opnmidi/chips/np2_opna.cpp b/thirdparty/opnmidi/chips/np2_opna.cpp new file mode 100644 index 0000000..ffd1bc5 --- /dev/null +++ b/thirdparty/opnmidi/chips/np2_opna.cpp @@ -0,0 +1,95 @@ +/* + * Interfaces over Yamaha OPN2 (YM2612) chip emulators + * + * Copyright (c) 2017-2020 Vitaly Novichkov (Wohlstand) + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#include "np2_opna.h" +#include "np2/fmgen_opna.h" +#include +#include +#include +#include + +template +NP2OPNA::NP2OPNA(OPNFamily f) + : ChipBase(f) +{ + ChipType *opn = (ChipType *)std::calloc(1, sizeof(ChipType)); + chip = new(opn) ChipType; + opn->Init(ChipBase::m_clock, ChipBase::m_rate); + opn->SetReg(0x29, 0x9f); // enable channels 4-6 +} + +template +NP2OPNA::~NP2OPNA() +{ + chip->~ChipType(); + std::free(chip); +} + +template +void NP2OPNA::setRate(uint32_t rate, uint32_t clock) +{ + ChipBase::setRate(rate, clock); + uint32_t chipRate = ChipBase::isRunningAtPcmRate() ? rate : ChipBase::nativeRate(); + chip->SetRate(clock, chipRate, false); // implies Reset() + chip->SetReg(0x29, 0x9f); // enable channels 4-6 +} + +template +void NP2OPNA::reset() +{ + ChipBase::reset(); + chip->Reset(); + chip->SetReg(0x29, 0x9f); // enable channels 4-6 +} + +template +void NP2OPNA::writeReg(uint32_t port, uint16_t addr, uint8_t data) +{ + chip->SetReg((port << 8) | addr, data); +} + +template +void NP2OPNA::writePan(uint16_t chan, uint8_t data) +{ + chip->SetPan(chan, data); +} + +template +void NP2OPNA::nativeGenerateN(int16_t *output, size_t frames) +{ + std::memset(output, 0, 2 * frames * sizeof(output[0])); + chip->Mix(output, static_cast(frames)); +} + +template <> +const char *NP2OPNA::emulatorName() +{ + return "Neko Project II Kai OPNA"; // git 2018-10-28 rev e1c0609 +} + +template <> +const char *NP2OPNA::emulatorName() +{ + return "Neko Project II Kai OPNB"; // git 2018-10-28 rev e1c0609 +} + +// template class NP2OPNA; +template class NP2OPNA; +template class NP2OPNA; diff --git a/thirdparty/opnmidi/chips/np2_opna.h b/thirdparty/opnmidi/chips/np2_opna.h new file mode 100644 index 0000000..6014998 --- /dev/null +++ b/thirdparty/opnmidi/chips/np2_opna.h @@ -0,0 +1,48 @@ +/* + * Interfaces over Yamaha OPN2 (YM2612) chip emulators + * + * Copyright (c) 2018-2020 Vitaly Novichkov (Wohlstand) + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#ifndef NP2_OPNA_H +#define NP2_OPNA_H + +#include "opn_chip_base.h" + +namespace FM { class OPN2; class OPNA; class OPNB; } +template +class NP2OPNA final : public OPNChipBaseBufferedT > +{ + typedef OPNChipBaseBufferedT > ChipBase; + ChipType *chip; +public: + explicit NP2OPNA(OPNFamily f); + ~NP2OPNA() override; + + bool canRunAtPcmRate() const override { return true; } + void setRate(uint32_t rate, uint32_t clock) override; + void reset() override; + void writeReg(uint32_t port, uint16_t addr, uint8_t data) override; + void writePan(uint16_t chan, uint8_t data) override; + void nativePreGenerate() override {} + void nativePostGenerate() override {} + void nativeGenerateN(int16_t *output, size_t frames) override; + const char *emulatorName() override; + enum { resamplerPostAttenuate = 2 }; +}; + +#endif diff --git a/thirdparty/opnmidi/chips/nuked/ym3438.c b/thirdparty/opnmidi/chips/nuked/ym3438.c index 8c170b7..b2f75a5 100644 --- a/thirdparty/opnmidi/chips/nuked/ym3438.c +++ b/thirdparty/opnmidi/chips/nuked/ym3438.c @@ -1,5 +1,5 @@ /* - * Copyright (C) 2017 Alexey Khokholov (Nuke.YKT) + * Copyright (C) 2017-2018 Alexey Khokholov (Nuke.YKT) * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public @@ -23,7 +23,7 @@ * OPLx decapsulated(Matthew Gambrell, Olli Niemitalo): * OPL2 ROMs. * - * version: 1.0.7 + * version: 1.0.9 */ #include @@ -242,7 +242,7 @@ static const Bit16u panlawtable[] = 4858, 4050, 3240, 2431, 1620, 810, 0 }; -static Bit32u chip_type = ym3438_type_discrete; +static Bit32u chip_type = ym3438_mode_readmode; void OPN2_DoIO(ym3438_t *chip) { @@ -388,7 +388,7 @@ void OPN2_DoRegWrite(ym3438_t *chip) /* Data */ if (chip->write_d_en && (chip->write_data & 0x100) == 0) { - switch (chip->address) + switch (chip->write_fm_mode_a) { case 0x21: /* LSI test 1 */ for (i = 0; i < 8; i++) @@ -467,7 +467,7 @@ void OPN2_DoRegWrite(ym3438_t *chip) /* Address */ if (chip->write_a_en) { - chip->write_fm_mode_a = chip->write_data & 0xff; + chip->write_fm_mode_a = chip->write_data & 0x1ff; } } @@ -1007,7 +1007,7 @@ void OPN2_ChOutput(ym3438_t *chip) chip->mol = 0; chip->mor = 0; - if (chip_type == ym3438_type_ym2612) + if (chip_type & ym3438_mode_ym2612) { out_en = ((cycles & 3) == 3) || test_dac; /* YM2612 DAC emulation(not verified) */ @@ -1040,11 +1040,6 @@ void OPN2_ChOutput(ym3438_t *chip) else { out_en = ((cycles & 3) != 0) || test_dac; - /* Discrete YM3438 seems has the ladder effect too */ - if (out >= 0 && chip_type == ym3438_type_discrete) - { - out++; - } if (chip->ch_lock_l && out_en) { chip->mol = out; @@ -1381,6 +1376,9 @@ void OPN2_Clock(ym3438_t *chip, Bit16s *buffer) buffer[0] = chip->mol; buffer[1] = chip->mor; + + if (chip->status_time) + chip->status_time--; } void OPN2_Write(ym3438_t *chip, Bit32u port, Bit8u data) @@ -1420,7 +1418,7 @@ Bit32u OPN2_ReadIRQPin(ym3438_t *chip) Bit8u OPN2_Read(ym3438_t *chip, Bit32u port) { - if ((port & 3) == 0 || chip_type == ym3438_type_asic) + if ((port & 3) == 0 || (chip_type & ym3438_mode_readmode)) { if (chip->mode_test_21[6]) { @@ -1438,23 +1436,34 @@ Bit8u OPN2_Read(ym3438_t *chip, Bit32u port) } if (chip->mode_test_21[7]) { - return testdata & 0xff; + chip->status = testdata & 0xff; } else { - return testdata >> 8; + chip->status = testdata >> 8; } } else { - return (Bit8u)(chip->busy << 7) | (Bit8u)(chip->timer_b_overflow_flag << 1) - | (Bit8u)chip->timer_a_overflow_flag; + chip->status = (chip->busy << 7) | (chip->timer_b_overflow_flag << 1) + | chip->timer_a_overflow_flag; + } + if (chip_type & ym3438_mode_ym2612) + { + chip->status_time = 300000; } + else + { + chip->status_time = 40000000; + } + } + if (chip->status_time) + { + return chip->status; } return 0; } - void OPN2_WritePan(ym3438_t *chip, Bit32u channel, Bit8u data) { chip->pan_volume_l[channel] = panlawtable[data & 0x7F]; @@ -1611,24 +1620,6 @@ void OPN2_GenerateStreamMix(ym3438_t *chip, Bit16s *output, Bit32u numsamples) } } - -void OPN2_SetOptions(Bit8u flags) -{ - switch ((flags >> 3) & 0x03) - { - case 0x00: /* YM2612 */ - default: - OPN2_SetChipType(ym3438_type_ym2612); - break; - case 0x01: /* ASIC YM3438 */ - OPN2_SetChipType(ym3438_type_asic); - break; - case 0x02: /* Discrete YM3438 */ - OPN2_SetChipType(ym3438_type_discrete); - break; - } -} - void OPN2_SetMute(ym3438_t *chip, Bit32u mute) { Bit32u i; diff --git a/thirdparty/opnmidi/chips/nuked/ym3438.h b/thirdparty/opnmidi/chips/nuked/ym3438.h index 2a3b5bf..26abfdf 100644 --- a/thirdparty/opnmidi/chips/nuked/ym3438.h +++ b/thirdparty/opnmidi/chips/nuked/ym3438.h @@ -1,5 +1,5 @@ /* - * Copyright (C) 2017 Alexey Khokholov (Nuke.YKT) + * Copyright (C) 2017-2018 Alexey Khokholov (Nuke.YKT) * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public @@ -23,7 +23,7 @@ * OPLx decapsulated(Matthew Gambrell, Olli Niemitalo): * OPL2 ROMs. * - * version: 1.0.7 + * version: 1.0.9 */ #ifndef YM3438_H @@ -39,9 +39,8 @@ extern "C" { #define OPN_WRITEBUF_DELAY 15 enum { - ym3438_type_discrete = 0, /* Discrete YM3438 (Teradrive) */ - ym3438_type_asic = 1, /* ASIC YM3438 (MD1 VA7, MD2, MD3, etc) */ - ym3438_type_ym2612 = 2 /* YM2612 (MD1, MD2 VA2) */ + ym3438_mode_ym2612 = 0x01, /* Enables YM2612 emulation (MD1, MD2 VA2) */ + ym3438_mode_readmode = 0x02 /* Enables status read on any port (TeraDrive, MD1 VA7, MD2, etc) */ }; #include @@ -80,7 +79,7 @@ typedef struct Bit8u write_busy_cnt; Bit8u write_fm_address; Bit8u write_fm_data; - Bit8u write_fm_mode_a; + Bit16u write_fm_mode_a; Bit16u address; Bit8u data; Bit8u pin_test_in; @@ -205,6 +204,8 @@ typedef struct Bit8u pan_l[6], pan_r[6]; Bit8u ams[6]; Bit8u pms[6]; + Bit8u status; + Bit32u status_time; /*EXTRA*/ Bit32u mute[7]; @@ -240,7 +241,6 @@ void OPN2_Generate(ym3438_t *chip, Bit16s *buf); void OPN2_GenerateResampled(ym3438_t *chip, Bit16s *buf); void OPN2_GenerateStream(ym3438_t *chip, Bit16s *output, Bit32u numsamples); void OPN2_GenerateStreamMix(ym3438_t *chip, Bit16s *output, Bit32u numsamples); -void OPN2_SetOptions(Bit8u flags); void OPN2_SetMute(ym3438_t *chip, Bit32u mute); #ifdef __cplusplus diff --git a/thirdparty/opnmidi/chips/nuked_opn2.cpp b/thirdparty/opnmidi/chips/nuked_opn2.cpp index 2c2ec46..e8f2835 100644 --- a/thirdparty/opnmidi/chips/nuked_opn2.cpp +++ b/thirdparty/opnmidi/chips/nuked_opn2.cpp @@ -1,7 +1,7 @@ /* * Interfaces over Yamaha OPN2 (YM2612) chip emulators * - * Copyright (C) 2017-2018 Vitaly Novichkov (Wohlstand) + * Copyright (c) 2017-2020 Vitaly Novichkov (Wohlstand) * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public @@ -22,9 +22,10 @@ #include "nuked/ym3438.h" #include -NukedOPN2::NukedOPN2() +NukedOPN2::NukedOPN2(OPNFamily f) + : OPNChipBaseT(f) { - OPN2_SetChipType(ym3438_type_asic); + OPN2_SetChipType(ym3438_mode_readmode); chip = new ym3438_t; setRate(m_rate, m_clock); } diff --git a/thirdparty/opnmidi/chips/nuked_opn2.h b/thirdparty/opnmidi/chips/nuked_opn2.h index ff5d255..d783761 100644 --- a/thirdparty/opnmidi/chips/nuked_opn2.h +++ b/thirdparty/opnmidi/chips/nuked_opn2.h @@ -1,7 +1,7 @@ /* * Interfaces over Yamaha OPN2 (YM2612) chip emulators * - * Copyright (C) 2017-2018 Vitaly Novichkov (Wohlstand) + * Copyright (c) 2017-2020 Vitaly Novichkov (Wohlstand) * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public @@ -27,7 +27,7 @@ class NukedOPN2 final : public OPNChipBaseT { void *chip; public: - NukedOPN2(); + explicit NukedOPN2(OPNFamily f); ~NukedOPN2() override; bool canRunAtPcmRate() const override { return false; } diff --git a/thirdparty/opnmidi/chips/opn_chip_base.h b/thirdparty/opnmidi/chips/opn_chip_base.h index fb02c32..feb63b4 100644 --- a/thirdparty/opnmidi/chips/opn_chip_base.h +++ b/thirdparty/opnmidi/chips/opn_chip_base.h @@ -1,7 +1,7 @@ /* * Interfaces over Yamaha OPN2 (YM2612) chip emulators * - * Copyright (C) 2017-2018 Vitaly Novichkov (Wohlstand) + * Copyright (c) 2017-2020 Vitaly Novichkov (Wohlstand) * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public @@ -21,6 +21,7 @@ #ifndef ONP_CHIP_BASE_H #define ONP_CHIP_BASE_H +#include "opn_chip_family.h" #include #include @@ -39,16 +40,19 @@ extern void opn2_audioTickHandler(void *instance, uint32_t chipId, uint32_t rate class OPNChipBase { -public: - enum { nativeRate = 53267 }; protected: uint32_t m_id; uint32_t m_rate; uint32_t m_clock; + OPNFamily m_family; public: - OPNChipBase(); + explicit OPNChipBase(OPNFamily f); virtual ~OPNChipBase(); + virtual OPNFamily family() const = 0; + uint32_t clockRate() const; + virtual uint32_t nativeClockRate() const = 0; + uint32_t chipId() const { return m_id; } void setChipId(uint32_t id) { m_id = id; } @@ -61,6 +65,7 @@ class OPNChipBase virtual void setRate(uint32_t rate, uint32_t clock) = 0; virtual uint32_t effectiveRate() const = 0; + virtual uint32_t nativeRate() const = 0; virtual void reset() = 0; virtual void writeReg(uint32_t port, uint16_t addr, uint8_t data) = 0; @@ -88,9 +93,12 @@ template class OPNChipBaseT : public OPNChipBase { public: - OPNChipBaseT(); + explicit OPNChipBaseT(OPNFamily f); virtual ~OPNChipBaseT(); + OPNFamily family() const override; + uint32_t nativeClockRate() const override; + bool isRunningAtPcmRate() const override; bool setRunningAtPcmRate(bool r) override; #if defined(OPNMIDI_AUDIO_TICK_HANDLER) @@ -99,6 +107,7 @@ class OPNChipBaseT : public OPNChipBase virtual void setRate(uint32_t rate, uint32_t clock) override; uint32_t effectiveRate() const override; + uint32_t nativeRate() const override; virtual void reset() override; void generate(int16_t *output, size_t frames) override; void generateAndMix(int16_t *output, size_t frames) override; @@ -134,10 +143,11 @@ template class OPNChipBaseBufferedT : public OPNChipBaseT { public: - OPNChipBaseBufferedT() - : OPNChipBaseT(), m_bufferIndex(0) {} + explicit OPNChipBaseBufferedT(OPNFamily f) + : OPNChipBaseT(f), m_bufferIndex(0) {} virtual ~OPNChipBaseBufferedT() {} + enum { buffer_size = Buffer }; public: void reset() override; void nativeGenerate(int16_t *frame) override; diff --git a/thirdparty/opnmidi/chips/opn_chip_base.tcc b/thirdparty/opnmidi/chips/opn_chip_base.tcc index 1302ea5..27d720a 100644 --- a/thirdparty/opnmidi/chips/opn_chip_base.tcc +++ b/thirdparty/opnmidi/chips/opn_chip_base.tcc @@ -1,5 +1,6 @@ #include "opn_chip_base.h" #include +#include #if defined(OPNMIDI_ENABLE_HQ_RESAMPLER) #include @@ -18,11 +19,11 @@ #endif /* OPNChipBase */ - -inline OPNChipBase::OPNChipBase() : +inline OPNChipBase::OPNChipBase(OPNFamily f) : m_id(0), m_rate(44100), - m_clock(7670454) + m_clock(7670454), + m_family(f) { } @@ -30,11 +31,16 @@ inline OPNChipBase::~OPNChipBase() { } +inline uint32_t OPNChipBase::clockRate() const +{ + return m_clock; +} + /* OPNChipBaseT */ template -OPNChipBaseT::OPNChipBaseT() - : OPNChipBase(), +OPNChipBaseT::OPNChipBaseT(OPNFamily f) + : OPNChipBase(f), m_runningAtPcmRate(false) #if defined(OPNMIDI_AUDIO_TICK_HANDLER) , @@ -55,6 +61,18 @@ OPNChipBaseT::~OPNChipBaseT() #endif } +template +OPNFamily OPNChipBaseT::family() const +{ + return m_family; +} + +template +uint32_t OPNChipBaseT::nativeClockRate() const +{ + return opn2_getNativeClockRate(m_family); +} + template bool OPNChipBaseT::isRunningAtPcmRate() const { @@ -86,9 +104,10 @@ template void OPNChipBaseT::setRate(uint32_t rate, uint32_t clock) { uint32_t oldRate = m_rate; + uint32_t oldClock = m_clock; m_rate = rate; m_clock = clock; - if(rate != oldRate) + if(rate != oldRate || clock != oldClock) setupResampler(rate); else resetResampler(); @@ -97,7 +116,13 @@ void OPNChipBaseT::setRate(uint32_t rate, uint32_t clock) template uint32_t OPNChipBaseT::effectiveRate() const { - return m_runningAtPcmRate ? m_rate : (uint32_t)nativeRate; + return m_runningAtPcmRate ? m_rate : opn2_getNativeRate(m_family); +} + +template +uint32_t OPNChipBaseT::nativeRate() const +{ + return opn2_getNativeRate(m_family); } template @@ -184,7 +209,8 @@ template void OPNChipBaseT::setupResampler(uint32_t rate) { #if defined(OPNMIDI_ENABLE_HQ_RESAMPLER) - m_resampler->setup(rate * (1.0 / 53267), 2, 48); + double ratio = rate * (1.0 / opn2_getNativeRate(m_family)); + m_resampler->setup(ratio, 2, 48); #else m_oldsamples[0] = m_oldsamples[1] = 0; m_samples[0] = m_samples[1] = 0; @@ -238,8 +264,8 @@ void OPNChipBaseT::resampledGenerate(int32_t *output) rsm->out_count = 1; rsm->out_data = f_out; } - output[0] = static_cast(std::lround(f_out[0])); - output[1] = static_cast(std::lround(f_out[1])); + output[0] = static_cast(lround(f_out[0])); + output[1] = static_cast(lround(f_out[1])); } #else template diff --git a/thirdparty/opnmidi/chips/opn_chip_family.h b/thirdparty/opnmidi/chips/opn_chip_family.h new file mode 100644 index 0000000..2d9b001 --- /dev/null +++ b/thirdparty/opnmidi/chips/opn_chip_family.h @@ -0,0 +1,84 @@ +/* + * Interfaces over Yamaha OPN2 (YM2612) chip emulators + * + * Copyright (c) 2017-2020 Vitaly Novichkov (Wohlstand) + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#ifndef OPN_CHIP_FAMILY_H +#define OPN_CHIP_FAMILY_H + +#include + +#define OPN_FAMILY_EACH(F) \ + F(OPN2) F(OPNA) + +enum OPNFamily +{ + #define Each(x) OPNChip_##x, + OPN_FAMILY_EACH(Each) + #undef Each + OPNChip_Count +}; + +template +struct OPNFamilyTraits; + +template <> +struct OPNFamilyTraits +{ + enum + { + nativeRate = 53267, + nativeClockRate = 7670454 + }; +}; + +template <> +struct OPNFamilyTraits +{ + enum + { + nativeRate = 55466, + nativeClockRate = 7987200 + }; +}; + +inline uint32_t opn2_getNativeRate(OPNFamily f) +{ + switch(f) + { + default: + #define Each(x) case OPNChip_##x: \ + return OPNFamilyTraits::nativeRate; + OPN_FAMILY_EACH(Each) + #undef Each + } +} + +inline uint32_t opn2_getNativeClockRate(OPNFamily f) +{ + switch(f) + { + default: + #define Each(x) case OPNChip_##x: \ + return OPNFamilyTraits::nativeClockRate; + OPN_FAMILY_EACH(Each) + #undef Each + } +} + +#endif // OPN_CHIP_FAMILY_H diff --git a/thirdparty/opnmidi/chips/pmdwin/op.h b/thirdparty/opnmidi/chips/pmdwin/op.h new file mode 100644 index 0000000..4f9111c --- /dev/null +++ b/thirdparty/opnmidi/chips/pmdwin/op.h @@ -0,0 +1,144 @@ +#ifndef FM_OP_H +#define FM_OP_H + +#include +#define false 0 +#define true 1 +#define Max(a,b) ((a>b)?a:b) +#define Min(a,b) ((a max ? max : (v < min ? min : v); +} + +static inline int16_t Limit16(int a) +{ + if ((a+0x8000) & ~0xFFFF) return (a>>31) ^ 0x7FFF; + else return a; +} + +/* ------------------------------------------------------------------------- */ +struct _OPNA; +struct Channel4; + +/* Operator ---------------------------------------------------------------- */ +typedef struct _FMOperator +{ + struct Channel4 *master; + + int32_t out, out2; + + /* Phase Generator ----------------------------------------------------- */ + uint32_t dp; /* Octave (used to define note in conjunction with bn, below). */ + uint8_t detune; /* Detune */ + uint8_t multiple; /* Multiple */ + uint32_t pgcount; /* Phase generator sweep value. Only the top 9 bits are relevant/used. */ + uint32_t pgdcount; /* Phase generator increment-per-clock value. Hopefully self-explanatory. */ + uint32_t pgdcountl; /* Phase generator detune increment value. Used in the implementation of vibrato. */ + /* Equal to pgdcount >> 11. */ + + /* Envelope Generator -------------------------------------------------- */ + uint32_t bn; /* Block/Note */ + uint32_t egout; + int eglevel; /* EG ¤Î½ÃÃŽÃÃà */ + int eglvnext; /* ¼¡¤Î phase ¤Ë°Ü¤ëÃà */ + int32_t egstep; /* EG ¤Î¼¡¤ÎÊѰܤޤǤλþ´Ö */ + int32_t egstepd; /* egstep ¤Î»þ´Öº¹Ê¬ */ + uint8_t egtransa; /* EG ÊѲ½¤Î³ä¹ç (for attack) */ + uint8_t egtransd; /* EG ÊѲ½¤Î³ä¹ç (for decay) */ + + uint32_t ksr; /* key scale rate */ + EGPhase phase; + uint8_t ams; + uint8_t ms; + + uint8_t keyon; /* current key state */ + + uint8_t tl; /* Total Level (0-127) */ + uint8_t tll; /* Total Level Latch (for CSM mode) */ + uint8_t ar; /* Attack Rate (0-63) */ + uint8_t dr; /* Decay Rate (0-63) */ + uint8_t sr; /* Sustain Rate (0-63) */ + uint8_t sl; /* Sustain Level (0-127) */ + uint8_t rr; /* Release Rate (0-63) */ + uint8_t ks; /* Keyscale (0-3) */ + uint8_t ssgtype; /* SSG-Type Envelope Control */ + + uint8_t amon; /* enable Amplitude Modulation */ + uint8_t paramchanged; /* Set whenever f-number or any ADSR constants */ + /* are set in OPNASetReg(), as well as upon */ + /* chip reset and chip "DAC" samplerate change. */ + /* Causes the envelope generator to reset its */ + /* internal state, also sets correct increments */ + /* for the phase generator. */ + uint8_t mute; +} FMOperator; + +/* 4-op Channel ------------------------------------------------------------ */ +typedef struct Channel4 +{ + struct _OPNA *master; + uint32_t fb; + int buf[4]; + uint8_t idx[6]; + int *pms; + uint16_t panl; + uint16_t panr; + FMOperator op[4]; +} Channel4; + +/* OPNA Rhythm Generator --------------------------------------------------- */ +typedef struct Rhythm { + uint8_t pan; + int8_t level; + int8_t volume; + int8_t* sample; /* Rhythm sample data */ + uint32_t size; /* Rhythm sample data size */ + uint32_t pos; /* Current index into rhytm sample data array */ + uint32_t step; /* Amount to increment the above by every time */ + /* RhythmMix() gets called. */ + uint32_t rate; /* Samplerate of rhythm sample data */ + /* (44100Hz in this implementation). */ +} Rhythm; + +#ifdef __cplusplus +extern "C" { +#endif + +/* -------------------------------------------------------------------------- +// Miscellaneous and probably irrelevant function prototypes. */ +void OperatorInit(Channel4 *ch4, FMOperator *op); +void OperatorReset(FMOperator *op); +void OperatorPrepare(FMOperator *op); + +static inline uint32_t IsOn(FMOperator *op) { + return (op->phase - off); +} + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/thirdparty/opnmidi/chips/pmdwin/opna.c b/thirdparty/opnmidi/chips/pmdwin/opna.c new file mode 100644 index 0000000..3dbf164 --- /dev/null +++ b/thirdparty/opnmidi/chips/pmdwin/opna.c @@ -0,0 +1,1370 @@ +/* FIXME: move ugly-ass legalese somewhere where it won't be seen +// by anyone other than lawyers. (/dev/null would be ideal but sadly +// we live in an imperfect world). */ +/* Copyright (c) 2012/2013, Peter Barfuss +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + +1. Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. +2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR +ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ + +#include +#include +#include +#include +#include +#include "op.h" +#include "psg.h" +#include "opna.h" + +static const uint8_t notetab[128] = +{ + 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 3, 3, 3, 3, 3, 3, + 4, 4, 4, 4, 4, 4, 4, 5, 6, 7, 7, 7, 7, 7, 7, 7, + 8, 8, 8, 8, 8, 8, 8, 9, 10, 11, 11, 11, 11, 11, 11, 11, + 12, 12, 12, 12, 12, 12, 12, 13, 14, 15, 15, 15, 15, 15, 15, 15, + 16, 16, 16, 16, 16, 16, 16, 17, 18, 19, 19, 19, 19, 19, 19, 19, + 20, 20, 20, 20, 20, 20, 20, 21, 22, 23, 23, 23, 23, 23, 23, 23, + 24, 24, 24, 24, 24, 24, 24, 25, 26, 27, 27, 27, 27, 27, 27, 27, + 28, 28, 28, 28, 28, 28, 28, 29, 30, 31, 31, 31, 31, 31, 31, 31, +}; + +static const int8_t dttab[256] = +{ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 2, 2, 2, 2, 2, 2, 2, 2, 4, 4, 4, 4, + 4, 6, 6, 6, 8, 8, 8, 10, 10, 12, 12, 14, 16, 16, 16, 16, + 2, 2, 2, 2, 4, 4, 4, 4, 4, 6, 6, 6, 8, 8, 8, 10, + 10, 12, 12, 14, 16, 16, 18, 20, 22, 24, 26, 28, 32, 32, 32, 32, + 4, 4, 4, 4, 4, 6, 6, 6, 8, 8, 8, 10, 10, 12, 12, 14, + 16, 16, 18, 20, 22, 24, 26, 28, 32, 34, 38, 40, 44, 44, 44, 44, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, -2, -2, -2, -2, -2, -2, -2, -2, -4, -4, -4, -4, + -4, -6, -6, -6, -8, -8, -8,-10,-10,-12,-12,-14,-16,-16,-16,-16, + -2, -2, -2, -2, -4, -4, -4, -4, -4, -6, -6, -6, -8, -8, -8,-10, + -10,-12,-12,-14,-16,-16,-18,-20,-22,-24,-26,-28,-32,-32,-32,-32, + -4, -4, -4, -4, -4, -6, -6, -6, -8, -8, -8,-10,-10,-12,-12,-14, + -16,-16,-18,-20,-22,-24,-26,-28,-32,-34,-38,-40,-44,-44,-44,-44, +}; + +static const uint8_t gaintab[64] = { + 0xff, 0xea, 0xd7, 0xc5, 0xb5, 0xa6, 0x98, 0x8b, 0x80, 0x75, 0x6c, 0x63, 0x5a, 0x53, 0x4c, 0x46, + 0x40, 0x3b, 0x36, 0x31, 0x2d, 0x2a, 0x26, 0x23, 0x20, 0x1d, 0x1b, 0x19, 0x17, 0x15, 0x13, 0x12, + 0x10, 0x0f, 0x0e, 0x0c, 0x0b, 0x0a, 0x0a, 0x09, 0x08, 0x07, 0x07, 0x06, 0x06, 0x05, 0x05, 0x04, + 0x04, 0x04, 0x03, 0x03, 0x03, 0x03, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x01, 0x01, 0x01, 0x01, +}; + +/* sinf(M_PI*(2*i+1)/1024.0f), i=0,...,511. +// Should make this twice as large (so a duplicate of the top 512, but with the other half of the +// interval [0,2*M_PI], therefore the negative of the first half), and then get rid of the +// silly hack in Sinetable(). However, I'm not actually sure which will use less gates on an FPGA, +// and there's really no speed difference on any machine newer than a 6502, probably. */ +static const int16_t sinetable[1024] = { + 1, 2, 4, 5, 7, 9, 10, 12, 13, 15, 16, 18, 20, 21, 23, 24, + 26, 27, 29, 31, 32, 34, 35, 37, 38, 40, 41, 43, 45, 46, 48, 49, + 51, 52, 54, 55, 57, 58, 60, 61, 63, 64, 66, 68, 69, 71, 72, 74, + 75, 77, 78, 80, 81, 83, 84, 86, 87, 88, 90, 91, 93, 94, 96, 97, + 99, 100, 102, 103, 104, 106, 107, 109, 110, 112, 113, 114, 116, 117, 119, 120, + 121, 123, 124, 125, 127, 128, 130, 131, 132, 134, 135, 136, 138, 139, 140, 142, + 143, 144, 145, 147, 148, 149, 151, 152, 153, 154, 156, 157, 158, 159, 161, 162, + 163, 164, 165, 167, 168, 169, 170, 171, 173, 174, 175, 176, 177, 178, 179, 180, + 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, + 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 212, + 213, 214, 215, 216, 217, 218, 218, 219, 220, 221, 222, 222, 223, 224, 225, 225, + 226, 227, 228, 228, 229, 230, 230, 231, 232, 232, 233, 234, 234, 235, 236, 236, + 237, 237, 238, 239, 239, 240, 240, 241, 241, 242, 242, 243, 243, 244, 244, 245, + 245, 246, 246, 247, 247, 247, 248, 248, 249, 249, 249, 250, 250, 250, 251, 251, + 251, 252, 252, 252, 252, 253, 253, 253, 253, 254, 254, 254, 254, 254, 255, 255, + 255, 255, 255, 255, 255, 255, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256, + 256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 255, 255, 255, 255, 255, 255, + 255, 255, 254, 254, 254, 254, 254, 253, 253, 253, 253, 252, 252, 252, 252, 251, + 251, 251, 250, 250, 250, 249, 249, 249, 248, 248, 247, 247, 247, 246, 246, 245, + 245, 244, 244, 243, 243, 242, 242, 241, 241, 240, 240, 239, 239, 238, 237, 237, + 236, 236, 235, 234, 234, 233, 232, 232, 231, 230, 230, 229, 228, 228, 227, 226, + 225, 225, 224, 223, 222, 222, 221, 220, 219, 218, 218, 217, 216, 215, 214, 213, + 212, 212, 211, 210, 209, 208, 207, 206, 205, 204, 203, 202, 201, 200, 199, 198, + 197, 196, 195, 194, 193, 192, 191, 190, 189, 188, 187, 186, 185, 184, 183, 182, + 180, 179, 178, 177, 176, 175, 174, 173, 171, 170, 169, 168, 167, 165, 164, 163, + 162, 161, 159, 158, 157, 156, 154, 153, 152, 151, 149, 148, 147, 145, 144, 143, + 142, 140, 139, 138, 136, 135, 134, 132, 131, 130, 128, 127, 125, 124, 123, 121, + 120, 119, 117, 116, 114, 113, 112, 110, 109, 107, 106, 104, 103, 102, 100, 99, + 97, 96, 94, 93, 91, 90, 88, 87, 86, 84, 83, 81, 80, 78, 77, 75, + 74, 72, 71, 69, 68, 66, 64, 63, 61, 60, 58, 57, 55, 54, 52, 51, + 49, 48, 46, 45, 43, 41, 40, 38, 37, 35, 34, 32, 31, 29, 27, 26, + 24, 23, 21, 20, 18, 16, 15, 13, 12, 10, 9, 7, 6, 4, 2, 1, + -1, -2, -4, -5, -7, -9, -10, -12, -13, -15, -16, -18, -20, -21, -23, -24, + -26, -27, -29, -31, -32, -34, -35, -37, -38, -40, -41, -43, -45, -46, -48, -49, + -51, -52, -54, -55, -57, -58, -60, -61, -63, -64, -66, -68, -69, -71, -72, -74, + -75, -77, -78, -80, -81, -83, -84, -86, -87, -88, -90, -91, -93, -94, -96, -97, + -99, -100, -102, -103, -104, -106, -107, -109, -110, -112, -113, -114, -116, -117, -119, -120, + -121, -123, -124, -125, -127, -128, -130, -131, -132, -134, -135, -136, -138, -139, -140, -142, + -143, -144, -145, -147, -148, -149, -151, -152, -153, -154, -156, -157, -158, -159, -161, -162, + -163, -164, -165, -167, -168, -169, -170, -171, -173, -174, -175, -176, -177, -178, -179, -180, + -182, -183, -184, -185, -186, -187, -188, -189, -190, -191, -192, -193, -194, -195, -196, -197, + -198, -199, -200, -201, -202, -203, -204, -205, -206, -207, -208, -209, -210, -211, -212, -212, + -213, -214, -215, -216, -217, -218, -218, -219, -220, -221, -222, -222, -223, -224, -225, -225, + -226, -227, -228, -228, -229, -230, -230, -231, -232, -232, -233, -234, -234, -235, -236, -236, + -237, -237, -238, -239, -239, -240, -240, -241, -241, -242, -242, -243, -243, -244, -244, -245, + -245, -246, -246, -247, -247, -247, -248, -248, -249, -249, -249, -250, -250, -250, -251, -251, + -251, -252, -252, -252, -252, -253, -253, -253, -253, -254, -254, -254, -254, -254, -255, -255, + -255, -255, -255, -255, -255, -255, -256, -256, -256, -256, -256, -256, -256, -256, -256, -256, + -256, -256, -256, -256, -256, -256, -256, -256, -256, -256, -255, -255, -255, -255, -255, -255, + -255, -255, -254, -254, -254, -254, -254, -253, -253, -253, -253, -252, -252, -252, -252, -251, + -251, -251, -250, -250, -250, -249, -249, -249, -248, -248, -247, -247, -247, -246, -246, -245, + -245, -244, -244, -243, -243, -242, -242, -241, -241, -240, -240, -239, -239, -238, -237, -237, + -236, -236, -235, -234, -234, -233, -232, -232, -231, -230, -230, -229, -228, -228, -227, -226, + -225, -225, -224, -223, -222, -222, -221, -220, -219, -218, -218, -217, -216, -215, -214, -213, + -212, -212, -211, -210, -209, -208, -207, -206, -205, -204, -203, -202, -201, -200, -199, -198, + -197, -196, -195, -194, -193, -192, -191, -190, -189, -188, -187, -186, -185, -184, -183, -182, + -180, -179, -178, -177, -176, -175, -174, -173, -171, -170, -169, -168, -167, -165, -164, -163, + -162, -161, -159, -158, -157, -156, -154, -153, -152, -151, -149, -148, -147, -145, -144, -143, + -142, -140, -139, -138, -136, -135, -134, -132, -131, -130, -128, -127, -125, -124, -123, -121, + -120, -119, -117, -116, -114, -113, -112, -110, -109, -107, -106, -104, -103, -102, -100, -99, + -97, -96, -94, -93, -91, -90, -88, -87, -86, -84, -83, -81, -80, -78, -77, -75, + -74, -72, -71, -69, -68, -66, -64, -63, -61, -60, -58, -57, -55, -54, -52, -51, + -49, -48, -46, -45, -43, -41, -40, -38, -37, -35, -34, -32, -31, -29, -27, -26, + -24, -23, -21, -20, -18, -16, -15, -13, -12, -10, -9, -7, -6, -4, -2, -1, +}; + +static const uint8_t cltab[512] = { + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xd6, 0xd6, 0xd6, 0xd6, 0xd6, 0xd6, 0xd6, 0xd6, 0xd6, 0xd6, 0xd6, 0xd6, 0xd6, 0xd6, 0xd6, 0xd6, + 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, + 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, + 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, + 0x6b, 0x6b, 0x6b, 0x6b, 0x6b, 0x6b, 0x6b, 0x6b, 0x6b, 0x6b, 0x6b, 0x6b, 0x6b, 0x6b, 0x6b, 0x6b, + 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, + 0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b, + 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, + 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, + 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, + 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, + 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, + 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, + 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, + 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, + 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, + 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, + 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, + 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, + 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, + 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, + 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, + 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, + 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, + 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, + 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, + 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, + 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, + 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, + 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, + 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, +}; + +static const uint8_t fbtab[8] = { 31, 7, 6, 5, 4, 3, 2, 1 }; + +/* Amplitude/Phase modulation tables. */ +static const uint8_t amt[4] = { 29, 4, 2, 1 }; /* OPNA */ + +/* libOPNMIDI: pan law table */ +static const uint16_t panlawtable[] = { + 65535, 65529, 65514, 65489, 65454, 65409, 65354, 65289, + 65214, 65129, 65034, 64929, 64814, 64689, 64554, 64410, + 64255, 64091, 63917, 63733, 63540, 63336, 63123, 62901, + 62668, 62426, 62175, 61914, 61644, 61364, 61075, 60776, + 60468, 60151, 59825, 59489, 59145, 58791, 58428, 58057, + 57676, 57287, 56889, 56482, 56067, 55643, 55211, 54770, + 54320, 53863, 53397, 52923, 52441, 51951, 51453, 50947, + 50433, 49912, 49383, 48846, 48302, 47750, 47191, + 46340, /* Center left */ + 46340, /* Center right */ + 45472, 44885, 44291, 43690, 43083, 42469, 41848, 41221, + 40588, 39948, 39303, 38651, 37994, 37330, 36661, 35986, + 35306, 34621, 33930, 33234, 32533, 31827, 31116, 30400, + 29680, 28955, 28225, 27492, 26754, 26012, 25266, 24516, + 23762, 23005, 22244, 21480, 20713, 19942, 19169, 18392, + 17613, 16831, 16046, 15259, 14469, 13678, 12884, 12088, + 11291, 10492, 9691, 8888, 8085, 7280, 6473, 5666, + 4858, 4050, 3240, 2431, 1620, 810, 0 +}; + +/* --------------------------------------------------------------------------- */ +static inline void LFO(OPNA *opna) +{ + uint8_t c = (opna->lfocount >> FM_LFOCBITS) & 0xff; + opna->lfocount += opna->lfodcount; + if (c < 0x80) opna->aml = (c << 1); + else opna->aml = ~(c << 1); +} + +/* --------------------------------------------------------------------------- +// Magic. No, really. +// In reality this just initialises some tables used by everything else, +// that are dependent on both the chip clock and the "DAC" samplerate. +// The hilarious thing though is that this is really the only place where +// the chip clock value gets actually *used*, and even then it's indirectly +// via the ratio parameter. +*/ +static void MakeTimeTable(OPNA *opna, uint32_t ratio) +{ + int h, l; + uint32_t *ratetable = opna->ratetable; + + if (ratio != opna->currentratio) + { + opna->currentratio = ratio; + + /* EG */ + for (h=1; h<16; h++) + { + for (l=0; l<4; l++) + { + int m = h == 15 ? 8 : l+4; + ratetable[h*4+l] = + ((ratio << (FM_EGBITS - 3 - FM_RATIOBITS)) << Min(h, 11)) * m; + } + } + ratetable[0] = ratetable[1] = ratetable[2] = ratetable[3] = 0; + ratetable[5] = ratetable[4], ratetable[7] = ratetable[6]; + } +} + +static void SetEGRate(FMOperator *op, uint32_t r) +{ + Channel4 *ch = op->master; + OPNA *opna = ch->master; + op->egstepd = opna->ratetable[r]; + op->egtransa = Limit(15 - (r>>2), 4, 1); + op->egtransd = 16 >> op->egtransa; +} + +/* Standard operator init routine. Zeros out some more stuff +// than OperatorReset() does, then calls OperatorReset(). +*/ +void OperatorInit(Channel4 *ch4, FMOperator *op) +{ + op->master = ch4; + + /* EG Part */ + op->ar = op->dr = op->sr = op->rr = op->ksr = 0; + op->ams = 0; + op->mute = 0; + op->keyon = 0; + + /* PG Part */ + op->multiple = 0; + op->detune = 0; + + /* LFO */ + op->ms = 0; + + OperatorReset(op); +} + +/* Standard operator reset routine. Init EG/PG to defaults, +// clear any stored samples, then force a reinit of EG/PG +// in OperatorPrepare() below by setting paramchanged to 1. +*/ +void OperatorReset(FMOperator *op) +{ + /* EG part */ + op->tl = op->tll = 127; + op->eglevel = 0xff; + op->eglvnext = 0x100; + SetEGRate(op, 0); + op->phase = off; + op->egstep = 0; + + /* PG part */ + op->pgcount = 0; + + /* OP part */ + op->out = op->out2 = 0; + op->paramchanged = 1; +} + +/* Init EG, PG. +// PG init is trivial, simply set pgdcount (phase counter increment) +// based on multiple, detune and bn. +// See Pages 24-26 of the OPNA manual for details. +// EG init is your standard ADSR state machine. Should (hopefully!) +// be self-explanatory, especially if you've ever seen a software implementation +// of ADSR before (seriously, they're all the damn same). +*/ +void OperatorPrepare(FMOperator *op) +{ + Channel4 *ch = op->master; + OPNA *opna = ch->master; + + if (op->paramchanged) + { + uint8_t l = ((op->multiple) ? 2*op->multiple : 1); + op->paramchanged = 0; + /* PG Part */ + op->pgdcount = (op->dp + dttab[op->detune + op->bn]) * (uint32_t)(l * opna->rr); + op->pgdcountl = op->pgdcount >> 11; + + /* EG Part */ + op->ksr = op->bn >> (3-op->ks); + + switch (op->phase) + { + case attack: + SetEGRate(op, op->ar ? Min(63, op->ar+op->ksr) : 0); + break; + case decay: + SetEGRate(op, op->dr ? Min(63, op->dr+op->ksr) : 0); + op->eglvnext = op->sl * 8; + break; + case sustain: + SetEGRate(op, op->sr ? Min(63, op->sr+op->ksr) : 0); + break; + case release: + SetEGRate(op, Min(63, op->rr+op->ksr)); + break; + case next: /* temporal */ + break; + case off: /* temporal */ + break; + } + /* LFO */ + op->ams = (op->amon ? (op->ms >> 4) & 3 : 0); + } +} + +/* FIXME: Rename. "Phase" here refers to ADSR DFA state, +// not PG/sine table phase. Also, yeah, this does the +// ADSR DFA state transitions. +*/ +static void ShiftPhase(FMOperator *op, EGPhase nextphase) +{ + switch (nextphase) + { + case attack: /* Attack Phase */ + op->tl = op->tll; + if ((op->ar+op->ksr) < 62) { + SetEGRate(op, op->ar ? Min(63, op->ar+op->ksr) : 0); + op->phase = attack; + break; + } + /* fall through */ + case decay: /* Decay Phase */ + if (op->sl) { + op->eglevel = 0; + op->eglvnext = op->sl*8; + SetEGRate(op, op->dr ? Min(63, op->dr+op->ksr) : 0); + op->phase = decay; + break; + } + /* fall through */ + case sustain: /* Sustain Phase */ + op->eglevel = op->sl*8; + op->eglvnext = 0x100; + SetEGRate(op, op->sr ? Min(63, op->sr+op->ksr) : 0); + op->phase = sustain; + break; + + case release: /* Release Phase */ + if (op->phase == attack || (op->eglevel < 0x100/* && phase != off*/)) { + op->eglvnext = 0x100; + SetEGRate(op, Min(63, op->rr+op->ksr)); + op->phase = release; + break; + } + /* fall through */ + case off: /* off */ + default: + op->eglevel = 0xff; + op->eglvnext = 0x100; + SetEGRate(op, 0); + op->phase = off; + break; + } +} + +/* Block/F-Num */ +static inline void SetFNum(FMOperator *op, uint32_t f) +{ + op->dp = (f & 2047) << ((f >> 11) & 7); + op->bn = notetab[(f >> 7) & 127]; + op->paramchanged = 1; +} + +/* Clock the EG for one operator. +// Essentially just a call to ShiftPhase, +// but decrements the output EG level if starting +// from the attack phase, otherwise incrementing it. +// Should probably integrate the special case for attack +// from ShiftPhase() directly into here at some point. */ +void EGCalc(FMOperator *op) +{ + op->egstep += 3L << (11 + FM_EGBITS); + if (op->phase == attack) + { + op->eglevel -= 1 + (op->eglevel >> op->egtransa); + if (op->eglevel <= 0) + ShiftPhase(op, decay); + } + else + { + op->eglevel += op->egtransd; + if (op->eglevel >= op->eglvnext) + ShiftPhase(op, (EGPhase)(op->phase+1)); + } +} + +/* KeyOn, hopefully obvious. */ +static void KeyOn(FMOperator *op) +{ + /*if (!op->keyon && ((op->ar = 31) || (op->ar == 62))) {*/ + if (!op->keyon) { + op->keyon = 1; + if (!op->sl) { + ShiftPhase(op, sustain); + op->out = op->out2 = 0; + op->pgcount = 0; + } else { + if (op->phase == off || op->phase == release) { + ShiftPhase(op, attack); + op->out = op->out2 = 0; + op->pgcount = 0; + } + } + } +} + +/* KeyOff, hopefully obvious. */ +static void KeyOff(FMOperator *op) +{ + if (op->keyon) { + op->keyon = 0; + ShiftPhase(op, release); + } +} + +/* PG uses 9 bits, with the table itsself using another 10 bits. +// The top bits are the actually relevant ones, given that the PG increment will basically set +// the lowest few bits to nonsense. +// The hack there that checks for bit 10 in the right place and if yes, does some strange xor magic +// makes the value of Sine() negative if we're in the top half of the [0,2*M_PI] interval. +// It is, of course, one/two's complement specific, but I have yet to hear of an integer arithmetic implementation +// on any modern machine that isn't at least one of those two. (In fact, I think they're all two's complement, even). */ +/*#define Sine(s) sinetable[((s) >> (20+FM_PGBITS-FM_OPSINBITS))&(FM_OPSINENTS/2-1)]^(-(((s) & 0x10000000) >> 27))*/ +#define Sine(s) sinetable[((s) >> (20+FM_PGBITS-FM_OPSINBITS))&(FM_OPSINENTS-1)] + +static inline uint32_t LogToLin(uint32_t x) { + if(x >= 0xff) { + return 0; + } + return cltab[x]; +} + +/* PG clock routine. +// Does this really need to be in its own function anymore? +// It's literally just a trivial increment of a counter now, nothing more. +// Its output, btw, is 2^(20+PGBITS) / cycle, with PGBITS=9 in this implementation. */ +static inline uint32_t PGCalc(FMOperator *op) +{ + uint32_t ret = op->pgcount; + op->pgcount += op->pgdcount; + return ret; +} + +/* Clock one FM operator. Does a lookup in the sine table +// for the waveform to output, possibly frequency-modulating +// that with the contents of in, then clocks the Phase Generator +// for that operator, stores the output sample and returns. +// Should probably integrate PGCalc() into this function, +// at some point at least. */ +static inline int32_t Calc(FMOperator *op, int32_t in) +{ + int32_t tmp = Sine(op->pgcount + (in << 7)); + op->out = op->egout*tmp; + PGCalc(op); + return op->out; +} + +/* Clock operator 0. OP0 is special as it does not take an input from +// another operator, rather it can frequency-modulate itsself via the +// fb parameter (which specifies feedback amount). This is incredibly +// useful, and makes it possible to define a lot more instruments +// for the OPNA than you'd be able to otherwise. */ +#define FM_PRECISEFEEDBACK 1 +static inline void CalcFB(FMOperator *op, uint32_t fb) +{ + int32_t tmp; + int32_t in = op->out + op->out2; + op->out2 = op->out; + if (FM_PRECISEFEEDBACK && fb == 31) + tmp = Sine(op->pgcount); + else + tmp = Sine(op->pgcount + ((in << 6) >> fb)); + + op->out = op->egout*tmp; + PGCalc(op); +} + +/* --------------------------------------------------------------------------- +// 4-op Channel +// Sets the "algorithm", i.e. the connections between individual operators +// in a channel. See Page 22 of the manual for pretty drawings of all of the +// different algorithms supported by the OPNA. +*/ +static void SetAlgorithm(Channel4 *ch4, uint32_t algo) +{ + static const uint8_t table1[8][6] = + { + { 0, 1, 1, 2, 2, 3 }, { 1, 0, 0, 1, 1, 2 }, + { 1, 1, 1, 0, 0, 2 }, { 0, 1, 2, 1, 1, 2 }, + { 0, 1, 2, 2, 2, 1 }, { 0, 1, 0, 1, 0, 1 }, + { 0, 1, 2, 1, 2, 1 }, { 1, 0, 1, 0, 1, 0 }, + }; + + ch4->idx[0] = table1[algo][0]; /* in[0]; */ + ch4->idx[1] = table1[algo][2]; /* in[1]; */ + ch4->idx[2] = table1[algo][4]; /* in[2]; */ + ch4->idx[3] = table1[algo][1]; /* out[0]; */ + ch4->idx[4] = table1[algo][3]; /* out[1]; */ + ch4->idx[5] = table1[algo][5]; /* out[2]; */ + ch4->op[0].out2 = ch4->op[0].out = 0; +} + +static inline void Ch4Init(OPNA *opna, Channel4 *ch4) +{ + int i; + ch4->master = opna; + for(i=0; i<4; i++) { + OperatorInit(ch4, &ch4->op[i]); + } + SetAlgorithm(ch4, 0); +} + +/* Reinit all operators on a given channel if paramchanged=1 +// for that channel, set the PM table for that channel, then determine +// if there is any output from this channel, based on: +// - mute state of each operator +// - keyon state of each operator +// - AM (Tremolo) enable for each operator. +// Bit 0 of the return value is set if there is any output, +// Bit 1 is set if tremolo is enabled for any of the operators on this +// channel. */ +static inline int Ch4Prepare(Channel4 *ch4) +{ + OperatorPrepare(&ch4->op[0]); + OperatorPrepare(&ch4->op[1]); + OperatorPrepare(&ch4->op[2]); + OperatorPrepare(&ch4->op[3]); + + if(ch4->op[0].mute && ch4->op[1].mute && ch4->op[2].mute && ch4->op[3].mute) + return 0; + else { + int key = (IsOn(&ch4->op[0]) | IsOn(&ch4->op[1]) | IsOn(&ch4->op[2]) | IsOn(&ch4->op[3])) ? 1 : 0; + int lfo = ch4->op[0].ms & (ch4->op[0].amon | ch4->op[1].amon | ch4->op[2].amon | ch4->op[3].amon ? 0x37 : 7) ? 2 : 0; + return key | lfo; + } +} + +/* Clock one channel. Clocks all the Envelope Generators in parallel +// (well, okay, in sequence, but a hardware implementation *should* +// clock them in parallel as they are completely independent tasks, +// all that is important is that you don't execute Calc{L,FB,FBL} +// until all of the EGs are done clocking - but that should be, again, +// straightforward to implement in hardware). +*/ +int32_t Ch4Calc(Channel4 *ch4) +{ + int i, o; + OPNA *opna = ch4->master; + ch4->buf[1] = ch4->buf[2] = ch4->buf[3] = 0; + for(i=0; i<4; i++) { + if ((ch4->op[i].egstep -= ch4->op[i].egstepd) < 0) + EGCalc(&ch4->op[i]); + ch4->op[i].egout = (LogToLin(ch4->op[i].eglevel + (opna->aml >> amt[ch4->op[i].ams]))*gaintab[ch4->op[i].tl]); + } + + ch4->buf[0] = ch4->op[0].out; CalcFB(&ch4->op[0], ch4->fb); + if (!(ch4->idx[0] | ch4->idx[2] | ch4->idx[4])) { + o = Calc(&ch4->op[1], ch4->buf[0]); + o += Calc(&ch4->op[2], ch4->buf[0]); + o += Calc(&ch4->op[3], ch4->buf[0]); + return (o >> 8); + } else { + ch4->buf[ch4->idx[3]] += Calc(&ch4->op[1], ch4->buf[ch4->idx[0]]); + ch4->buf[ch4->idx[4]] += Calc(&ch4->op[2], ch4->buf[ch4->idx[1]]); + o = ch4->op[3].out; + Calc(&ch4->op[3], ch4->buf[ch4->idx[2]]); + return ((ch4->buf[ch4->idx[5]] + o) >> 8); + } +} + +/* This essentially initializes a couple constant tables +// and chip-specific parameters based on what the chip clock and "DAC" samplerate +// were set to in OPNAInit(). psgrate is always equal to the user-requested samplerate, +// whereas rate is only equal to that in the interpolation=0 case, otherwise +// it's set to whatever value is needed to downsample 55466Hz to the user-requested +// samplerate, which will (almost?) always be either 44100Hz or 48000Hz. +// TODO: better-quality resampling may be of use here, possibly. +*/ +static void SetPrescaler(OPNA *opna, uint32_t p) +{ + static const char table[3][2] = { { 6, 4 }, { 3, 2 }, { 2, 1 } }; + static const uint8_t table2[8] = { 109, 78, 72, 68, 63, 45, 9, 6 }; + /* 512 */ + if (opna->prescale != p) + { + uint32_t i, fmclock; + uint32_t ratio; + + opna->prescale = p; + fmclock = opna->clock / table[p][0] / 12; + + if (opna->interpolation) { + opna->rate = fmclock * 2; + do { + opna->rate >>= 1; + opna->mpratio = opna->psgrate * 16384 / opna->rate; + } while (opna->mpratio <= 8192); + } else { + opna->rate = opna->psgrate; + } + ratio = ((fmclock << FM_RATIOBITS) + opna->rate/2) / opna->rate; + opna->timer_step = (int32_t)(1000000.0f * 65536.0f/fmclock); + /* PG Part */ + opna->rr = (float)ratio / (1 << (2 + FM_RATIOBITS - FM_PGBITS)); + MakeTimeTable(opna, ratio); + PSGSetClock(&opna->psg, opna->clock / table[p][1], opna->psgrate); + + for (i=0; i<8; i++) { + opna->lfotab[i] = (ratio << (1+FM_LFOCBITS-FM_RATIOBITS)) / table2[i]; + } + } +} + +static inline void RebuildTimeTable(OPNA *opna) +{ + int p = opna->prescale; + opna->prescale = -1; + SetPrescaler(opna, p); +} + +/* Chip-internal TimerA() handler. All it does is implement CSM, i.e. +// channel 3 will get keyed on and off whenever the TimerA() interrupt fires. +// To the best of my knowledge, CSM was intended to be used to implement +// primitive formant synthesis (which Yamaha later repackaged in a much more +// elaborate and featured implementation in their FS1R), and used by +// approximately nobody. It's also been removed from the YMF288/OPN3. +*/ +static void TimerA(OPNA *opna) +{ + int i; + if (opna->regtc & 0x80) + { + for(i=0; i<4; i++) + KeyOn(&opna->csmch->op[i]); + for(i=0; i<4; i++) + KeyOff(&opna->csmch->op[i]); + } +} + +/* --------------------------------------------------------------------------- +// Clock timers. TimerA has a resolution of 9 microseconds (assuming standard +// chip clockspeed of 8MHz, which all of this code of course does), and +// on the Speak Board for the PC-9801 is used only for the purpose of sound effects. +// TimerB, on the other hand, has a resolution of 144 microseconds, and is basically +// used as the main chip clock. Also, binding "sound-effects" to TimerB (needed as +// ZUN uses the sound-effects feature to implement PSG percussion) results in tiny +// changes to the output file, precisely none of them audible, making TimerA +// all but useless in this case. Note that TimerA is also used internally in the chip +// to implement CSM-mode (see comment above). +*/ +uint8_t OPNATimerCount(OPNA *opna, int32_t us) +{ + uint8_t event = 0; + + if (opna->timera_count) { + opna->timera_count -= us << 16; + if (opna->timera_count <= 0) { + event = 1; + TimerA(opna); + + while (opna->timera_count <= 0) + opna->timera_count += opna->timera; + + if (opna->regtc & 4) { + if (!(opna->status & 1)) { + opna->status |= 1; + } + } + } + } + if (opna->timerb_count) { + opna->timerb_count -= us << 12; + if (opna->timerb_count <= 0) { + event = 1; + while (opna->timerb_count <= 0) + opna->timerb_count += opna->timerb; + + if (opna->regtc & 8) { + if (!(opna->status & 2)) { + opna->status |= 2; + } + } + } + } + return event; +} + +/* Rhythm source samples. pcm_s8 (*not* u8!), and found in rhythmdata.h, +// which is included in rhythmdata.c in order to keep the size of the +// object file that you get from compiling this file at a reasonable size, +// for debugging/testing/sanity purposes. +*/ +extern const unsigned char* rhythmdata[6]; +static const unsigned int rhythmdatalen[6] = { + 9013, 10674, 66610, 7259, 18562, 3042 +}; + +/* --------------------------------------------------------------------------- +// Main chip init routine. +// c is the chip clock, which should never be set to anything other than 8MHz. +// r is the chip samplerate, set to 44100 typically. +// ipflag - if 1, ignore the value of r, clock the "DAC" at the OPNA-internal +// samplerate of 55466Hz, then downsample to whatever the actual value of r is. +*/ +uint8_t OPNAInit(OPNA *opna, uint32_t c, uint32_t r, uint8_t ipflag) +{ + int i; + opna->devmask = 0x7; + opna->prescale = 0; + opna->rate = 44100; + opna->mixl = 0; + opna->mixr = 0; + opna->mixdelta = 16383; + opna->interpolation = 0; + + for (i=0; i<8; i++) + opna->lfotab[i] = 0; + + opna->aml = 0; + + opna->currentratio = ~0; + opna->rr = 0; + for (i=0; i<64; i++) + opna->ratetable[i] = 0; + + for (i=0; i<6; i++) { + Ch4Init(opna, &opna->ch[i]); + opna->rhythm[i].sample = 0; + opna->rhythm[i].pos = 0; + opna->rhythm[i].size = 0; + opna->rhythm[i].volume = 0; + } + opna->rhythmtvol = 0; + opna->csmch = &opna->ch[2]; + for (i=0; i<6; i++) + opna->rhythm[i].pos = ~0; + + for (i=0; i<6; i++) + { + uint8_t *file_buf = (uint8_t*)0; + uint32_t fsize; + file_buf = (uint8_t*)rhythmdata[i]; + fsize = rhythmdatalen[i]; + file_buf += 44; + fsize -= 44; + fsize /= 2; + opna->rhythm[i].sample = (int8_t*)file_buf; + opna->rhythm[i].rate = 44100; + opna->rhythm[i].step = opna->rhythm[i].rate * 1024 / opna->rate; + opna->rhythm[i].pos = opna->rhythm[i].size = fsize * 1024; + } + + c /= 2; + opna->clock = c; + if (!OPNASetRate(opna, r, ipflag)) + return 0; + RebuildTimeTable(opna); + OPNAReset(opna); + PSGInit(&opna->psg); + + OPNASetChannelMask(opna, ~0); + return 1; +} + +/* --------------------------------------------------------------------------- +// Reset chip. Your standard routine, basically zeros everything in sight. +*/ +void OPNAReset(OPNA *opna) +{ + int i, j; + + opna->status = 0; + SetPrescaler(opna, 0); + opna->timera_count = 0; + opna->timerb_count = 0; + PSGReset(&opna->psg); + opna->reg29 = 0x1f; + opna->rhythmkey = 0; + for (i=0x20; i<0x28; i++) OPNASetReg(opna, i, 0); + for (i=0x30; i<0xc0; i++) OPNASetReg(opna, i, 0); + for (i=0x130; i<0x1c0; i++) OPNASetReg(opna, i, 0); + for (i=0x100; i<0x110; i++) OPNASetReg(opna, i, 0); + for (i=0x10; i<0x20; i++) OPNASetReg(opna, i, 0); + for (i=0; i<6; i++) { + Channel4 *ch = &opna->ch[i]; + ch->panl = 46340; + ch->panr = 46340; + for(j=0; j<4; j++) { + FMOperator *op = &opna->ch[i].op[j]; + OperatorReset(op); + } + } + + opna->statusnext = 0; + opna->lfocount = 0; + opna->status = 0; +} + +/* --------------------------------------------------------------------------- +// Change OPNA "DAC" samplerate. +// r and ipflag are as in OPNAInit(), above. +*/ +uint8_t OPNASetRate(OPNA *opna, uint32_t r, uint8_t ipflag) +{ + int i, j; + opna->interpolation = ipflag; + opna->psgrate = r; + RebuildTimeTable(opna); + opna->lfodcount = opna->reg22 & 0x08 ? opna->lfotab[opna->reg22 & 7] : 0; + + for (i=0; i<6; i++) { + for (j=0; j<4; j++) + opna->ch[i].op[j].paramchanged = 1; + } + for (i=0; i<6; i++) { + opna->rhythm[i].step = opna->rhythm[i].rate * 1024 / r; + } + return 1; +} + +void SetVolumeRhythm(OPNA *opna, unsigned int index, int db) +{ + db = Min(db, 20); + opna->rhythm[index].volume = 16-(db * 2 / 3); +} + +/* --------------------------------------------------------------------------- +// Set OPNA channel mask. The 6 LSBs of mask are 0 to disable that FM channel, +// and 1 to enable it. The next 3 LSBs are passed to PSGSetChannelMask() to, +// well, set the PSG channel mask (which behaves the same way: 0 disables +// a given channel and 1 enables it). +*/ +void OPNASetChannelMask(OPNA *opna, uint32_t mask) +{ + int i, j; + for (i=0; i<6; i++) { + for (j=0; j<4; j++) { + opna->ch[i].op[j].mute = (!(mask & (1 << i))); + opna->ch[i].op[j].paramchanged = 1; + } + } + PSGSetChannelMask(&opna->psg, (mask >> 6)); + /*if (!(mask & 0x200)) opna->devmask = 3;*/ +} + +#include + +/* libOPNMIDI: allow to disable the console messages */ +#if defined(OPNA_VERBOSE) +static void message(const char *fmt, ...) +{ + va_list ap; + va_start(ap, fmt); + vfprintf(stderr, fmt, ap); + va_end(ap); +} +#else +static void message(const char *fmt, ...) +{ + (void)fmt; +} +#endif + +/* --------------------------------------------------------------------------- +// Main OPNA register-set routine. Really long and boring switch-case. +// Basically taken directly from the manual - the only parts of the spec +// that were even the least bit tricky to implement were the f-number tables, +// everything else is basically obvious. +*/ +void OPNASetReg(OPNA *opna, uint32_t addr, uint32_t data) +{ + uint32_t j, _dp = 0; + int c = addr & 3; + switch (addr) + { + uint32_t modified; + uint32_t tmp; + + /* Timer ----------------------------------------------------------------- */ + case 0x24: case 0x25: + opna->regta[addr & 1] = (uint8_t)data; + tmp = (opna->regta[0] << 2) + (opna->regta[1] & 3); + opna->timera = (1024-tmp) * opna->timer_step; + break; + + case 0x26: + opna->timerb = (256-data) * opna->timer_step; + break; + + case 0x27: + tmp = opna->regtc ^ data; + opna->regtc = (uint8_t)data; + if (data & 0x10) + opna->status &= ~1; + if (data & 0x20) + opna->status &= ~2; + if (tmp & 0x01) + opna->timera_count = (data & 1) ? opna->timera : 0; + if (tmp & 0x02) + opna->timerb_count = (data & 2) ? opna->timerb : 0; + break; + + /* Misc ------------------------------------------------------------------ */ + case 0x28: /* Key On/Off */ + if ((data & 3) < 3) + { + uint32_t key = (data >> 4); + c = (data & 3) + (data & 4 ? 3 : 0); + if (key & 0x1) KeyOn(&opna->ch[c].op[0]); else KeyOff(&opna->ch[c].op[0]); + if (key & 0x2) KeyOn(&opna->ch[c].op[1]); else KeyOff(&opna->ch[c].op[1]); + if (key & 0x4) KeyOn(&opna->ch[c].op[2]); else KeyOff(&opna->ch[c].op[2]); + if (key & 0x8) KeyOn(&opna->ch[c].op[3]); else KeyOff(&opna->ch[c].op[3]); + } + break; + + /* Status Mask ----------------------------------------------------------- */ + case 0x29: + opna->reg29 = data; + break; + + /* Prescaler ------------------------------------------------------------- */ + case 0x2d: case 0x2e: case 0x2f: + SetPrescaler(opna, (addr-0x2d)); + break; + + /* F-Number -------------------------------------------------------------- */ + case 0x1a0: case 0x1a1: case 0x1a2: + c += 3; + /* fall through */ + case 0xa0: case 0xa1: case 0xa2: + opna->fnum[c] = data + opna->fnum2[c] * 0x100; + _dp = (opna->fnum[c] & 2047) << ((opna->fnum[c] >> 11) & 7); + for(j=0; j<4; j++) { + opna->ch[c].op[j].dp = _dp; + opna->ch[c].op[j].bn = notetab[(opna->fnum[c] >> 7) & 127]; + opna->ch[c].op[j].paramchanged = 1; + } + break; + + case 0x1a4: case 0x1a5: case 0x1a6: + c += 3; + /* fall through */ + case 0xa4 : case 0xa5: case 0xa6: + opna->fnum2[c] = (uint8_t)data; + break; + + case 0xa8: case 0xa9: case 0xaa: + opna->fnum3[c] = data + opna->fnum2[c+6] * 0x100; + break; + + case 0xac : case 0xad: case 0xae: + opna->fnum2[c+6] = (uint8_t)data; + break; + + /* Algorithm ------------------------------------------------------------- */ + case 0x1b0: case 0x1b1: case 0x1b2: + c += 3; + /* fall through */ + case 0xb0: case 0xb1: case 0xb2: + opna->ch[c].fb = fbtab[((data >> 3) & 7)]; + SetAlgorithm(&opna->ch[c], data & 7); + message("OP%u: Algorithm: %u, FB: %u\n", c, data & 7, opna->ch[c].fb); + break; + + case 0x1b4: case 0x1b5: case 0x1b6: + c += 3; + /* fall through */ + case 0xb4: case 0xb5: case 0xb6: + /*opna->pan[c] = (data >> 6) & 3;*/ + for(j=0; j<4; j++) { + opna->ch[c].op[j].ms = data; + opna->ch[c].op[j].paramchanged = 1; + } + break; + + /* Rhythm ---------------------------------------------------------------- */ + case 0x10: /* DM/KEYON */ + if (!(data & 0x80)) /* KEY ON */ + { + opna->rhythmkey |= data & 0x3f; + if (data & 0x01) opna->rhythm[0].pos = 0; + if (data & 0x02) opna->rhythm[1].pos = 0; + if (data & 0x04) opna->rhythm[2].pos = 0; + if (data & 0x08) opna->rhythm[3].pos = 0; + if (data & 0x10) opna->rhythm[4].pos = 0; + if (data & 0x20) opna->rhythm[5].pos = 0; + } + else + { /* DUMP */ + opna->rhythmkey &= ~data; + } + break; + + case 0x11: + opna->rhythmtl = ~data & 63; + break; + + case 0x1a: /* Top Cymbal */ + break; + case 0x18: /* Bass Drum */ + case 0x19: /* Snare Drum */ + case 0x1b: /* Hihat */ + case 0x1c: /* Tom-tom */ + case 0x1d: /* Rim shot */ + opna->rhythm[addr & 7].pan = (data >> 6) & 3; + opna->rhythm[addr & 7].level = ~data & 31; + break; + + /* LFO ------------------------------------------------------------------- */ + case 0x22: + modified = opna->reg22 ^ data; + opna->reg22 = data; + if (modified & 0x8) + opna->lfocount = 0; + opna->lfodcount = opna->reg22 & 8 ? opna->lfotab[opna->reg22 & 7] : 0; + message("LFO: reg22: %u, lfodcount: %u\n", opna->reg22, opna->lfodcount); + break; + + /* PSG ------------------------------------------------------------------- */ + case 0: case 1: case 2: case 3: case 4: case 5: case 6: case 7: + case 8: case 9: case 10: case 11: case 12: case 13: case 14: case 15: + PSGSetReg(&opna->psg, addr, data); + break; + + /* ADSR ------------------------------------------------------------------ */ + default: + if (c < 3) + { + if (addr & 0x100) + c += 3; + { + /*uint8_t slottable[4] = { 0, 2, 1, 3 };*/ + /*uint32_t slot = slottable[(addr >> 2) & 3];*/ + uint32_t slottable = 216; + uint32_t l, slot = ((slottable >> (((addr >> 2) & 3) << 1)) & 3); + FMOperator* op = &opna->ch[c].op[slot]; + + switch ((addr >> 4) & 15) + { + case 3: /* 30-3E DT/MULTI */ + op->detune = (((data >> 4) & 0x07) * 0x20); + op->multiple = (data & 0x0f); + l = ((op->multiple) ? 2*op->multiple : 1); + /* PG Part */ + op->pgdcount = (op->dp + dttab[op->detune + op->bn]) * (uint32_t)(l * opna->rr); + op->pgdcountl = op->pgdcount >> 11; + /*op->paramchanged = 1;*/ + if(!op->mute) + message("OP%u DT: %u, Mult: %u\n", c, op->detune, op->multiple); + break; + + case 4: /* 40-4E TL */ + if(!((opna->regtc & 0x80) && (opna->csmch == &opna->ch[c]))) { + op->tl = (data & 0x7f); + op->paramchanged = 1; + } + op->tll = (data & 0x7f); + break; + + case 5: /* 50-5E KS/AR */ + op->ks = ((data >> 6) & 3); + op->ar = ((data & 0x1f) * 2); + op->paramchanged = 1; + if(!op->mute) + message("OP%u KS: %u, AR: %u\n", c, op->ks, op->ar); + break; + + case 6: /* 60-6E DR/AMON */ + op->dr = ((data & 0x1f) * 2); + op->amon = ((data & 0x80) != 0); + op->paramchanged = 1; + if(!op->mute) + message("OP%u DR: %u, AM: %u\n", c, op->dr, op->amon); + break; + + case 7: /* 70-7E SR */ + op->sr = ((data & 0x1f) * 2); + op->paramchanged = 1; + if(!op->mute) + message("OP%u SR: %u\n", c, op->sr); + break; + + case 8: /* 80-8E SL/RR */ + op->sl = (((data >> 4) & 15) * 4); + op->rr = ((data & 0x0f) * 4 + 2); + op->paramchanged = 1; + if(!op->mute) + message("OP%u SL: %u, RR: %u\n", c, op->sl, op->rr); + break; + + case 9: /* 90-9E SSG-EC */ + op->ssgtype = (data & 0x0f); + message("OP%u SSG-EG: %u\n", c, op->ssgtype); + break; + } + } + } + break; + } +} + +/* libOPNMIDI: soft panning */ +void OPNASetPan(OPNA *opna, uint32_t chan, uint32_t data) +{ + assert(chan < 6); + assert(data < 128); + opna->ch[chan].panl = panlawtable[data & 0x7F]; + opna->ch[chan].panr = panlawtable[0x7F - (data & 0x7F)]; +} + +/* --------------------------------------------------------------------------- +// Read OPNA register. Pointless. Only SSG registers can be read, and of those +// the only one anyone seems to be interested in reading is register 7, +// which as I explain in detail in psg.c, is completely superfluous. +*/ +uint32_t OPNAGetReg(OPNA *opna, uint32_t addr) +{ + if (addr < 0x10) + return PSGGetReg(&opna->psg, addr); + if (addr == 0xff) + return 1; + return 0; +} + +/* --------------------------------------------------------------------------- */ + +static inline void MixSubS(Channel4 ch[6], int activech, int32_t *dest) +{ + unsigned int c; + int32_t l = 0; + int32_t r = 0; + + for (c = 0; c < 6; ++c) { + if (activech & (1 << (c << 1))) { + int32_t s = Ch4Calc(&ch[c]); + s >>= 2; /* libOPNMIDI: prevent FM channel clipping (TODO: also adjust PSG and rhythm) */ + l += s * ch[c].panl / 65536; + r += s * ch[c].panr / 65536; + } + } + + dest[0] = l; + dest[1] = r; +} + +/* --------------------------------------------------------------------------- +// Mix FM channels and output. Mix6 runs at user-specified samplerate, +// Mix6I runs at the chip samplerate of 55466Hz and then downsamples +// to the user-specified samplerate. It is an open problem as to determining +// if one of these sounds better than the other. +*/ +#define IStoSample(s) (Limit16((s))) + +static void Mix6(OPNA *opna, int32_t *buffer, uint32_t nsamples, int activech) +{ + /* Mix */ + int32_t ibuf[2]; + unsigned int i; + + for (i = 0; i < nsamples; i++) { + ibuf[0] = 0; + ibuf[1] = 0; + if (activech & 0xaaa) + LFO(opna), MixSubS(opna->ch, activech, ibuf); + else + MixSubS(opna->ch, activech, ibuf); + buffer[i * 2 + 0] += IStoSample(ibuf[0]); + buffer[i * 2 + 1] += IStoSample(ibuf[1]); + } +} + +/* --------------------------------------------------------------------------- +// See comment above Mix6(), above. +*/ +static void Mix6I(OPNA *opna, int32_t *buffer, uint32_t nsamples, int activech) +{ + /* Mix */ + int32_t ibuf[2], delta = opna->mixdelta; + unsigned int i; + + if (opna->mpratio < 16384) { + for (i = 0; i < nsamples; i++) { + int32_t l = 0, r = 0, d = 0; + while (delta > 0) { + ibuf[0] = 0; + ibuf[1] = 0; + if (activech & 0xaaa) + LFO(opna), MixSubS(opna->ch, activech, ibuf); + else + MixSubS(opna->ch, activech, ibuf); + + l = IStoSample(ibuf[0]); + r = IStoSample(ibuf[1]); + d = Min(opna->mpratio, delta); + opna->mixl += l * d; + opna->mixr += r * d; + delta -= opna->mpratio; + } + buffer[i * 2 + 0] += opna->mixl >> 14; + buffer[i * 2 + 1] += opna->mixr >> 14; + opna->mixl = l * (16384-d); + opna->mixr = r * (16384-d); + delta += 16384; + } + } else { + int impr = 16384 * 16384 / opna->mpratio; + for (i = 0; i < nsamples; i++) { + int32_t l, r; + if (delta < 0) { + delta += 16384; + opna->mixl = opna->mixl1; + opna->mixr = opna->mixr1; + + ibuf[0] = 0; + ibuf[1] = 0; + if (activech & 0xaaa) + LFO(opna), MixSubS(opna->ch, activech, ibuf); + else + MixSubS(opna->ch, activech, ibuf); + + opna->mixl1 = IStoSample(ibuf[0]); + opna->mixr1 = IStoSample(ibuf[1]); + } + l = (delta * opna->mixl + (16384 - delta) * opna->mixl1) / 16384; + r = (delta * opna->mixr + (16384 - delta) * opna->mixr1) / 16384; + buffer[i * 2 + 0] += l; + buffer[i * 2 + 1] += r; + delta -= impr; + } + } + opna->mixdelta = delta; +} + +/* --------------------------------------------------------------------------- +// Main FM output routine. Clocks all of the operators on the chip, then mixes +// together the output using one of Mix6() or Mix6I() above, and then outputs +// the result to OPNAMix, which is what the calling routine will actually use. +// buffer should be a pointer to a buffer of type Sample (int32_t in this +// implementation, though another used float and in principle int16_t *should* +// be sufficient), and be of size at least equal to nsamples. +*/ +static void FMMix(OPNA *opna, int32_t *buffer, uint32_t nsamples) +{ + uint32_t j; + { + /* Set F-Number */ + if (!(opna->regtc & 0xc0)) { + uint32_t _dp = (opna->fnum[opna->csmch-opna->ch] & 2047) << ((opna->fnum[opna->csmch-opna->ch] >> 11) & 7); + for(j=0; j<4; j++) { + opna->csmch->op[j].dp = _dp; + opna->csmch->op[j].bn = notetab[(opna->fnum[opna->csmch-opna->ch] >> 7) & 127]; + opna->csmch->op[j].paramchanged = 1; + } + } else { + SetFNum(&opna->csmch->op[0], opna->fnum3[1]); SetFNum(&opna->csmch->op[1], opna->fnum3[2]); + SetFNum(&opna->csmch->op[2], opna->fnum3[0]); SetFNum(&opna->csmch->op[3], opna->fnum[2]); + } + } + + { + int act = (((Ch4Prepare(&opna->ch[2]) << 2) | Ch4Prepare(&opna->ch[1])) << 2) | Ch4Prepare(&opna->ch[0]); + if (opna->reg29 & 0x80) + act |= (Ch4Prepare(&opna->ch[3]) | ((Ch4Prepare(&opna->ch[4]) | (Ch4Prepare(&opna->ch[5]) << 2)) << 2)) << 6; + if (!(opna->reg22 & 0x08)) + act &= 0x555; + + if (act & 0x555) { + if (opna->interpolation) + Mix6I(opna, buffer, nsamples, act); + else + Mix6(opna, buffer, nsamples, act); + } else { + opna->mixl = 0, opna->mixr = 0, opna->mixdelta = 16383; + } + } +} + +/* --------------------------------------------------------------------------- +// Mix Rhythm generator output. Boring, just takes the PCM samples, +// multiplies them by the volume set for that rhythm sample, and then outputs +// the appropriate length of sample for that given samplerate to buffer. +// The same restrictions on buffer as in FMMix() above apply. +*/ +static void RhythmMix(OPNA *opna, int32_t *buffer, uint32_t count) +{ + unsigned int i, j; + if (opna->rhythmtvol < 128 && opna->rhythm[0].sample && (opna->rhythmkey & 0x3f)) { + for (i=0; i<6; i++) { + Rhythm *r = &opna->rhythm[i]; + if ((opna->rhythmkey & (1 << i)) && r->level >= 0) { + int db = Limit(opna->rhythmtl+r->level+r->volume, 127, 0); + int vol = cltab[db]; + + for (j = 0; j < count && r->pos < r->size; j++) { + int sample = Limit16(((r->sample[r->pos >> 10] << 8) * vol) >> 10); + r->pos += r->step; + buffer[j * 2 + 0] += sample; + buffer[j * 2 + 1] += sample; + } + } + } + } +} + +/* --------------------------------------------------------------------------- +// Main OPNA output routine. See FMMix(), RhythmMix() above and PSGMix() +// in psg.c for details. +*/ +void OPNAMix(OPNA *opna, int16_t *buf, uint32_t nframes) +{ + int32_t buffer[16384]; + unsigned int i, clips = 0; + for (i = 0; i < 2 * nframes; i++) buffer[i] = 0; + if(opna->devmask & 1) FMMix(opna, buffer, nframes); + if(opna->devmask & 2) PSGMix(&opna->psg, buffer, nframes); + if(opna->devmask & 4) RhythmMix(opna, buffer, nframes); + for (i = 0; i < 2 * nframes; i++) { + int32_t k = (buffer[i] >> 2); + if (k > 32767 || k < -32767) clips++; + buf[i] = Limit16(k); + } + if (clips) message("clipped %u samples\n", clips); +} diff --git a/thirdparty/opnmidi/chips/pmdwin/opna.h b/thirdparty/opnmidi/chips/pmdwin/opna.h new file mode 100644 index 0000000..81dc51d --- /dev/null +++ b/thirdparty/opnmidi/chips/pmdwin/opna.h @@ -0,0 +1,91 @@ +#ifndef __OPNA_H__ +#define __OPNA_H__ + +#include +#include "op.h" +#include "psg.h" + +/* YM2608 (OPNA) ------------------------------------------------------ */ +typedef struct _OPNA +{ + int fmvolume; + uint32_t clock; + uint32_t rate; + uint32_t psgrate; + uint32_t status; + Channel4 ch[6]; + Channel4* csmch; + + int32_t mixdelta; + int mpratio; + uint8_t interpolation; + + uint8_t timer_status; + uint8_t regtc; + uint8_t regta[2]; + + int32_t timera, timera_count; + int32_t timerb, timerb_count; + int32_t timer_step; + uint8_t prescale; + uint8_t devmask; + + PSG psg; + + Rhythm rhythm[6]; + int8_t rhythmtl; + int rhythmtvol; + uint8_t rhythmkey; + + int32_t mixl, mixl1; + int32_t mixr, mixr1; + uint8_t fnum2[9]; + + uint8_t reg22; + uint32_t reg29; + uint32_t statusnext; + + uint32_t lfocount; + uint32_t lfodcount; + uint32_t lfotab[8]; + + uint32_t fnum[6]; + uint32_t fnum3[3]; + + uint8_t aml; + + uint32_t currentratio; + float rr; + uint32_t ratetable[64]; +} OPNA; + +#ifdef __cplusplus +extern "C" { +#endif + +/* --------------------------------------------------------------------------- */ +uint8_t OPNAInit(OPNA *opna, uint32_t c, uint32_t r, uint8_t ipflag); +void OPNAReset(OPNA *opna); +void OPNASetVolumeRhythm(OPNA *opna, int index, int db); +uint8_t OPNASetRate(OPNA *opna, uint32_t r, uint8_t ipflag); +void OPNASetChannelMask(OPNA *opna, uint32_t mask); +void OPNASetReg(OPNA *opna, uint32_t addr, uint32_t data); +void OPNASetPan(OPNA *opna, uint32_t chan, uint32_t data); +uint8_t OPNATimerCount(OPNA *opna, int32_t us); +void OPNAMix(OPNA *opna, int16_t *buffer, uint32_t nframes); + +/* --------------------------------------------------------------------------- */ +static inline uint32_t OPNAReadStatus(OPNA *opna) { return opna->status & 0x03; } + +static inline int32_t OPNAGetNextEvent(OPNA *opna) +{ + uint32_t ta = ((opna->timera_count + 0xffff) >> 16) - 1; + uint32_t tb = ((opna->timerb_count + 0xfff) >> 12) - 1; + return (ta < tb ? ta : tb) + 1; +} + +#ifdef __cplusplus +} +#endif + +#endif /* FM_OPNA_H */ diff --git a/thirdparty/opnmidi/chips/pmdwin/psg.c b/thirdparty/opnmidi/chips/pmdwin/psg.c new file mode 100644 index 0000000..44a7cf0 --- /dev/null +++ b/thirdparty/opnmidi/chips/pmdwin/psg.c @@ -0,0 +1,343 @@ +/* FIXME: move ugly-ass legalese somewhere where it won't be seen +// by anyone other than lawyers. (/dev/null would be ideal but sadly +// we live in an imperfect world). */ +/* Copyright (c) 2012/2013, Peter Barfuss +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + +1. Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. +2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR +ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ + +/* Quick, somewhat hacky PSG implementation. Seems to work fine in most cases. +// Known bugs: volume *may* still be off for a lot of samples. Importantly, +// waveform volume is too quiet but setting it at the correct volume makes +// the noise volume too loud and vice-versa. I *think* what I have currently +// is mostly correct (I'm basing this mostly on how good Strawberry Crisis +// sounds with the given settings), but it's possible that more fine-tuning +// is needed. Apart from that, this is probably the sketchiest part of all +// of my emulator code, but then again there's a bit-exact VHDL core of +// the YM2149F/AY-3-8910, so while I do want to make this as good +// as the code in opna.c, it's the lowest-priority of all of the code here. +// --bofh */ +#include +#include +#include +#include +#include +#include "op.h" +#include "psg.h" + +/* --------------------------------------------------------------------------- +// ???? +*/ +int EmitTable[0x20] = { -1, }; +uint32_t enveloptable[16][64] = { { 0, }, }; + +/* --------------------------------------------------------------------------- +// PSG reset to power-on defaults +*/ +void PSGReset(PSG *psg) +{ + int i; + for (i=0; i<14; i++) + PSGSetReg(psg, i, 0); + PSGSetReg(psg, 7, 0xff); + PSGSetReg(psg, 14, 0xff); + PSGSetReg(psg, 15, 0xff); +} + +/* --------------------------------------------------------------------------- +// This code is strongly inspired by some random PSG emulator code I found, +// and is probably not the optimal way to define periods. It *is* at least +// among the fastest, given that it uses the hilarious hack of using the +// integer overflow on a 32-bit unsigned integer to compute ""moduli"". +*/ +void PSGSetClock(PSG *psg, uint32_t clock, uint32_t rate) +{ + int tmp; + psg->tperiodbase = (uint32_t)((1 << toneshift ) / 4.0f * clock / rate); + psg->eperiodbase = (uint32_t)((1 << envshift ) / 4.0f * clock / rate); + + tmp = ((psg->reg[0] + psg->reg[1] * 256) & 0xfff); + psg->speriod[0] = tmp ? psg->tperiodbase / tmp : psg->tperiodbase; + tmp = ((psg->reg[2] + psg->reg[3] * 256) & 0xfff); + psg->speriod[1] = tmp ? psg->tperiodbase / tmp : psg->tperiodbase; + tmp = ((psg->reg[4] + psg->reg[5] * 256) & 0xfff); + psg->speriod[2] = tmp ? psg->tperiodbase / tmp : psg->tperiodbase; + tmp = psg->reg[6] & 0x1f; + psg->nperiod = tmp; + tmp = ((psg->reg[11] + psg->reg[12] * 256) & 0xffff); + psg->eperiod = tmp ? psg->eperiodbase / tmp : psg->eperiodbase * 2; +} + +/* --------------------------------------------------------------------------- +// ???????????? +*/ +static uint8_t table3[4] = { 0, 1, -1, 0 }; +void MakeEnvelopTable(void) +{ + /* 0 lo 1 up 2 down 3 hi */ + static uint8_t table1[16*2] = + { + 2,0, 2,0, 2,0, 2,0, 1,0, 1,0, 1,0, 1,0, + 2,2, 2,0, 2,1, 2,3, 1,1, 1,3, 1,2, 1,0, + }; + int i, j; + + if (!enveloptable[0][0]) { + uint32_t *ptr = enveloptable[0]; + for (i=0; i<16*2; i++) { + uint8_t v = ((table1[i] & 0x2) ? 31 : 0); + for (j=0; j<32; j++) { + *ptr++ = EmitTable[v]; + v += table3[table1[i]]; + } + } + } +} + +/* --------------------------------------------------------------------------- +// Sets the channel output mask for the PSG device. +// c is a bitvector where the 3 LSBs are set to 0 to disable a given +// PSG channel and 1 to enable it. +// TODO: Possibly allow enabling tone/noise output for each channel independently? +*/ +void PSGSetChannelMask(PSG *psg, int c) +{ + int i; + psg->mask = c; + for (i=0; i<3; i++) + psg->olevel[i] = psg->mask & (1 << i) ? EmitTable[(psg->reg[8+i] & 15) * 2 + 1] : 0; +} + +/* --------------------------------------------------------------------------- +// PSG register set routine. Mostly just what you'd expect from reading the manual. +// Fairly boring code overall. regnum can be 0 - 15, data can be 0x00 - 0xFF. +// (This should not be surprising - the YM2149F *did* use an 8-bit bus, after all). +// Interesting quirk: the task of register 7 (channel enable/disable) is basically +// entirely duplicated by other registers, to the point where you can basically +// just ignore any writes to register 7 entirely. I save it here in case some +// braindead routine wants to read its value and do something based on that +// (Another curiosity: register 7 on the PSG appears to be the only register +// between *both* the OPNA and the PSG which is actually *read from* by +// pmdwin.cpp and not just written to. Amusingly enough, the only reason +// that it is ever read is so that it can then OR something with what it just read +// and then write that back to register 7. Hilarity). +// HACK ALERT: The output levels for channels 0 and 1 are increased by a factor of 4 +// to make them match the actual chip in loudness, but without causing the noise channel +// to overtake everything in intensity. This is almost certainly wrong, and moreover +// it assumes that channel 2 will be playing back Speak Board effects which usually means +// drum kit only (for the most part, at least), and not being used as a separate tonal +// channel in its own right. To the best of my knowledge, this does hold for all of ZUN's +// songs, however, once you step outside that set of music, it's trivial to find +// all sorts of counterexamples to that assumption. Therefore, this should be fixed ASAP. +*/ +void PSGSetReg(PSG *psg, uint8_t regnum, uint8_t data) +{ + if (regnum < 0x10) + { + psg->reg[regnum] = data; + switch (regnum) + { + int tmp; + + case 0: /* ChA Fine Tune */ + case 1: /* ChA Coarse Tune */ + tmp = ((psg->reg[0] + psg->reg[1] * 256) & 0xfff); + psg->speriod[0] = tmp ? psg->tperiodbase / tmp : psg->tperiodbase; + break; + + case 2: /* ChB Fine Tune */ + case 3: /* ChB Coarse Tune */ + tmp = ((psg->reg[2] + psg->reg[3] * 256) & 0xfff); + psg->speriod[1] = tmp ? psg->tperiodbase / tmp : psg->tperiodbase; + break; + + case 4: /* ChC Fine Tune */ + case 5: /* ChC Coarse Tune */ + tmp = ((psg->reg[4] + psg->reg[5] * 256) & 0xfff); + psg->speriod[2] = tmp ? psg->tperiodbase / tmp : psg->tperiodbase; + break; + + case 6: /* Noise generator control */ + data &= 0x1f; + psg->nperiod = data; + break; + + case 8: + psg->olevel[0] = psg->mask & 1 ? EmitTable[(data & 15) * 2 + 1] : 0; + break; + + case 9: + psg->olevel[1] = psg->mask & 2 ? EmitTable[(data & 15) * 2 + 1] : 0; + break; + + case 10: + psg->olevel[2] = psg->mask & 4 ? EmitTable[(data & 15) * 2 + 1] : 0; + break; + + case 11: /* Envelope period */ + case 12: + tmp = ((psg->reg[11] + psg->reg[12] * 256) & 0xffff); + psg->eperiod = tmp ? psg->eperiodbase / tmp : psg->eperiodbase * 2; + break; + + case 13: /* Envelope shape */ + psg->ecount = 0; + psg->envelop = enveloptable[data & 15]; + break; + } + } +} + +/* --------------------------------------------------------------------------- +// Init code. Set volume to 0, reset the chip, enable all channels, seed the RNG. +// RNG seed lifted from MAME's YM2149F emulation routine, appears to be correct. +*/ +void PSGInit(PSG *psg) +{ + int i; + float base = 0x4000 / 3.0f; + for (i=31; i>=2; i--) + { + EmitTable[i] = lrintf(base); + base *= 0.840896415f; /* 1.0f / 1.189207115f */ + } + EmitTable[1] = 0; + EmitTable[0] = 0; + MakeEnvelopTable(); + + PSGSetChannelMask(psg, psg->mask); + psg->rng = 14231; + psg->ncount = 0; + PSGReset(psg); + psg->mask = 0x3f; +} + +/* --------------------------------------------------------------------------- +// The main output routine for the PSG emulation. +// dest should be an array of size nsamples, and of type Sample +// (one of int16_t, int32_t or float - any will work here without causing +// clipping/precision problems). +// Everything is implemented using some form of fixed-point arithmetic +// that currently needs no more than 32-bits for its implementation, +// but I'm pretty certain that you can get by with much less than that +// and still have mostly correct-to-fully-correct emulation. +// +// TODO: In the future, test the veracity of the above statement. Moreover, +// if it turns out to be correct, rewrite this routine to not use more than +// the required precision. This is irrelevant for any PC newer than, well, +// a 386DX/68040, but important for efficient hardware implementation. +*/ +void PSGMix(PSG *psg, int32_t *dest, uint32_t nsamples) +{ + uint8_t chenable[3]; + uint8_t r7 = ~psg->reg[7]; + unsigned int i, k = 0; + int x, y, z; + + if ((r7 & 0x3f) | ((psg->reg[8] | psg->reg[9] | psg->reg[10]) & 0x1f)) { + int noise, sample; + uint32_t env; + uint32_t* p1; + uint32_t* p2; + uint32_t* p3; + + chenable[0] = (r7 & 0x01) && (psg->speriod[0] <= (1 << toneshift)); + chenable[1] = (r7 & 0x02) && (psg->speriod[1] <= (1 << toneshift)); + chenable[2] = (r7 & 0x04) && (psg->speriod[2] <= (1 << toneshift)); + + p1 = ((psg->mask & 1) && (psg->reg[ 8] & 0x10)) ? &env : &psg->olevel[0]; + p2 = ((psg->mask & 2) && (psg->reg[ 9] & 0x10)) ? &env : &psg->olevel[1]; + p3 = ((psg->mask & 4) && (psg->reg[10] & 0x10)) ? &env : &psg->olevel[2]; + #define SCOUNT(ch) (psg->scount[ch] >> toneshift) + + if (p1 != &env && p2 != &env && p3 != &env) { + for (i=0; incount++; + if(psg->ncount >= psg->nperiod) { + if(psg->rng & 1) + psg->rng ^= 0x24000; + psg->rng >>= 1; + psg->ncount = 0; + } + noise = (psg->rng & 1); + sample = 0; + { + x = ((SCOUNT(0) & chenable[0]) | ((r7 >> 3) & noise)) - 1; /* 0 or -1 */ + sample += (psg->olevel[0] + x) ^ x; + psg->scount[0] += psg->speriod[0]; + y = ((SCOUNT(1) & chenable[1]) | ((r7 >> 4) & noise)) - 1; + sample += (psg->olevel[1] + y) ^ y; + psg->scount[1] += psg->speriod[1]; + /*z = ((SCOUNT(2) & chenable[2]) | ((r7 >> 5) & noise)) - 1;*/ + z = ((r7 >> 5) & noise) - 1; + sample += (psg->olevel[2] + z) ^ z; + psg->scount[2] += psg->speriod[2]; + } + sample = Limit16(sample); + dest[k++] += sample; + dest[k++] += sample; + } + + psg->ecount = (psg->ecount >> 8) + (psg->eperiod >> 8) * nsamples; + if (psg->ecount >= (1 << (envshift+6-8))) { + if ((psg->reg[0x0d] & 0x0b) != 0x0a) + psg->ecount |= (1 << (envshift+5-8)); + psg->ecount &= (1 << (envshift+6-8)) - 1; + } + psg->ecount <<= 8; + } else { + for (i=0; incount++; + if(psg->ncount >= psg->nperiod) { + if(psg->rng & 1) + psg->rng ^= 0x24000; + psg->rng >>= 1; + psg->ncount = 0; + } + noise = (psg->rng & 1); + sample = 0; + { + env = psg->envelop[psg->ecount >> envshift]; + psg->ecount += psg->eperiod; + if (psg->ecount >= (1 << (envshift+6))) { + if ((psg->reg[0x0d] & 0x0b) != 0x0a) + psg->ecount |= (1 << (envshift+5)); + psg->ecount &= (1 << (envshift+6)) - 1; + } + x = ((SCOUNT(0) & chenable[0]) | ((r7 >> 3) & noise)) - 1; /* 0 or -1 */ + sample += (*p1 + x) ^ x; + psg->scount[0] += psg->speriod[0]; + y = ((SCOUNT(1) & chenable[1]) | ((r7 >> 4) & noise)) - 1; + sample += (*p2 + y) ^ y; + psg->scount[1] += psg->speriod[1]; + /*z = ((SCOUNT(2) & chenable[2]) | ((r7 >> 5) & noise)) - 1;*/ + z = ((r7 >> 5) & noise) - 1; + sample += (*p3 + z) ^ z; + psg->scount[2] += psg->speriod[2]; + } + sample = Limit16(sample); + dest[k++] += sample; + dest[k++] += sample; + } + } + } +} + diff --git a/thirdparty/opnmidi/chips/pmdwin/psg.h b/thirdparty/opnmidi/chips/pmdwin/psg.h new file mode 100644 index 0000000..9f6f1c9 --- /dev/null +++ b/thirdparty/opnmidi/chips/pmdwin/psg.h @@ -0,0 +1,52 @@ +#ifndef __PSG_H__ +#define __PSG_H__ + +#include +#define PSG_SAMPLETYPE int32_t /* any of int16_t, int32_t or float will work here. */ + +/* Constants for the shift amounts used in the counters. +*/ +enum { + toneshift = 24, + envshift = 22 +}; + +typedef struct _PSG { + uint8_t reg[16]; + + const uint32_t *envelop; + uint32_t rng; + uint32_t olevel[3]; + uint32_t scount[3], speriod[3]; + uint32_t ecount, eperiod; + uint32_t ncount, nperiod; + uint32_t tperiodbase; + uint32_t eperiodbase; + int volume; + int mask; +} PSG; + +#ifdef __cplusplus +extern "C" { +#endif + +/* Mostly self-explanatory. +// Actual descriptions of each function can be found in psg.c +// Also, PSGGetReg() is basically useless. +// (More info on that can *also* be found in psg.c). */ +void PSGInit(PSG *psg); +void PSGReset(PSG *psg); +void PSGSetClock(PSG *psg, uint32_t clock, uint32_t rate); +void PSGSetChannelMask(PSG *psg, int c); +void PSGSetReg(PSG *psg, uint8_t regnum, uint8_t data); +void PSGMix(PSG *psg, int32_t *dest, uint32_t nsamples); + +static inline uint32_t PSGGetReg(PSG *psg, uint8_t regnum) { + return psg->reg[regnum & 0x0f]; +} + +#ifdef __cplusplus +} +#endif + +#endif /* PSG_H */ diff --git a/thirdparty/opnmidi/chips/pmdwin/rhythmdata.c b/thirdparty/opnmidi/chips/pmdwin/rhythmdata.c new file mode 100644 index 0000000..2d00327 --- /dev/null +++ b/thirdparty/opnmidi/chips/pmdwin/rhythmdata.c @@ -0,0 +1,5 @@ +#include "rhythmdata.h" + +const unsigned char* rhythmdata[6] = { + BD_2608, SD_2608, TOP_2608, HH_2608, TOM_2608, RIM_2608 +}; diff --git a/thirdparty/opnmidi/chips/pmdwin/rhythmdata.h b/thirdparty/opnmidi/chips/pmdwin/rhythmdata.h new file mode 100644 index 0000000..e3a7e36 --- /dev/null +++ b/thirdparty/opnmidi/chips/pmdwin/rhythmdata.h @@ -0,0 +1,5254 @@ +static const unsigned char BD_2608[9013] = { + 0x52, 0x49, 0x46, 0x46, 0x36, 0x46, 0x00, 0x00, 0x57, 0x41, 0x56, 0x45, 0x66, 0x6d, 0x74, 0x20, 0x10, 0x00, 0x00, 0x00, 0x01, 0x00, + 0x01, 0x00, 0x44, 0xac, 0x00, 0x00, 0x88, 0x58, 0x01, 0x00, 0x02, 0x00, 0x10, 0x00, 0x66, 0x61, 0x63, 0x74, 0x04, 0x00, 0x00, 0x00, + 0x23, 0x00, 0x61, 0x61, 0x46, 0x00, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, + 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, + 0x03, 0x03, 0x03, 0x03, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, + 0x04, 0x04, 0x04, 0x04, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, + 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, + 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, + 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, + 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, + 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, + 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, + 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, + 0x07, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, + 0x06, 0x06, 0x06, 0x06, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, + 0x05, 0x05, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x03, 0x03, 0x03, 0x03, + 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x02, 0x02, 0x01, 0xff, 0xff, 0xff, 0x02, 0x05, 0x05, 0x06, 0x09, 0x10, 0x19, 0x1c, 0x18, + 0x09, 0xef, 0xd2, 0xc5, 0xdd, 0xff, 0x1b, 0x27, 0x1e, 0x0d, 0x02, 0x00, 0xf1, 0xd3, 0xb9, 0xbe, 0xd8, 0x01, 0x2a, 0x3c, 0x39, 0x1b, + 0xe4, 0xbf, 0xb9, 0xcd, 0xed, 0x0f, 0x29, 0x32, 0x2c, 0x1a, 0x0c, 0x10, 0x15, 0x0e, 0xfa, 0xe2, 0xce, 0xc0, 0xb8, 0xb5, 0xbb, 0xcd, + 0xeb, 0x07, 0x14, 0x10, 0x00, 0xe9, 0xd7, 0xd1, 0xd3, 0xdb, 0xe2, 0xd9, 0xcc, 0xc3, 0xcc, 0xeb, 0x11, 0x12, 0xde, 0xb1, 0xa6, 0xb6, + 0xbd, 0xc9, 0xd6, 0xe0, 0xde, 0xd3, 0xbf, 0xaa, 0xa1, 0xbf, 0xf3, 0x0e, 0x08, 0xe8, 0xc4, 0xae, 0xab, 0xb2, 0xb6, 0xb9, 0xb3, 0xa9, + 0xa7, 0xa9, 0xab, 0xa9, 0xaa, 0xb4, 0xc2, 0xc3, 0xbd, 0xba, 0xc2, 0xc8, 0xcb, 0xc1, 0xac, 0x9d, 0x9e, 0xa9, 0xb2, 0xbe, 0xd0, 0xe4, + 0xf0, 0xf5, 0xef, 0xdf, 0xcb, 0xbb, 0xb3, 0xb2, 0xb5, 0xbf, 0xcd, 0xda, 0xd4, 0xc0, 0xb5, 0xae, 0xae, 0xb2, 0xb6, 0xbc, 0xc1, 0xc5, + 0xc8, 0xd0, 0xe2, 0xf6, 0x0a, 0x0c, 0xfc, 0xed, 0xdf, 0xd9, 0xda, 0xe1, 0xdf, 0xd3, 0xca, 0xc6, 0xd2, 0xee, 0x0a, 0x12, 0x0a, 0xfc, + 0xf3, 0xec, 0xe5, 0xe4, 0xf2, 0x04, 0x0a, 0x06, 0xfd, 0xfa, 0x02, 0x11, 0x1b, 0x1b, 0x15, 0x0c, 0x04, 0x00, 0x00, 0x0a, 0x1b, 0x27, + 0x2a, 0x28, 0x27, 0x2d, 0x34, 0x3a, 0x3e, 0x42, 0x3c, 0x2f, 0x26, 0x24, 0x29, 0x2f, 0x35, 0x38, 0x39, 0x38, 0x39, 0x3a, 0x3b, 0x3d, + 0x3e, 0x3e, 0x40, 0x43, 0x48, 0x4d, 0x50, 0x4e, 0x4e, 0x4f, 0x50, 0x4f, 0x50, 0x58, 0x64, 0x6b, 0x69, 0x64, 0x60, 0x5f, 0x61, 0x65, + 0x65, 0x63, 0x61, 0x5e, 0x61, 0x67, 0x6d, 0x6d, 0x69, 0x65, 0x65, 0x66, 0x65, 0x61, 0x5d, 0x5e, 0x63, 0x68, 0x68, 0x65, 0x61, 0x5f, + 0x60, 0x61, 0x62, 0x64, 0x65, 0x63, 0x5f, 0x5b, 0x5a, 0x5d, 0x62, 0x67, 0x6a, 0x6b, 0x6b, 0x6a, 0x64, 0x5d, 0x51, 0x47, 0x44, 0x48, + 0x53, 0x60, 0x6b, 0x6c, 0x66, 0x5a, 0x4a, 0x41, 0x40, 0x44, 0x49, 0x4e, 0x51, 0x53, 0x51, 0x52, 0x54, 0x51, 0x4b, 0x44, 0x40, 0x43, + 0x46, 0x46, 0x42, 0x3e, 0x3b, 0x39, 0x39, 0x37, 0x34, 0x32, 0x32, 0x34, 0x36, 0x37, 0x35, 0x30, 0x2b, 0x29, 0x24, 0x1f, 0x1a, 0x18, + 0x18, 0x1a, 0x1e, 0x22, 0x26, 0x28, 0x28, 0x25, 0x1f, 0x18, 0x0d, 0x03, 0xfa, 0xf3, 0xf2, 0xf8, 0x01, 0x0a, 0x0e, 0x0d, 0x08, 0x04, + 0xff, 0xf8, 0xf5, 0xf2, 0xf0, 0xee, 0xeb, 0xe8, 0xe5, 0xe4, 0xe4, 0xe6, 0xe7, 0xe4, 0xe1, 0xde, 0xdd, 0xdb, 0xd8, 0xd7, 0xd6, 0xd6, + 0xd4, 0xd1, 0xce, 0xcc, 0xc9, 0xc7, 0xc5, 0xc5, 0xc5, 0xc3, 0xc1, 0xc0, 0xbe, 0xba, 0xb7, 0xb4, 0xb4, 0xb4, 0xb3, 0xb3, 0xb3, 0xb4, + 0xb3, 0xb2, 0xb0, 0xac, 0xa9, 0xa6, 0xa4, 0xa0, 0x9e, 0x9f, 0xa2, 0xa5, 0xa6, 0xa4, 0xa0, 0x9c, 0x9b, 0x9b, 0x9c, 0x9a, 0x96, 0x92, + 0x90, 0x90, 0x8f, 0x8f, 0x8f, 0x91, 0x92, 0x91, 0x8f, 0x8d, 0x8c, 0x8b, 0x8a, 0x8b, 0x8c, 0x8e, 0x8d, 0x8b, 0x88, 0x85, 0x84, 0x84, + 0x83, 0x82, 0x83, 0x85, 0x87, 0x88, 0x88, 0x87, 0x84, 0x82, 0x81, 0x81, 0x80, 0x80, 0x80, 0x81, 0x81, 0x82, 0x82, 0x83, 0x84, 0x86, + 0x87, 0x86, 0x83, 0x82, 0x81, 0x80, 0x80, 0x80, 0x80, 0x82, 0x84, 0x85, 0x86, 0x86, 0x85, 0x86, 0x85, 0x84, 0x83, 0x83, 0x83, 0x83, + 0x83, 0x83, 0x83, 0x84, 0x86, 0x88, 0x89, 0x89, 0x88, 0x86, 0x85, 0x85, 0x85, 0x86, 0x88, 0x89, 0x89, 0x89, 0x89, 0x89, 0x8a, 0x8b, + 0x8c, 0x8e, 0x8f, 0x8f, 0x90, 0x90, 0x91, 0x91, 0x91, 0x91, 0x90, 0x91, 0x92, 0x94, 0x96, 0x99, 0x9b, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, + 0x9c, 0x9d, 0x9d, 0x9d, 0x9d, 0x9e, 0xa0, 0xa3, 0xa6, 0xa9, 0xac, 0xaf, 0xb2, 0xb3, 0xb2, 0xb0, 0xac, 0xa9, 0xa8, 0xa9, 0xac, 0xb1, + 0xb7, 0xbe, 0xc4, 0xc8, 0xc9, 0xc6, 0xc2, 0xbe, 0xbb, 0xbb, 0xbc, 0xbd, 0xbf, 0xc1, 0xc5, 0xc8, 0xcc, 0xd0, 0xd2, 0xd2, 0xd3, 0xd4, + 0xd6, 0xd8, 0xda, 0xdb, 0xdc, 0xdb, 0xdc, 0xdd, 0xde, 0xe1, 0xe4, 0xe7, 0xe9, 0xe9, 0xe9, 0xe8, 0xea, 0xed, 0xf1, 0xf3, 0xf4, 0xf3, + 0xf4, 0xf6, 0xf9, 0xfd, 0xff, 0x00, 0x00, 0x00, 0x01, 0x03, 0x05, 0x07, 0x0a, 0x0b, 0x0b, 0x0b, 0x0c, 0x0d, 0x0f, 0x10, 0x11, 0x11, + 0x12, 0x13, 0x15, 0x17, 0x1a, 0x1c, 0x1e, 0x20, 0x23, 0x26, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2b, 0x29, 0x28, 0x29, 0x2a, 0x2e, 0x31, + 0x34, 0x34, 0x35, 0x36, 0x37, 0x37, 0x38, 0x39, 0x3a, 0x3c, 0x3e, 0x41, 0x44, 0x47, 0x48, 0x47, 0x46, 0x45, 0x45, 0x45, 0x46, 0x48, + 0x4a, 0x4b, 0x4a, 0x49, 0x49, 0x4a, 0x4c, 0x4d, 0x50, 0x54, 0x58, 0x5a, 0x5a, 0x59, 0x57, 0x56, 0x56, 0x56, 0x56, 0x57, 0x58, 0x58, + 0x57, 0x56, 0x58, 0x5a, 0x5b, 0x5b, 0x5c, 0x5e, 0x60, 0x61, 0x62, 0x62, 0x61, 0x5f, 0x5e, 0x5f, 0x5f, 0x5f, 0x5f, 0x5e, 0x5e, 0x5f, + 0x61, 0x63, 0x64, 0x65, 0x65, 0x65, 0x64, 0x64, 0x63, 0x61, 0x60, 0x5f, 0x60, 0x60, 0x60, 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, + 0x66, 0x66, 0x66, 0x67, 0x66, 0x66, 0x65, 0x65, 0x65, 0x66, 0x66, 0x65, 0x63, 0x61, 0x61, 0x62, 0x63, 0x64, 0x63, 0x62, 0x62, 0x63, + 0x64, 0x64, 0x64, 0x63, 0x61, 0x60, 0x5f, 0x5e, 0x5e, 0x5e, 0x5f, 0x60, 0x62, 0x62, 0x62, 0x60, 0x5f, 0x5d, 0x5c, 0x5d, 0x5e, 0x5e, + 0x5f, 0x5f, 0x5f, 0x5f, 0x5f, 0x5f, 0x5f, 0x60, 0x60, 0x5f, 0x5d, 0x5b, 0x5a, 0x58, 0x57, 0x56, 0x56, 0x57, 0x58, 0x59, 0x5b, 0x5b, + 0x5b, 0x5b, 0x59, 0x58, 0x57, 0x58, 0x59, 0x5a, 0x5b, 0x5b, 0x59, 0x57, 0x55, 0x54, 0x53, 0x53, 0x54, 0x55, 0x56, 0x56, 0x57, 0x56, + 0x55, 0x54, 0x54, 0x54, 0x53, 0x53, 0x52, 0x51, 0x51, 0x51, 0x53, 0x54, 0x55, 0x55, 0x55, 0x55, 0x55, 0x54, 0x53, 0x51, 0x50, 0x4f, + 0x4d, 0x4d, 0x4e, 0x4e, 0x4f, 0x50, 0x50, 0x51, 0x51, 0x51, 0x51, 0x52, 0x52, 0x51, 0x52, 0x52, 0x52, 0x52, 0x52, 0x52, 0x51, 0x50, + 0x4f, 0x4f, 0x50, 0x50, 0x50, 0x50, 0x51, 0x52, 0x52, 0x53, 0x53, 0x51, 0x50, 0x50, 0x50, 0x50, 0x50, 0x51, 0x51, 0x52, 0x53, 0x53, + 0x53, 0x52, 0x51, 0x50, 0x4f, 0x4e, 0x4f, 0x50, 0x52, 0x53, 0x53, 0x53, 0x53, 0x53, 0x53, 0x53, 0x53, 0x53, 0x52, 0x51, 0x51, 0x52, + 0x51, 0x51, 0x50, 0x4f, 0x4f, 0x4f, 0x50, 0x51, 0x51, 0x51, 0x51, 0x50, 0x4f, 0x4f, 0x4e, 0x4f, 0x4f, 0x4f, 0x4e, 0x4d, 0x4d, 0x4d, + 0x4d, 0x4d, 0x4d, 0x4d, 0x4e, 0x4e, 0x4e, 0x4d, 0x4c, 0x4b, 0x49, 0x48, 0x48, 0x49, 0x49, 0x49, 0x49, 0x48, 0x48, 0x48, 0x49, 0x49, + 0x48, 0x47, 0x46, 0x45, 0x44, 0x43, 0x42, 0x43, 0x43, 0x44, 0x44, 0x43, 0x42, 0x41, 0x40, 0x40, 0x40, 0x41, 0x41, 0x41, 0x41, 0x41, + 0x41, 0x41, 0x41, 0x40, 0x3f, 0x3d, 0x3c, 0x3b, 0x3a, 0x39, 0x38, 0x38, 0x38, 0x39, 0x39, 0x39, 0x38, 0x38, 0x38, 0x37, 0x35, 0x34, + 0x34, 0x33, 0x34, 0x33, 0x33, 0x32, 0x30, 0x2f, 0x2e, 0x2e, 0x2d, 0x2c, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2a, 0x29, 0x28, 0x27, + 0x26, 0x25, 0x24, 0x23, 0x23, 0x22, 0x22, 0x21, 0x21, 0x20, 0x20, 0x20, 0x1f, 0x1f, 0x1e, 0x1d, 0x1c, 0x1b, 0x1a, 0x19, 0x18, 0x17, + 0x16, 0x16, 0x16, 0x16, 0x14, 0x12, 0x10, 0x0e, 0x0e, 0x0f, 0x10, 0x10, 0x0f, 0x0e, 0x0c, 0x0a, 0x09, 0x08, 0x07, 0x05, 0x04, 0x04, + 0x05, 0x05, 0x04, 0x02, 0x00, 0xfe, 0xfd, 0xfd, 0xfd, 0xfe, 0xff, 0xff, 0xff, 0xfd, 0xfc, 0xf9, 0xf4, 0xf1, 0xef, 0xef, 0xee, 0xee, + 0xed, 0xed, 0xec, 0xec, 0xec, 0xec, 0xeb, 0xea, 0xe8, 0xe6, 0xe4, 0xe3, 0xe1, 0xdf, 0xde, 0xdd, 0xdd, 0xdd, 0xdc, 0xdc, 0xdb, 0xdb, + 0xda, 0xd9, 0xd7, 0xd4, 0xd1, 0xd0, 0xcf, 0xcf, 0xcf, 0xcf, 0xce, 0xce, 0xcd, 0xcd, 0xcc, 0xcc, 0xca, 0xc8, 0xc5, 0xc2, 0xc0, 0xbf, + 0xbe, 0xbf, 0xc0, 0xbf, 0xbe, 0xbd, 0xbd, 0xbd, 0xbd, 0xbc, 0xba, 0xb8, 0xb6, 0xb5, 0xb3, 0xb2, 0xb1, 0xb0, 0xaf, 0xae, 0xae, 0xae, + 0xaf, 0xae, 0xad, 0xac, 0xaa, 0xa9, 0xa7, 0xa6, 0xa5, 0xa4, 0xa4, 0xa5, 0xa5, 0xa5, 0xa4, 0xa4, 0xa3, 0xa2, 0xa1, 0xa0, 0x9e, 0x9c, + 0x9b, 0x9b, 0x9b, 0x9c, 0x9e, 0x9f, 0x9f, 0x9e, 0x9d, 0x9b, 0x99, 0x97, 0x96, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, + 0x94, 0x93, 0x92, 0x92, 0x92, 0x92, 0x91, 0x91, 0x91, 0x90, 0x90, 0x90, 0x8f, 0x8f, 0x8f, 0x8f, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8d, + 0x8d, 0x8d, 0x8d, 0x8d, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, + 0x8b, 0x8c, 0x8b, 0x8a, 0x89, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, + 0x8a, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8e, 0x8d, 0x8d, 0x8d, 0x8c, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8c, 0x8c, 0x8d, 0x8d, 0x8e, 0x8f, + 0x90, 0x91, 0x91, 0x92, 0x92, 0x92, 0x91, 0x91, 0x92, 0x93, 0x93, 0x94, 0x94, 0x94, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9a, + 0x9a, 0x9b, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f, 0x9f, 0xa0, 0xa0, 0xa1, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa8, 0xa8, 0xa9, + 0xaa, 0xab, 0xac, 0xad, 0xaf, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb7, 0xb7, 0xb8, 0xb8, 0xb9, 0xba, 0xbc, 0xbf, 0xc1, 0xc3, + 0xc4, 0xc5, 0xc5, 0xc6, 0xc7, 0xc7, 0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xce, 0xcf, 0xd0, 0xd1, 0xd3, 0xd4, 0xd6, 0xd8, 0xda, 0xdb, 0xdc, + 0xdd, 0xde, 0xe0, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe6, 0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xee, 0xf0, 0xf2, 0xf4, 0xf5, 0xf7, 0xf8, 0xf9, + 0xfa, 0xfb, 0xfc, 0xfc, 0xfd, 0xff, 0x00, 0x02, 0x03, 0x04, 0x05, 0x06, 0x08, 0x09, 0x0b, 0x0d, 0x0e, 0x10, 0x11, 0x12, 0x12, 0x13, + 0x15, 0x16, 0x18, 0x1a, 0x1b, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x22, 0x23, 0x24, 0x26, 0x27, 0x28, 0x29, 0x29, 0x29, 0x2a, 0x2c, + 0x2d, 0x2f, 0x31, 0x33, 0x34, 0x35, 0x35, 0x36, 0x36, 0x37, 0x37, 0x38, 0x3a, 0x3b, 0x3c, 0x3d, 0x3d, 0x3e, 0x3f, 0x40, 0x41, 0x43, + 0x44, 0x45, 0x45, 0x46, 0x46, 0x47, 0x48, 0x48, 0x49, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x4f, 0x50, 0x51, 0x52, 0x53, 0x53, 0x54, 0x54, + 0x55, 0x55, 0x56, 0x56, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5a, 0x5b, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f, 0x60, 0x5f, 0x5f, 0x5e, 0x5e, 0x5e, + 0x5f, 0x5f, 0x60, 0x61, 0x61, 0x62, 0x62, 0x63, 0x63, 0x64, 0x64, 0x65, 0x65, 0x65, 0x65, 0x65, 0x65, 0x64, 0x64, 0x64, 0x64, 0x64, + 0x65, 0x65, 0x66, 0x67, 0x68, 0x68, 0x69, 0x68, 0x68, 0x68, 0x67, 0x66, 0x66, 0x65, 0x65, 0x65, 0x66, 0x66, 0x67, 0x67, 0x68, 0x68, + 0x67, 0x67, 0x66, 0x66, 0x65, 0x64, 0x64, 0x64, 0x64, 0x65, 0x65, 0x65, 0x65, 0x64, 0x64, 0x64, 0x63, 0x63, 0x63, 0x62, 0x61, 0x61, + 0x60, 0x60, 0x60, 0x61, 0x61, 0x60, 0x60, 0x5f, 0x5f, 0x5e, 0x5e, 0x5d, 0x5c, 0x5c, 0x5c, 0x5b, 0x5b, 0x5b, 0x5b, 0x5b, 0x5a, 0x59, + 0x59, 0x58, 0x57, 0x57, 0x56, 0x55, 0x54, 0x54, 0x53, 0x54, 0x54, 0x53, 0x52, 0x51, 0x50, 0x4f, 0x4f, 0x4f, 0x4f, 0x4e, 0x4e, 0x4d, + 0x4c, 0x4b, 0x4a, 0x49, 0x48, 0x47, 0x47, 0x47, 0x47, 0x46, 0x45, 0x44, 0x43, 0x42, 0x41, 0x41, 0x41, 0x40, 0x3f, 0x3f, 0x3f, 0x3e, + 0x3e, 0x3c, 0x3b, 0x3a, 0x39, 0x38, 0x37, 0x37, 0x37, 0x38, 0x37, 0x36, 0x35, 0x34, 0x33, 0x32, 0x31, 0x31, 0x30, 0x2f, 0x2e, 0x2d, + 0x2d, 0x2c, 0x2a, 0x29, 0x29, 0x29, 0x29, 0x29, 0x28, 0x28, 0x26, 0x25, 0x24, 0x23, 0x22, 0x21, 0x21, 0x22, 0x23, 0x23, 0x22, 0x21, + 0x20, 0x1f, 0x1e, 0x1e, 0x1d, 0x1c, 0x1c, 0x1c, 0x1b, 0x1b, 0x1a, 0x19, 0x18, 0x18, 0x18, 0x18, 0x17, 0x17, 0x17, 0x16, 0x16, 0x14, + 0x13, 0x12, 0x11, 0x10, 0x11, 0x11, 0x12, 0x12, 0x11, 0x10, 0x0f, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0d, 0x0c, 0x0b, 0x0a, + 0x0a, 0x0a, 0x09, 0x09, 0x09, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x07, 0x06, 0x05, 0x05, 0x05, 0x05, 0x05, 0x04, + 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x03, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x02, 0x02, 0x02, 0x01, 0x01, 0x01, 0x01, + 0x01, 0x00, 0x00, 0x01, 0x01, 0x01, 0x02, 0x03, 0x03, 0x04, 0x04, 0x04, 0x05, 0x06, 0x06, 0x05, 0x04, 0x03, 0x02, 0x03, 0x03, 0x04, + 0x05, 0x06, 0x06, 0x07, 0x07, 0x07, 0x06, 0x06, 0x06, 0x06, 0x06, 0x07, 0x08, 0x09, 0x08, 0x08, 0x07, 0x07, 0x08, 0x08, 0x09, 0x0a, + 0x0c, 0x0c, 0x0d, 0x0d, 0x0e, 0x0e, 0x0d, 0x0d, 0x0d, 0x0c, 0x0d, 0x0f, 0x11, 0x11, 0x11, 0x11, 0x10, 0x10, 0x0f, 0x10, 0x10, 0x11, + 0x12, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x17, 0x17, 0x16, 0x16, 0x17, 0x18, 0x18, 0x18, 0x19, 0x19, 0x1b, 0x1b, 0x1c, 0x1c, 0x1b, + 0x1b, 0x1b, 0x1b, 0x1c, 0x1e, 0x1e, 0x1e, 0x1e, 0x1d, 0x1c, 0x1c, 0x1d, 0x1e, 0x20, 0x22, 0x23, 0x23, 0x23, 0x23, 0x23, 0x22, 0x22, + 0x22, 0x22, 0x24, 0x24, 0x25, 0x25, 0x24, 0x24, 0x24, 0x24, 0x24, 0x25, 0x26, 0x25, 0x25, 0x25, 0x25, 0x25, 0x26, 0x28, 0x29, 0x2a, + 0x2b, 0x2b, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x29, 0x28, 0x28, 0x29, 0x2a, 0x2c, 0x2c, 0x2c, 0x2d, 0x2d, 0x2c, 0x2c, 0x2d, 0x2d, 0x2c, + 0x2c, 0x2c, 0x2c, 0x2c, 0x2d, 0x2d, 0x2e, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2e, 0x2d, 0x2d, 0x2c, 0x2b, 0x2b, + 0x2a, 0x2a, 0x2a, 0x2b, 0x2b, 0x2b, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2b, 0x2a, 0x2a, 0x29, 0x2a, 0x2a, 0x29, 0x29, 0x28, 0x28, 0x27, + 0x26, 0x26, 0x26, 0x26, 0x25, 0x25, 0x25, 0x25, 0x25, 0x24, 0x24, 0x24, 0x23, 0x23, 0x22, 0x21, 0x20, 0x20, 0x21, 0x20, 0x20, 0x1f, + 0x1f, 0x1e, 0x1e, 0x1e, 0x1d, 0x1d, 0x1d, 0x1d, 0x1c, 0x1b, 0x1a, 0x18, 0x17, 0x17, 0x17, 0x16, 0x16, 0x15, 0x13, 0x12, 0x11, 0x10, + 0x10, 0x10, 0x10, 0x0f, 0x0e, 0x0d, 0x0d, 0x0d, 0x0c, 0x0a, 0x07, 0x06, 0x06, 0x06, 0x07, 0x07, 0x06, 0x06, 0x05, 0x05, 0x04, 0x03, + 0x02, 0x00, 0xff, 0xfe, 0xfd, 0xfd, 0xfc, 0xfc, 0xfb, 0xfa, 0xf8, 0xf7, 0xf5, 0xf4, 0xf3, 0xf3, 0xf3, 0xf2, 0xf1, 0xf1, 0xf0, 0xef, + 0xed, 0xec, 0xec, 0xeb, 0xea, 0xe9, 0xe9, 0xe8, 0xe8, 0xe6, 0xe4, 0xe2, 0xe1, 0xe1, 0xe0, 0xe0, 0xe0, 0xdf, 0xde, 0xdd, 0xdb, 0xdb, + 0xda, 0xd9, 0xd8, 0xd7, 0xd7, 0xd6, 0xd5, 0xd3, 0xd1, 0xcf, 0xce, 0xcd, 0xcd, 0xcd, 0xcd, 0xcc, 0xcc, 0xcb, 0xcb, 0xca, 0xc9, 0xc8, + 0xc7, 0xc6, 0xc5, 0xc5, 0xc4, 0xc3, 0xc2, 0xc1, 0xc0, 0xbf, 0xbe, 0xbe, 0xbe, 0xbe, 0xbd, 0xbc, 0xba, 0xb9, 0xb8, 0xb8, 0xb7, 0xb7, + 0xb7, 0xb7, 0xb7, 0xb6, 0xb5, 0xb4, 0xb3, 0xb3, 0xb3, 0xb2, 0xb2, 0xb1, 0xb1, 0xb0, 0xb0, 0xaf, 0xae, 0xad, 0xad, 0xac, 0xac, 0xac, + 0xac, 0xab, 0xab, 0xaa, 0xa9, 0xa9, 0xa8, 0xa7, 0xa6, 0xa6, 0xa6, 0xa7, 0xa7, 0xa6, 0xa5, 0xa4, 0xa4, 0xa4, 0xa4, 0xa3, 0xa3, 0xa2, + 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa1, 0xa1, 0xa0, 0xa0, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0xa0, 0xa1, 0xa1, 0xa1, 0xa0, 0x9f, 0x9f, + 0x9e, 0x9e, 0x9f, 0x9f, 0x9f, 0x9f, 0x9e, 0x9e, 0x9e, 0x9e, 0x9f, 0x9f, 0xa0, 0xa1, 0xa1, 0xa2, 0xa2, 0xa1, 0xa1, 0xa0, 0xa0, 0xa0, + 0xa1, 0xa1, 0xa2, 0xa1, 0xa1, 0xa0, 0xa0, 0xa1, 0xa2, 0xa2, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa4, 0xa5, 0xa6, 0xa6, 0xa6, + 0xa7, 0xa8, 0xa9, 0xa8, 0xa8, 0xa8, 0xa8, 0xa9, 0xaa, 0xaa, 0xab, 0xaa, 0xaa, 0xaa, 0xab, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xaf, 0xb0, + 0xb0, 0xb1, 0xb1, 0xb1, 0xb1, 0xb2, 0xb2, 0xb3, 0xb4, 0xb4, 0xb5, 0xb5, 0xb6, 0xb6, 0xb7, 0xb8, 0xb9, 0xb9, 0xba, 0xba, 0xba, 0xbb, + 0xbb, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xc0, 0xc1, 0xc1, 0xc1, 0xc1, 0xc2, 0xc2, 0xc3, 0xc4, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xc9, 0xca, + 0xca, 0xcb, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xcf, 0xd0, 0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd4, 0xd6, 0xd7, 0xd8, 0xd9, 0xd9, 0xd9, 0xd9, + 0xda, 0xdb, 0xdc, 0xdc, 0xdd, 0xdd, 0xde, 0xdf, 0xe0, 0xe2, 0xe3, 0xe3, 0xe4, 0xe5, 0xe5, 0xe6, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xeb, + 0xeb, 0xec, 0xec, 0xed, 0xee, 0xef, 0xef, 0xf0, 0xf1, 0xf2, 0xf2, 0xf3, 0xf4, 0xf4, 0xf5, 0xf5, 0xf6, 0xf6, 0xf7, 0xf7, 0xf8, 0xf9, + 0xfa, 0xfb, 0xfb, 0xfc, 0xfd, 0xfe, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x05, 0x06, 0x07, 0x07, 0x07, + 0x08, 0x08, 0x09, 0x09, 0x0a, 0x0b, 0x0b, 0x0b, 0x0c, 0x0d, 0x0d, 0x0e, 0x0f, 0x10, 0x10, 0x10, 0x11, 0x10, 0x10, 0x11, 0x12, 0x13, + 0x13, 0x14, 0x15, 0x15, 0x16, 0x16, 0x17, 0x18, 0x18, 0x18, 0x17, 0x17, 0x18, 0x18, 0x19, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1d, 0x1d, + 0x1d, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1f, 0x1f, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x21, 0x22, 0x23, 0x23, 0x24, 0x24, 0x24, 0x23, + 0x23, 0x23, 0x23, 0x24, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x26, 0x26, 0x27, 0x27, 0x26, 0x26, 0x27, 0x27, 0x27, + 0x27, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x27, 0x27, 0x28, 0x28, 0x27, 0x27, 0x26, 0x27, 0x27, 0x27, 0x26, 0x26, 0x26, 0x26, 0x26, + 0x26, 0x26, 0x25, 0x25, 0x25, 0x25, 0x26, 0x26, 0x26, 0x26, 0x25, 0x24, 0x23, 0x23, 0x24, 0x24, 0x24, 0x24, 0x24, 0x23, 0x23, 0x22, + 0x22, 0x21, 0x20, 0x20, 0x21, 0x21, 0x21, 0x21, 0x20, 0x20, 0x20, 0x1f, 0x1f, 0x1f, 0x1e, 0x1e, 0x1d, 0x1d, 0x1d, 0x1e, 0x1e, 0x1d, + 0x1d, 0x1c, 0x1c, 0x1c, 0x1c, 0x1b, 0x1a, 0x19, 0x18, 0x17, 0x17, 0x18, 0x18, 0x18, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x16, 0x15, + 0x14, 0x13, 0x12, 0x12, 0x12, 0x12, 0x11, 0x10, 0x0f, 0x0e, 0x0e, 0x0e, 0x0e, 0x0d, 0x0d, 0x0c, 0x0c, 0x0d, 0x0d, 0x0d, 0x0c, 0x0c, + 0x0b, 0x0a, 0x09, 0x09, 0x08, 0x07, 0x06, 0x05, 0x05, 0x05, 0x05, 0x04, 0x03, 0x03, 0x03, 0x03, 0x03, 0x02, 0x01, 0x00, 0xff, 0xff, + 0x00, 0x00, 0x00, 0x00, 0xff, 0xfd, 0xfd, 0xfc, 0xfc, 0xfb, 0xfb, 0xfb, 0xfb, 0xfa, 0xfa, 0xf9, 0xf8, 0xf7, 0xf6, 0xf6, 0xf6, 0xf6, + 0xf6, 0xf5, 0xf5, 0xf4, 0xf3, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf1, 0xf0, 0xef, 0xee, 0xed, 0xed, 0xed, 0xed, 0xed, 0xed, 0xed, + 0xec, 0xeb, 0xeb, 0xeb, 0xea, 0xea, 0xea, 0xe9, 0xe9, 0xe8, 0xe7, 0xe6, 0xe5, 0xe4, 0xe4, 0xe4, 0xe4, 0xe3, 0xe3, 0xe3, 0xe3, 0xe3, + 0xe4, 0xe4, 0xe4, 0xe3, 0xe2, 0xe0, 0xdf, 0xde, 0xde, 0xde, 0xde, 0xdf, 0xdf, 0xde, 0xde, 0xdd, 0xdc, 0xdb, 0xdb, 0xdb, 0xdb, 0xdc, + 0xdc, 0xdb, 0xda, 0xda, 0xd9, 0xd9, 0xd9, 0xd9, 0xd9, 0xda, 0xd9, 0xd9, 0xd8, 0xd7, 0xd6, 0xd6, 0xd6, 0xd6, 0xd6, 0xd6, 0xd6, 0xd6, + 0xd5, 0xd4, 0xd4, 0xd4, 0xd4, 0xd4, 0xd4, 0xd4, 0xd4, 0xd4, 0xd5, 0xd5, 0xd5, 0xd5, 0xd4, 0xd3, 0xd2, 0xd2, 0xd2, 0xd3, 0xd3, 0xd3, + 0xd3, 0xd3, 0xd3, 0xd2, 0xd2, 0xd3, 0xd2, 0xd2, 0xd1, 0xd1, 0xd1, 0xd2, 0xd1, 0xd1, 0xd2, 0xd2, 0xd3, 0xd3, 0xd3, 0xd2, 0xd2, 0xd1, + 0xd1, 0xd1, 0xd2, 0xd3, 0xd3, 0xd4, 0xd4, 0xd3, 0xd3, 0xd3, 0xd3, 0xd3, 0xd3, 0xd3, 0xd3, 0xd3, 0xd4, 0xd4, 0xd5, 0xd5, 0xd6, 0xd6, + 0xd6, 0xd6, 0xd6, 0xd6, 0xd6, 0xd6, 0xd6, 0xd7, 0xd7, 0xd7, 0xd7, 0xd8, 0xd8, 0xd9, 0xd9, 0xd9, 0xda, 0xda, 0xda, 0xda, 0xdb, 0xdc, + 0xdb, 0xdb, 0xdb, 0xdb, 0xdb, 0xdc, 0xdd, 0xdd, 0xde, 0xde, 0xde, 0xde, 0xde, 0xde, 0xdf, 0xdf, 0xe0, 0xe1, 0xe1, 0xe1, 0xe2, 0xe2, + 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe6, 0xe6, 0xe7, 0xe7, 0xe7, 0xe7, 0xe7, 0xe8, 0xe9, 0xea, 0xea, 0xea, 0xea, 0xea, 0xeb, 0xec, 0xed, + 0xee, 0xef, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf1, 0xf1, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf7, 0xf7, 0xf8, 0xf9, + 0xfa, 0xfb, 0xfb, 0xfc, 0xfc, 0xfd, 0xfd, 0xfe, 0xfe, 0xfe, 0xff, 0x00, 0x01, 0x02, 0x02, 0x02, 0x02, 0x02, 0x03, 0x04, 0x05, 0x06, + 0x07, 0x08, 0x08, 0x09, 0x0a, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0c, 0x0c, 0x0e, 0x0f, 0x10, 0x10, 0x10, 0x11, 0x11, 0x12, 0x12, 0x13, + 0x13, 0x14, 0x15, 0x16, 0x17, 0x17, 0x18, 0x18, 0x18, 0x18, 0x19, 0x1a, 0x1b, 0x1b, 0x1c, 0x1c, 0x1c, 0x1c, 0x1d, 0x1d, 0x1d, 0x1e, + 0x1f, 0x20, 0x21, 0x22, 0x22, 0x23, 0x23, 0x23, 0x23, 0x24, 0x25, 0x25, 0x25, 0x26, 0x26, 0x26, 0x26, 0x27, 0x27, 0x28, 0x28, 0x29, + 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2b, 0x2b, 0x2b, 0x2b, 0x2c, 0x2c, 0x2c, 0x2d, 0x2d, 0x2e, 0x2e, 0x2e, 0x2f, 0x2f, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x2f, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x32, 0x32, 0x31, 0x31, 0x31, 0x31, 0x32, 0x32, 0x32, 0x32, 0x32, + 0x32, 0x33, 0x33, 0x33, 0x34, 0x33, 0x33, 0x33, 0x33, 0x33, 0x34, 0x34, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x32, + 0x32, 0x32, 0x33, 0x33, 0x34, 0x34, 0x34, 0x34, 0x33, 0x32, 0x32, 0x31, 0x31, 0x31, 0x32, 0x32, 0x33, 0x33, 0x33, 0x32, 0x31, 0x31, + 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2f, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, + 0x2d, 0x2d, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2b, 0x2b, 0x2a, 0x2a, 0x2a, 0x29, 0x29, 0x28, 0x28, 0x28, 0x27, 0x27, 0x27, + 0x27, 0x27, 0x27, 0x26, 0x26, 0x26, 0x26, 0x26, 0x25, 0x24, 0x23, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x21, 0x21, 0x21, 0x21, + 0x21, 0x20, 0x1f, 0x1f, 0x1e, 0x1e, 0x1d, 0x1d, 0x1c, 0x1c, 0x1c, 0x1c, 0x1b, 0x1b, 0x1c, 0x1c, 0x1b, 0x1b, 0x1a, 0x1a, 0x19, 0x18, + 0x18, 0x17, 0x16, 0x16, 0x16, 0x16, 0x15, 0x15, 0x15, 0x15, 0x14, 0x14, 0x14, 0x13, 0x13, 0x13, 0x12, 0x11, 0x11, 0x11, 0x10, 0x10, + 0x0f, 0x0f, 0x0f, 0x0e, 0x0d, 0x0d, 0x0c, 0x0c, 0x0c, 0x0b, 0x0a, 0x0a, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x08, 0x08, 0x07, 0x07, 0x07, + 0x06, 0x06, 0x06, 0x05, 0x05, 0x04, 0x04, 0x03, 0x03, 0x02, 0x02, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xfe, 0xfe, + 0xfd, 0xfd, 0xfc, 0xfc, 0xfc, 0xfb, 0xfb, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xf9, 0xf9, 0xf8, 0xf7, 0xf6, 0xf6, 0xf5, 0xf4, 0xf4, 0xf4, + 0xf4, 0xf3, 0xf3, 0xf3, 0xf3, 0xf2, 0xf2, 0xf1, 0xf0, 0xef, 0xef, 0xef, 0xef, 0xf0, 0xef, 0xef, 0xee, 0xed, 0xed, 0xec, 0xec, 0xec, + 0xec, 0xec, 0xec, 0xeb, 0xeb, 0xea, 0xea, 0xe9, 0xe8, 0xe8, 0xe7, 0xe7, 0xe7, 0xe6, 0xe6, 0xe6, 0xe5, 0xe5, 0xe5, 0xe5, 0xe5, 0xe5, + 0xe5, 0xe4, 0xe4, 0xe4, 0xe4, 0xe3, 0xe3, 0xe3, 0xe2, 0xe1, 0xe1, 0xe0, 0xe0, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xde, 0xde, 0xde, 0xde, + 0xde, 0xde, 0xde, 0xdd, 0xdc, 0xdb, 0xdb, 0xda, 0xda, 0xda, 0xda, 0xda, 0xda, 0xda, 0xda, 0xda, 0xda, 0xd9, 0xd8, 0xd7, 0xd7, 0xd7, + 0xd7, 0xd7, 0xd7, 0xd7, 0xd7, 0xd6, 0xd5, 0xd5, 0xd4, 0xd4, 0xd4, 0xd4, 0xd4, 0xd3, 0xd3, 0xd3, 0xd3, 0xd3, 0xd3, 0xd3, 0xd2, 0xd2, + 0xd2, 0xd2, 0xd2, 0xd1, 0xd1, 0xd1, 0xd0, 0xd0, 0xd0, 0xd0, 0xd0, 0xcf, 0xcf, 0xcf, 0xcf, 0xce, 0xce, 0xce, 0xce, 0xce, 0xce, 0xce, + 0xcd, 0xcd, 0xcd, 0xcc, 0xcc, 0xcd, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcd, 0xcd, 0xcc, 0xcc, 0xcb, 0xca, 0xca, 0xca, 0xca, + 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xcb, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xc9, 0xc9, 0xc9, 0xc9, + 0xca, 0xca, 0xc9, 0xc9, 0xc9, 0xc9, 0xc9, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xcb, 0xcb, 0xcb, 0xca, 0xca, 0xca, 0xcb, 0xcc, + 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcb, 0xcb, 0xcb, 0xcb, 0xcc, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xce, 0xcf, 0xcf, + 0xce, 0xce, 0xcf, 0xcf, 0xcf, 0xcf, 0xcf, 0xd0, 0xd1, 0xd1, 0xd2, 0xd2, 0xd2, 0xd2, 0xd2, 0xd2, 0xd2, 0xd2, 0xd2, 0xd3, 0xd4, 0xd4, + 0xd4, 0xd3, 0xd4, 0xd4, 0xd4, 0xd5, 0xd5, 0xd6, 0xd6, 0xd7, 0xd7, 0xd8, 0xd8, 0xd7, 0xd8, 0xd8, 0xd8, 0xd9, 0xd9, 0xd9, 0xda, 0xda, + 0xda, 0xda, 0xdb, 0xdb, 0xdb, 0xdc, 0xdc, 0xdd, 0xdd, 0xde, 0xde, 0xde, 0xde, 0xdf, 0xdf, 0xe0, 0xe1, 0xe1, 0xe1, 0xe1, 0xe1, 0xe1, + 0xe2, 0xe2, 0xe3, 0xe3, 0xe4, 0xe4, 0xe5, 0xe5, 0xe5, 0xe5, 0xe5, 0xe5, 0xe6, 0xe6, 0xe7, 0xe8, 0xe8, 0xe8, 0xe9, 0xe9, 0xea, 0xeb, + 0xeb, 0xec, 0xec, 0xec, 0xec, 0xec, 0xec, 0xed, 0xee, 0xef, 0xef, 0xef, 0xef, 0xef, 0xf0, 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf4, 0xf4, + 0xf4, 0xf5, 0xf5, 0xf5, 0xf6, 0xf6, 0xf7, 0xf8, 0xf8, 0xf9, 0xf9, 0xfa, 0xfa, 0xfa, 0xfa, 0xfb, 0xfb, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, + 0xfd, 0xfd, 0xfe, 0xff, 0x00, 0x00, 0x01, 0x01, 0x01, 0x02, 0x02, 0x03, 0x04, 0x04, 0x05, 0x05, 0x05, 0x06, 0x06, 0x06, 0x07, 0x07, + 0x07, 0x07, 0x07, 0x08, 0x08, 0x08, 0x09, 0x09, 0x0a, 0x0a, 0x0b, 0x0b, 0x0b, 0x0b, 0x0c, 0x0c, 0x0c, 0x0d, 0x0d, 0x0d, 0x0e, 0x0e, + 0x0e, 0x0e, 0x0e, 0x0f, 0x0f, 0x0f, 0x0f, 0x10, 0x10, 0x10, 0x10, 0x10, 0x11, 0x11, 0x12, 0x12, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, + 0x13, 0x13, 0x14, 0x14, 0x14, 0x15, 0x15, 0x14, 0x14, 0x15, 0x15, 0x15, 0x16, 0x16, 0x16, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, + 0x17, 0x17, 0x18, 0x18, 0x18, 0x18, 0x18, 0x17, 0x17, 0x18, 0x18, 0x18, 0x18, 0x18, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, + 0x19, 0x1a, 0x1a, 0x1a, 0x1a, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x1a, 0x1a, 0x1a, 0x19, 0x19, 0x19, 0x1a, 0x1a, 0x1a, 0x1a, + 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, + 0x18, 0x18, 0x18, 0x19, 0x19, 0x18, 0x18, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x18, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x16, + 0x16, 0x16, 0x16, 0x16, 0x16, 0x15, 0x15, 0x15, 0x14, 0x14, 0x15, 0x15, 0x15, 0x15, 0x14, 0x14, 0x13, 0x13, 0x12, 0x12, 0x13, 0x13, + 0x13, 0x12, 0x12, 0x12, 0x12, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x10, 0x10, 0x10, 0x10, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0e, + 0x0e, 0x0d, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0a, 0x0a, 0x0a, 0x09, 0x09, 0x08, 0x08, 0x08, + 0x08, 0x08, 0x08, 0x07, 0x07, 0x07, 0x06, 0x06, 0x06, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x04, 0x03, 0x03, 0x02, 0x02, 0x02, 0x02, + 0x02, 0x02, 0x02, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xfe, 0xfe, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfc, 0xfc, + 0xfc, 0xfc, 0xfb, 0xfb, 0xfa, 0xfa, 0xf9, 0xf9, 0xf9, 0xfa, 0xfa, 0xf9, 0xf9, 0xf8, 0xf8, 0xf8, 0xf8, 0xf8, 0xf8, 0xf7, 0xf6, 0xf6, + 0xf5, 0xf5, 0xf5, 0xf4, 0xf4, 0xf4, 0xf4, 0xf3, 0xf3, 0xf3, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf1, 0xf1, 0xf0, 0xf0, 0xef, 0xef, + 0xef, 0xef, 0xef, 0xef, 0xee, 0xee, 0xee, 0xee, 0xed, 0xed, 0xed, 0xed, 0xec, 0xec, 0xeb, 0xeb, 0xea, 0xea, 0xea, 0xe9, 0xea, 0xea, + 0xea, 0xea, 0xe9, 0xe9, 0xe9, 0xe9, 0xe9, 0xe9, 0xe8, 0xe8, 0xe7, 0xe7, 0xe7, 0xe7, 0xe7, 0xe7, 0xe6, 0xe6, 0xe6, 0xe6, 0xe5, 0xe5, + 0xe4, 0xe4, 0xe3, 0xe3, 0xe3, 0xe3, 0xe2, 0xe2, 0xe2, 0xe2, 0xe2, 0xe2, 0xe2, 0xe2, 0xe2, 0xe2, 0xe2, 0xe1, 0xe1, 0xe1, 0xe1, 0xe0, + 0xe0, 0xe0, 0xe0, 0xe0, 0xe0, 0xe0, 0xe0, 0xe0, 0xe0, 0xe0, 0xe0, 0xdf, 0xdf, 0xdf, 0xdf, 0xde, 0xde, 0xde, 0xde, 0xdf, 0xdf, 0xdf, + 0xdf, 0xde, 0xde, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdc, 0xdc, 0xdc, 0xdc, 0xdc, 0xdc, 0xdc, 0xdc, 0xdd, 0xdd, 0xdd, + 0xdd, 0xdd, 0xdd, 0xdc, 0xdc, 0xdb, 0xdb, 0xdc, 0xdc, 0xdd, 0xdd, 0xdd, 0xdd, 0xdc, 0xdc, 0xdb, 0xdb, 0xdb, 0xdb, 0xdb, 0xdb, 0xdc, + 0xdc, 0xdc, 0xdc, 0xdc, 0xdc, 0xdc, 0xdc, 0xdc, 0xdc, 0xdc, 0xdc, 0xdc, 0xdc, 0xdc, 0xdc, 0xdc, 0xdc, 0xdc, 0xdc, 0xdc, 0xdc, 0xdd, + 0xdd, 0xdd, 0xdc, 0xdc, 0xdc, 0xdc, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xde, 0xde, 0xde, 0xde, + 0xde, 0xde, 0xde, 0xde, 0xde, 0xde, 0xdf, 0xdf, 0xe0, 0xe0, 0xe0, 0xe0, 0xe0, 0xe0, 0xdf, 0xe0, 0xe0, 0xe0, 0xe1, 0xe1, 0xe1, 0xe1, + 0xe1, 0xe0, 0xe0, 0xe1, 0xe1, 0xe2, 0xe2, 0xe2, 0xe2, 0xe2, 0xe2, 0xe3, 0xe3, 0xe3, 0xe3, 0xe3, 0xe4, 0xe4, 0xe4, 0xe4, 0xe4, 0xe4, + 0xe4, 0xe4, 0xe5, 0xe5, 0xe5, 0xe5, 0xe5, 0xe5, 0xe6, 0xe6, 0xe7, 0xe7, 0xe7, 0xe7, 0xe7, 0xe8, 0xe8, 0xe8, 0xe9, 0xe9, 0xea, 0xea, + 0xea, 0xe9, 0xe9, 0xe9, 0xea, 0xea, 0xea, 0xeb, 0xeb, 0xeb, 0xec, 0xec, 0xed, 0xed, 0xed, 0xed, 0xed, 0xed, 0xee, 0xef, 0xef, 0xf0, + 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf1, 0xf1, 0xf1, 0xf1, 0xf2, 0xf2, 0xf2, 0xf3, 0xf3, 0xf3, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, + 0xf4, 0xf4, 0xf5, 0xf5, 0xf6, 0xf7, 0xf7, 0xf8, 0xf8, 0xf8, 0xf8, 0xf9, 0xf9, 0xf9, 0xf9, 0xf9, 0xfa, 0xfa, 0xfb, 0xfb, 0xfb, 0xfb, + 0xfc, 0xfc, 0xfc, 0xfd, 0xfd, 0xfd, 0xfe, 0xfe, 0xfe, 0xfe, 0xff, 0xff, 0xff, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x02, + 0x02, 0x03, 0x03, 0x03, 0x04, 0x04, 0x05, 0x05, 0x05, 0x05, 0x06, 0x06, 0x06, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x08, 0x09, 0x09, + 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0b, 0x0b, 0x0b, 0x0c, 0x0c, 0x0d, 0x0d, 0x0d, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0f, 0x0f, 0x10, 0x10, + 0x11, 0x11, 0x11, 0x11, 0x11, 0x12, 0x12, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x14, 0x14, 0x15, 0x15, 0x16, 0x16, 0x16, 0x16, 0x17, + 0x17, 0x17, 0x17, 0x18, 0x18, 0x19, 0x19, 0x19, 0x19, 0x1a, 0x1a, 0x1b, 0x1b, 0x1b, 0x1b, 0x1c, 0x1c, 0x1c, 0x1d, 0x1d, 0x1d, 0x1e, + 0x1e, 0x1e, 0x1e, 0x1e, 0x1f, 0x1f, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x21, 0x21, 0x22, 0x22, 0x22, 0x22, 0x22, 0x23, 0x23, 0x24, + 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x26, 0x26, 0x26, 0x26, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x28, 0x28, 0x28, 0x29, 0x29, 0x29, + 0x29, 0x29, 0x29, 0x29, 0x29, 0x2a, 0x2a, 0x2a, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2d, + 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2e, 0x2e, 0x2e, 0x2f, 0x2f, 0x2f, 0x2f, 0x2e, 0x2e, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, + 0x2f, 0x2f, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, + 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x30, 0x30, 0x30, + 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, + 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2d, 0x2d, 0x2d, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2b, 0x2b, 0x2b, + 0x2b, 0x2b, 0x2b, 0x2b, 0x2a, 0x2a, 0x2a, 0x2a, 0x29, 0x29, 0x29, 0x28, 0x28, 0x28, 0x28, 0x28, 0x27, 0x27, 0x27, 0x26, 0x26, 0x25, + 0x25, 0x25, 0x25, 0x25, 0x24, 0x24, 0x23, 0x23, 0x23, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x21, 0x21, 0x20, 0x20, 0x20, 0x20, + 0x1f, 0x1e, 0x1e, 0x1d, 0x1d, 0x1d, 0x1c, 0x1c, 0x1b, 0x1b, 0x1b, 0x1b, 0x1a, 0x1a, 0x1a, 0x19, 0x19, 0x19, 0x19, 0x18, 0x18, 0x17, + 0x16, 0x16, 0x15, 0x15, 0x14, 0x14, 0x14, 0x13, 0x13, 0x13, 0x13, 0x12, 0x12, 0x12, 0x11, 0x11, 0x10, 0x10, 0x0f, 0x0f, 0x0f, 0x0f, + 0x0f, 0x0e, 0x0e, 0x0d, 0x0d, 0x0c, 0x0c, 0x0c, 0x0b, 0x0b, 0x0a, 0x0a, 0x09, 0x09, 0x08, 0x08, 0x08, 0x08, 0x07, 0x06, 0x06, 0x06, + 0x05, 0x05, 0x05, 0x05, 0x04, 0x04, 0x04, 0x03, 0x03, 0x03, 0x02, 0x02, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xfe, + 0xfe, 0xfd, 0xfd, 0xfd, 0xfc, 0xfc, 0xfc, 0xfb, 0xfb, 0xfa, 0xfa, 0xf9, 0xf9, 0xf9, 0xf8, 0xf9, 0xf9, 0xf9, 0xf8, 0xf7, 0xf7, 0xf6, + 0xf5, 0xf5, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf3, 0xf3, 0xf3, 0xf2, 0xf2, 0xf2, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf0, 0xf0, 0xef, 0xef, + 0xef, 0xef, 0xee, 0xee, 0xed, 0xed, 0xed, 0xec, 0xec, 0xec, 0xec, 0xeb, 0xeb, 0xeb, 0xeb, 0xeb, 0xea, 0xea, 0xe9, 0xe9, 0xe9, 0xe9, + 0xe9, 0xe9, 0xe8, 0xe8, 0xe7, 0xe7, 0xe7, 0xe6, 0xe6, 0xe6, 0xe6, 0xe5, 0xe5, 0xe5, 0xe5, 0xe5, 0xe5, 0xe4, 0xe4, 0xe4, 0xe4, 0xe4, + 0xe3, 0xe3, 0xe3, 0xe2, 0xe2, 0xe2, 0xe1, 0xe1, 0xe1, 0xe1, 0xe1, 0xe1, 0xe1, 0xe0, 0xe0, 0xe0, 0xe0, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, + 0xdf, 0xde, 0xde, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdc, 0xdc, 0xdc, 0xdc, 0xdb, 0xdb, 0xda, 0xda, 0xda, 0xda, 0xda, + 0xda, 0xda, 0xda, 0xd9, 0xd9, 0xd9, 0xd9, 0xd9, 0xd9, 0xd9, 0xd9, 0xd8, 0xd8, 0xd8, 0xd8, 0xd8, 0xd7, 0xd7, 0xd7, 0xd7, 0xd7, 0xd7, + 0xd6, 0xd6, 0xd6, 0xd6, 0xd6, 0xd5, 0xd5, 0xd5, 0xd5, 0xd5, 0xd5, 0xd5, 0xd5, 0xd5, 0xd5, 0xd4, 0xd4, 0xd4, 0xd4, 0xd4, 0xd4, 0xd4, + 0xd4, 0xd4, 0xd4, 0xd4, 0xd3, 0xd4, 0xd4, 0xd4, 0xd4, 0xd3, 0xd3, 0xd3, 0xd3, 0xd3, 0xd3, 0xd3, 0xd3, 0xd3, 0xd2, 0xd2, 0xd2, 0xd2, + 0xd2, 0xd2, 0xd2, 0xd2, 0xd2, 0xd2, 0xd2, 0xd2, 0xd2, 0xd1, 0xd1, 0xd1, 0xd1, 0xd2, 0xd2, 0xd2, 0xd2, 0xd2, 0xd2, 0xd1, 0xd1, 0xd1, + 0xd1, 0xd1, 0xd1, 0xd1, 0xd2, 0xd2, 0xd2, 0xd2, 0xd2, 0xd2, 0xd2, 0xd2, 0xd1, 0xd1, 0xd1, 0xd1, 0xd1, 0xd1, 0xd2, 0xd2, 0xd2, 0xd2, + 0xd2, 0xd2, 0xd2, 0xd2, 0xd2, 0xd2, 0xd2, 0xd2, 0xd2, 0xd2, 0xd2, 0xd2, 0xd2, 0xd2, 0xd2, 0xd2, 0xd2, 0xd2, 0xd3, 0xd3, 0xd3, 0xd2, + 0xd2, 0xd2, 0xd2, 0xd3, 0xd3, 0xd3, 0xd3, 0xd3, 0xd3, 0xd3, 0xd3, 0xd3, 0xd3, 0xd3, 0xd4, 0xd4, 0xd4, 0xd4, 0xd4, 0xd4, 0xd4, 0xd4, + 0xd4, 0xd4, 0xd5, 0xd5, 0xd5, 0xd5, 0xd5, 0xd5, 0xd5, 0xd5, 0xd5, 0xd6, 0xd6, 0xd6, 0xd5, 0xd5, 0xd5, 0xd6, 0xd6, 0xd6, 0xd6, 0xd7, + 0xd7, 0xd7, 0xd7, 0xd8, 0xd8, 0xd8, 0xd8, 0xd8, 0xd8, 0xd8, 0xd8, 0xd8, 0xd9, 0xd9, 0xd9, 0xd9, 0xd9, 0xd9, 0xda, 0xda, 0xda, 0xda, + 0xda, 0xda, 0xda, 0xdb, 0xdb, 0xdb, 0xdb, 0xdb, 0xdb, 0xdb, 0xdc, 0xdc, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xde, + 0xde, 0xde, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xe0, 0xe0, 0xe0, 0xe0, 0xe0, 0xe0, 0xe0, 0xe1, 0xe1, 0xe2, 0xe3, 0xe3, 0xe3, 0xe3, + 0xe3, 0xe3, 0xe4, 0xe4, 0xe4, 0xe4, 0xe5, 0xe5, 0xe5, 0xe5, 0xe6, 0xe6, 0xe6, 0xe7, 0xe7, 0xe7, 0xe8, 0xe8, 0xe8, 0xe9, 0xe9, 0xe9, + 0xe9, 0xea, 0xea, 0xea, 0xea, 0xeb, 0xeb, 0xeb, 0xec, 0xec, 0xec, 0xed, 0xed, 0xed, 0xed, 0xee, 0xee, 0xee, 0xef, 0xef, 0xf0, 0xf0, + 0xf0, 0xf1, 0xf1, 0xf1, 0xf1, 0xf2, 0xf2, 0xf3, 0xf3, 0xf3, 0xf4, 0xf4, 0xf4, 0xf5, 0xf5, 0xf5, 0xf6, 0xf6, 0xf6, 0xf7, 0xf7, 0xf7, + 0xf8, 0xf8, 0xf8, 0xf9, 0xf9, 0xfa, 0xfa, 0xfa, 0xfb, 0xfb, 0xfb, 0xfc, 0xfc, 0xfc, 0xfd, 0xfd, 0xfe, 0xfe, 0xfe, 0xff, 0xff, 0xff, + 0xff, 0x00, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x04, 0x04, 0x04, 0x05, 0x05, 0x05, 0x06, 0x06, 0x07, 0x07, 0x07, + 0x08, 0x08, 0x09, 0x09, 0x09, 0x0a, 0x0a, 0x0a, 0x0b, 0x0b, 0x0b, 0x0c, 0x0c, 0x0d, 0x0d, 0x0d, 0x0e, 0x0e, 0x0f, 0x0f, 0x0f, 0x10, + 0x10, 0x10, 0x10, 0x11, 0x11, 0x11, 0x12, 0x12, 0x12, 0x13, 0x13, 0x14, 0x14, 0x14, 0x15, 0x15, 0x15, 0x16, 0x16, 0x16, 0x17, 0x17, + 0x17, 0x18, 0x18, 0x19, 0x19, 0x19, 0x19, 0x1a, 0x1a, 0x1b, 0x1b, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1d, 0x1d, 0x1e, 0x1e, 0x1e, + 0x1e, 0x1e, 0x1f, 0x1f, 0x20, 0x20, 0x20, 0x20, 0x20, 0x21, 0x21, 0x21, 0x21, 0x21, 0x22, 0x22, 0x23, 0x23, 0x23, 0x23, 0x24, 0x24, + 0x24, 0x25, 0x25, 0x25, 0x25, 0x25, 0x26, 0x26, 0x26, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x28, 0x28, 0x28, 0x28, 0x28, 0x29, 0x29, + 0x29, 0x29, 0x29, 0x29, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, + 0x2c, 0x2c, 0x2c, 0x2c, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2e, 0x2d, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, + 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x30, 0x30, 0x2f, + 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, + 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2d, 0x2d, 0x2d, 0x2e, 0x2e, 0x2e, 0x2e, + 0x2e, 0x2e, 0x2e, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, + 0x2b, 0x2b, 0x2b, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x28, 0x28, 0x28, 0x28, 0x28, + 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x26, 0x26, 0x26, 0x26, 0x25, 0x25, 0x25, 0x25, 0x25, 0x24, 0x24, 0x24, 0x24, + 0x24, 0x24, 0x24, 0x23, 0x23, 0x23, 0x23, 0x23, 0x22, 0x22, 0x22, 0x22, 0x21, 0x21, 0x21, 0x21, 0x21, 0x20, 0x20, 0x20, 0x20, 0x20, + 0x1f, 0x1f, 0x1f, 0x1f, 0x1e, 0x1e, 0x1e, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1c, 0x1c, 0x1b, 0x1b, 0x1b, 0x1b, 0x1a, 0x1a, 0x1a, 0x1a, + 0x1a, 0x19, 0x19, 0x19, 0x19, 0x18, 0x18, 0x18, 0x17, 0x17, 0x17, 0x16, 0x16, 0x15, 0x15, 0x15, 0x15, 0x15, 0x14, 0x14, 0x13, 0x13, + 0x13, 0x13, 0x13, 0x12, 0x12, 0x12, 0x11, 0x11, 0x11, 0x11, 0x10, 0x10, 0x10, 0x0f, 0x0f, 0x0e, 0x0e, 0x0e, 0x0e, 0x0d, 0x0d, 0x0d, + 0x0c, 0x0c, 0x0c, 0x0b, 0x0b, 0x0b, 0x0a, 0x0a, 0x0a, 0x09, 0x09, 0x09, 0x08, 0x08, 0x08, 0x08, 0x07, 0x07, 0x06, 0x06, 0x06, 0x05, + 0x05, 0x04, 0x04, 0x04, 0x04, 0x03, 0x03, 0x02, 0x02, 0x02, 0x02, 0x02, 0x01, 0x01, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xfe, 0xfe, + 0xfe, 0xfd, 0xfd, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfb, 0xfb, 0xfb, 0xfa, 0xfa, 0xf9, 0xf9, 0xf9, 0xf9, 0xf8, 0xf8, 0xf8, 0xf7, 0xf7, + 0xf7, 0xf6, 0xf6, 0xf6, 0xf6, 0xf5, 0xf5, 0xf5, 0xf5, 0xf4, 0xf4, 0xf4, 0xf3, 0xf3, 0xf3, 0xf2, 0xf2, 0xf2, 0xf1, 0xf1, 0xf1, 0xf1, + 0xf1, 0xf0, 0xf0, 0xf0, 0xef, 0xef, 0xef, 0xee, 0xee, 0xee, 0xee, 0xed, 0xed, 0xed, 0xec, 0xec, 0xec, 0xec, 0xec, 0xec, 0xec, 0xeb, + 0xeb, 0xeb, 0xea, 0xea, 0xea, 0xea, 0xea, 0xe9, 0xe9, 0xe9, 0xe9, 0xe8, 0xe8, 0xe8, 0xe8, 0xe8, 0xe7, 0xe7, 0xe7, 0xe7, 0xe7, 0xe7, + 0xe7, 0xe6, 0xe6, 0xe6, 0xe5, 0xe5, 0xe5, 0xe5, 0xe5, 0xe5, 0xe5, 0xe4, 0xe4, 0xe4, 0xe4, 0xe4, 0xe3, 0xe3, 0xe3, 0xe3, 0xe3, 0xe3, + 0xe3, 0xe3, 0xe3, 0xe2, 0xe2, 0xe2, 0xe2, 0xe2, 0xe2, 0xe2, 0xe2, 0xe2, 0xe1, 0xe1, 0xe1, 0xe1, 0xe1, 0xe0, 0xe0, 0xe0, 0xe0, 0xe0, + 0xe0, 0xe0, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xde, 0xde, 0xde, 0xde, 0xde, 0xde, 0xde, 0xde, + 0xde, 0xde, 0xde, 0xde, 0xde, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdc, 0xdc, 0xdc, 0xdd, 0xdc, 0xdc, 0xdc, 0xdd, 0xdd, + 0xdd, 0xdd, 0xdd, 0xdc, 0xdc, 0xdc, 0xdb, 0xdb, 0xdb, 0xdc, 0xdc, 0xdc, 0xdc, 0xdc, 0xdb, 0xdb, 0xdb, 0xdb, 0xdb, 0xdb, 0xdb, 0xdb, + 0xdb, 0xdb, 0xdb, 0xdb, 0xdb, 0xdb, 0xdb, 0xdb, 0xdb, 0xdb, 0xdb, 0xdb, 0xdb, 0xdb, 0xdb, 0xdb, 0xdb, 0xdb, 0xdb, 0xdb, 0xdb, 0xdb, + 0xdb, 0xdb, 0xdb, 0xdb, 0xdb, 0xdb, 0xdb, 0xdb, 0xdb, 0xdb, 0xdb, 0xdb, 0xdb, 0xdb, 0xdb, 0xdb, 0xdb, 0xdb, 0xdb, 0xdb, 0xdb, 0xdb, + 0xdb, 0xdb, 0xdb, 0xdb, 0xdb, 0xdb, 0xdc, 0xdc, 0xdc, 0xdb, 0xdb, 0xdb, 0xdb, 0xdb, 0xdb, 0xdc, 0xdc, 0xdc, 0xdc, 0xdc, 0xdc, 0xdc, + 0xdc, 0xdc, 0xdc, 0xdc, 0xdc, 0xdc, 0xdc, 0xdd, 0xdd, 0xdd, 0xdd, 0xdc, 0xdc, 0xdd, 0xdd, 0xdd, 0xde, 0xde, 0xde, 0xdd, 0xdd, 0xdd, + 0xde, 0xde, 0xde, 0xde, 0xde, 0xde, 0xde, 0xde, 0xde, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, + 0xdf, 0xe0, 0xe0, 0xe0, 0xe0, 0xe0, 0xe1, 0xe1, 0xe1, 0xe1, 0xe1, 0xe1, 0xe1, 0xe2, 0xe2, 0xe2, 0xe2, 0xe2, 0xe2, 0xe2, 0xe2, 0xe2, + 0xe3, 0xe3, 0xe3, 0xe3, 0xe3, 0xe3, 0xe3, 0xe3, 0xe3, 0xe4, 0xe4, 0xe4, 0xe4, 0xe4, 0xe4, 0xe5, 0xe5, 0xe5, 0xe5, 0xe5, 0xe5, 0xe6, + 0xe6, 0xe6, 0xe6, 0xe6, 0xe6, 0xe6, 0xe7, 0xe7, 0xe7, 0xe7, 0xe7, 0xe8, 0xe8, 0xe8, 0xe8, 0xe9, 0xe9, 0xe9, 0xe9, 0xe9, 0xe9, 0xea, + 0xea, 0xea, 0xea, 0xeb, 0xeb, 0xeb, 0xeb, 0xeb, 0xeb, 0xec, 0xec, 0xec, 0xec, 0xec, 0xed, 0xed, 0xed, 0xee, 0xee, 0xee, 0xee, 0xee, + 0xef, 0xef, 0xef, 0xef, 0xf0, 0xf0, 0xf0, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf2, 0xf2, 0xf2, 0xf2, 0xf3, 0xf3, 0xf3, 0xf3, 0xf3, + 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf5, 0xf5, 0xf5, 0xf5, 0xf6, 0xf6, 0xf6, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xf8, 0xf8, 0xf8, 0xf9, + 0xf9, 0xf9, 0xf9, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfb, 0xfb, 0xfb, 0xfb, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfd, 0xfd, 0xfd, 0xfe, + 0xfe, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, + 0x03, 0x03, 0x03, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x05, 0x05, 0x05, 0x06, 0x06, 0x06, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x08, + 0x08, 0x08, 0x08, 0x08, 0x08, 0x09, 0x09, 0x09, 0x09, 0x0a, 0x0a, 0x0a, 0x0a, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0c, 0x0c, + 0x0c, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0f, 0x0f, 0x0f, 0x0f, 0x10, 0x10, 0x10, 0x10, 0x10, + 0x10, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x13, 0x13, 0x13, 0x13, 0x14, 0x14, + 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, + 0x16, 0x16, 0x16, 0x16, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, + 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x19, 0x19, 0x19, 0x18, 0x19, 0x19, 0x19, 0x19, + 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, + 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, + 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x19, 0x19, 0x19, 0x19, 0x19, 0x18, 0x18, 0x18, 0x18, + 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x17, + 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, + 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x15, + 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, + 0x14, 0x14, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, + 0x12, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, + 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, + 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, + 0x09, 0x09, 0x09, 0x09, 0x09, 0x08, 0x09, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x06, + 0x06, 0x06, 0x06, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x03, 0x03, 0x03, + 0x03, 0x03, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, + 0xfe, 0xfe, 0xfe, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfb, 0xfb, + 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xf9, 0xf9, 0xf9, 0xf9, 0xf9, 0xf9, 0xf9, + 0xf9, 0xf9, 0xf8, 0xf8, 0xf8, 0xf8, 0xf8, 0xf8, 0xf8, 0xf8, 0xf8, 0xf8, 0xf8, 0xf8, 0xf8, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, + 0xf7, 0xf7, 0xf7, 0xf6, 0xf6, 0xf6, 0xf6, 0xf6, 0xf6, 0xf6, 0xf6, 0xf6, 0xf6, 0xf6, 0xf6, 0xf6, 0xf5, 0xf5, 0xf5, 0xf5, 0xf5, 0xf5, + 0xf5, 0xf5, 0xf5, 0xf5, 0xf5, 0xf5, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf3, 0xf3, 0xf3, 0xf3, + 0xf3, 0xf3, 0xf3, 0xf3, 0xf3, 0xf3, 0xf3, 0xf3, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf1, + 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, + 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, + 0xee, 0xee, 0xee, 0xee, 0xee, 0xee, 0xee, 0xee, 0xee, 0xee, 0xee, 0xee, 0xee, 0xee, 0xee, 0xee, 0xee, 0xee, 0xee, 0xee, 0xed, 0xed, + 0xed, 0xed, 0xed, 0xed, 0xed, 0xed, 0xed, 0xed, 0xed, 0xed, 0xed, 0xed, 0xed, 0xed, 0xed, 0xed, 0xed, 0xed, 0xed, 0xed, 0xed, 0xed, + 0xed, 0xed, 0xed, 0xed, 0xed, 0xec, 0xec, 0xec, 0xec, 0xec, 0xed, 0xed, 0xed, 0xed, 0xed, 0xed, 0xed, 0xed, 0xed, 0xed, 0xed, 0xec, + 0xec, 0xed, 0xed, 0xed, 0xed, 0xed, 0xed, 0xed, 0xed, 0xed, 0xed, 0xed, 0xed, 0xed, 0xed, 0xed, 0xed, 0xed, 0xed, 0xed, 0xed, 0xed, + 0xed, 0xed, 0xed, 0xed, 0xed, 0xed, 0xed, 0xed, 0xed, 0xed, 0xed, 0xed, 0xee, 0xee, 0xee, 0xee, 0xee, 0xee, 0xee, 0xee, 0xee, 0xee, + 0xee, 0xee, 0xee, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, + 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, + 0xf2, 0xf2, 0xf2, 0xf3, 0xf3, 0xf3, 0xf3, 0xf3, 0xf3, 0xf3, 0xf3, 0xf3, 0xf3, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf5, 0xf5, + 0xf5, 0xf5, 0xf5, 0xf5, 0xf5, 0xf5, 0xf5, 0xf5, 0xf6, 0xf6, 0xf6, 0xf6, 0xf6, 0xf6, 0xf6, 0xf6, 0xf6, 0xf6, 0xf6, 0xf7, 0xf7, 0xf7, + 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xf8, 0xf8, 0xf8, 0xf8, 0xf8, 0xf8, 0xf8, 0xf8, 0xf8, 0xf8, 0xf8, 0xf8, 0xf8, 0xf9, 0xf9, 0xf9, + 0xf9, 0xf9, 0xf9, 0xf9, 0xf9, 0xf9, 0xf9, 0xf9, 0xf9, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, + 0xfa, 0xfa, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfc, + 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, + 0xfc, 0xfc, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, + 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfe, 0xfe, 0xfd, 0xfe, 0xfe, 0xfe, + 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, + 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, + 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, + 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, + 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, + 0x04, 0x04, 0x04, 0x04, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, + 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, + 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x07, 0x07, 0x07, 0x07, 0x06, + 0x06, 0x06, 0x06, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, + 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, + 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, + 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x09, 0x09, 0x08, 0x08, 0x08, 0x08, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, + 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, + 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, + 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, + 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x08, 0x08, 0x08, + 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, + 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, + 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x06, 0x06, 0x06, 0x06, + 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, + 0x06, 0x06, 0x06, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, + 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, + 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, + 0x03, 0x03, 0x03, 0x04, 0x04, 0x04, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, + 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x02, 0x02, 0x02, 0x02, 0x02, + 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, + 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, + 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, + 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xff, 0xff, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, + 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, + 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, + 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, + 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, + 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, + 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, + 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, + 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, + 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, + 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, + 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, + 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, + 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, + 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, + 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, + 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, + 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, + 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, + 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, + 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfd, 0xfd, + 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, + 0xfd, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, + 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, + 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, + 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, + 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, + 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, + 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, + 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, + 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, + 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, + 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, + 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +}; + +static const unsigned char HH_2608[7259] = { + 0x52, 0x49, 0x46, 0x46, 0x82, 0x38, 0x00, 0x00, 0x57, 0x41, 0x56, 0x45, 0x66, 0x6d, 0x74, 0x20, 0x10, 0x00, 0x00, 0x00, 0x01, 0x00, + 0x01, 0x00, 0x44, 0xac, 0x00, 0x00, 0x88, 0x58, 0x01, 0x00, 0x02, 0x00, 0x10, 0x00, 0x66, 0x61, 0x63, 0x74, 0x04, 0x00, 0x00, 0x00, + 0x1c, 0x00, 0x61, 0x61, 0x38, 0x00, 0x00, 0x01, 0x01, 0x03, 0x02, 0x01, 0x02, 0xfc, 0xff, 0x01, 0xf7, 0x08, 0x01, 0xf1, 0x08, 0x05, + 0x00, 0x07, 0xfe, 0xf9, 0xfd, 0x02, 0xfe, 0xff, 0x03, 0xf1, 0x00, 0x04, 0xec, 0xfe, 0x01, 0xf9, 0x04, 0x02, 0x07, 0x0d, 0xfa, 0xf2, + 0xf0, 0xef, 0x03, 0x09, 0x01, 0xff, 0xf6, 0xf4, 0xfc, 0x06, 0x0a, 0x0b, 0x0c, 0x0c, 0x00, 0xfa, 0x11, 0x04, 0xf5, 0xf9, 0xf8, 0x00, + 0x05, 0xfb, 0x03, 0x00, 0xfb, 0x0e, 0x0b, 0x02, 0x01, 0x11, 0x01, 0xf5, 0x11, 0x11, 0x10, 0x11, 0x07, 0x09, 0x07, 0xfa, 0xff, 0x06, + 0x01, 0xef, 0xf4, 0xfa, 0xfc, 0x0e, 0xfd, 0xf6, 0x10, 0xf4, 0xf5, 0x07, 0xf9, 0xf9, 0xfa, 0xf5, 0xf0, 0xfc, 0x05, 0xfe, 0xf3, 0xf5, + 0xfc, 0xf2, 0xff, 0x06, 0xfa, 0xe8, 0xeb, 0xf4, 0xf2, 0xfe, 0x05, 0x04, 0x03, 0xfa, 0xf8, 0xfd, 0xf7, 0xf4, 0xf6, 0xfa, 0x01, 0x05, + 0x07, 0x10, 0x12, 0x0e, 0x04, 0xf9, 0xf8, 0xff, 0x02, 0x05, 0xfb, 0xed, 0xeb, 0x09, 0x15, 0xf9, 0x1e, 0x0d, 0xeb, 0x00, 0x0d, 0xff, + 0xef, 0x02, 0x0c, 0x06, 0xf9, 0xfb, 0x08, 0x10, 0x02, 0x18, 0x1f, 0x09, 0xf7, 0x09, 0x15, 0xfb, 0xf8, 0xf5, 0xf5, 0x04, 0xf8, 0xf4, + 0x04, 0x07, 0xfb, 0xf7, 0x0e, 0xeb, 0xec, 0x0d, 0x08, 0x01, 0x07, 0x14, 0x0b, 0xf8, 0xf2, 0x09, 0xe2, 0xf1, 0x20, 0xe4, 0xee, 0x0d, + 0x09, 0xde, 0xf9, 0x1e, 0xef, 0xf4, 0xf6, 0xec, 0xff, 0x09, 0xfc, 0xe9, 0xe2, 0xfa, 0x11, 0x04, 0x00, 0xf8, 0xed, 0x08, 0x00, 0xf8, + 0x11, 0x12, 0xfd, 0xef, 0x04, 0xf5, 0xe0, 0xdd, 0x04, 0xfa, 0xf6, 0x22, 0x14, 0xeb, 0xe0, 0x2d, 0x06, 0xe5, 0x07, 0x10, 0xf1, 0xe6, + 0x16, 0x18, 0x0b, 0x06, 0x12, 0x01, 0xf9, 0x08, 0x03, 0xfb, 0xfe, 0x0a, 0x11, 0x04, 0xf5, 0x0c, 0x05, 0xf5, 0xf9, 0xfc, 0x03, 0x0e, + 0x1e, 0x0a, 0x09, 0x18, 0xf5, 0xf2, 0x04, 0x09, 0x0c, 0xff, 0xee, 0xea, 0x00, 0x08, 0xfb, 0x1f, 0x07, 0xeb, 0x04, 0x0c, 0x01, 0xfa, + 0x1b, 0xfd, 0xed, 0x08, 0xf2, 0xfd, 0x15, 0x0f, 0xf5, 0xea, 0xf3, 0xed, 0x0f, 0x10, 0xe3, 0xff, 0x10, 0x07, 0xf6, 0x0e, 0x0a, 0xec, + 0xee, 0x06, 0x02, 0xe0, 0x29, 0x1c, 0xe5, 0x01, 0xef, 0xe4, 0xf6, 0x11, 0xf8, 0xf5, 0x2a, 0x00, 0xf6, 0x0d, 0x03, 0xfb, 0xff, 0x0a, + 0xf8, 0x13, 0x17, 0xd4, 0x0b, 0x01, 0xd9, 0x32, 0x02, 0xd4, 0xf8, 0xe7, 0x00, 0x15, 0xf3, 0xfc, 0x09, 0x09, 0x01, 0x0e, 0x03, 0xde, + 0x04, 0x07, 0xf6, 0x00, 0x14, 0x08, 0xef, 0x0c, 0x01, 0xf5, 0x01, 0x07, 0xed, 0xe1, 0x10, 0xfc, 0xf4, 0x0c, 0x06, 0x08, 0x08, 0xfd, + 0xf7, 0xff, 0x05, 0xef, 0x13, 0x20, 0x04, 0xfd, 0x07, 0x10, 0x0d, 0xeb, 0xf6, 0x16, 0xfb, 0x06, 0x0d, 0xfc, 0xe2, 0xef, 0x10, 0x21, + 0xf5, 0xec, 0xfe, 0xc5, 0xf9, 0x0f, 0xd8, 0x08, 0x13, 0x00, 0x04, 0x0f, 0x04, 0xf4, 0x0f, 0xfc, 0xf0, 0x09, 0x02, 0xf8, 0xf8, 0xfe, + 0x00, 0x03, 0x08, 0x08, 0x02, 0xf7, 0xea, 0xe5, 0xf5, 0x09, 0x0e, 0x18, 0x1e, 0x12, 0x00, 0xd8, 0xce, 0xf7, 0x09, 0x09, 0x08, 0x14, + 0x16, 0xf7, 0xd2, 0x0e, 0x0a, 0xf2, 0x0c, 0xf7, 0xef, 0xff, 0x0e, 0xf6, 0xe9, 0xfb, 0xf5, 0x0c, 0x0c, 0xc7, 0x0c, 0x05, 0xc6, 0x1e, + 0x28, 0x1a, 0x21, 0xed, 0xdc, 0xf0, 0xf4, 0x0b, 0x0b, 0xf9, 0xff, 0x14, 0x12, 0xf0, 0xfb, 0xed, 0xe4, 0x0e, 0x05, 0xf7, 0xfe, 0xeb, + 0xff, 0x12, 0x05, 0xe7, 0xfd, 0x1d, 0xf4, 0xfc, 0xfa, 0xe2, 0xf5, 0x0b, 0x0d, 0xfb, 0x0f, 0xfa, 0xdd, 0x10, 0x00, 0xf5, 0x12, 0x02, + 0xf9, 0x02, 0x18, 0xe2, 0xe6, 0x14, 0xf0, 0xf2, 0xfe, 0xfb, 0x24, 0x08, 0xef, 0x37, 0xf0, 0xe3, 0x27, 0x0c, 0x11, 0x09, 0xe2, 0xe3, + 0x0b, 0x1e, 0xf1, 0x02, 0x0e, 0xfb, 0x06, 0xf8, 0xf7, 0x16, 0x00, 0xe8, 0xef, 0x23, 0xea, 0xe1, 0x21, 0xfa, 0xfc, 0x09, 0xee, 0x04, + 0xee, 0xcf, 0x0e, 0x0e, 0x02, 0x09, 0xfd, 0xf7, 0xfe, 0x00, 0x06, 0xfd, 0xf0, 0xef, 0x14, 0x1c, 0xf7, 0xfc, 0xec, 0xe9, 0x1b, 0xfe, + 0x03, 0x21, 0xe0, 0xf0, 0x10, 0xff, 0x12, 0x02, 0xf3, 0x19, 0x1d, 0x03, 0xe8, 0xfe, 0xe4, 0xea, 0x31, 0x27, 0x13, 0x0c, 0x08, 0xf7, + 0xf2, 0xfd, 0x00, 0x0e, 0x17, 0x0a, 0x19, 0x04, 0xe7, 0x0a, 0x01, 0xf1, 0xfa, 0x2a, 0x0a, 0xed, 0x2a, 0xe4, 0xf2, 0x37, 0xf4, 0x02, + 0x1e, 0x0a, 0xec, 0xf4, 0x05, 0xf7, 0x05, 0x04, 0xf8, 0x06, 0x06, 0xf9, 0xee, 0xfc, 0xf6, 0xf1, 0x0d, 0x14, 0xfe, 0xe8, 0x15, 0xf9, + 0xda, 0xee, 0x26, 0x05, 0xd3, 0x0c, 0x05, 0xec, 0xe9, 0x0a, 0x02, 0xf1, 0xf5, 0x02, 0xee, 0xd9, 0xfb, 0x09, 0x06, 0xff, 0xf6, 0xfd, + 0x06, 0xfe, 0x11, 0x05, 0xe5, 0xe6, 0xf0, 0x02, 0x11, 0xff, 0x09, 0x0f, 0xe7, 0x17, 0x17, 0xe7, 0xf1, 0x0c, 0xff, 0xd2, 0x0f, 0x1e, + 0x08, 0x10, 0x0e, 0x08, 0xfe, 0xdf, 0xff, 0x12, 0xef, 0x1a, 0x1d, 0xfb, 0xee, 0x14, 0x19, 0xf6, 0x0c, 0x0b, 0xfc, 0xf4, 0x1c, 0x10, + 0xe8, 0xe6, 0x22, 0x2e, 0xf8, 0x03, 0xe8, 0xd1, 0xe9, 0x0f, 0x1f, 0x13, 0xf9, 0xf5, 0x07, 0x13, 0xe1, 0xed, 0x09, 0xec, 0xfe, 0x0d, + 0x01, 0xdf, 0xfa, 0xfe, 0xd3, 0x16, 0x10, 0xe9, 0x00, 0x1a, 0x14, 0xf9, 0xfd, 0xfd, 0xf9, 0xf5, 0x06, 0x00, 0xf4, 0xff, 0xf4, 0xe9, + 0xee, 0xf3, 0x02, 0x07, 0xf9, 0x01, 0x01, 0xf8, 0xf8, 0xf2, 0x02, 0x1b, 0xf1, 0x04, 0x15, 0xe6, 0x04, 0x0a, 0xf5, 0x00, 0x06, 0x08, + 0x07, 0xf4, 0xf4, 0x02, 0x0a, 0xe8, 0xfc, 0x25, 0xe8, 0x01, 0x17, 0xf6, 0xe3, 0xf7, 0x11, 0x0d, 0xff, 0x03, 0x10, 0x01, 0xf8, 0x01, + 0x12, 0xfc, 0xf2, 0xf6, 0xf7, 0xf8, 0x04, 0x12, 0x13, 0xf7, 0xeb, 0x04, 0xf8, 0xf8, 0x07, 0x13, 0xf7, 0xf5, 0x10, 0x07, 0xf4, 0xf2, + 0x08, 0x0a, 0x12, 0x0e, 0xe2, 0xf9, 0x0c, 0xf7, 0x11, 0xf7, 0xe7, 0x15, 0x02, 0xfa, 0x06, 0xee, 0x02, 0x0c, 0xfa, 0x15, 0x23, 0x02, + 0xc0, 0xf9, 0x15, 0xfa, 0x12, 0x06, 0xf4, 0xf5, 0x05, 0x02, 0xf7, 0xfe, 0xf1, 0x00, 0x1b, 0xf0, 0x08, 0x12, 0xdd, 0x04, 0xfb, 0xe0, + 0x0f, 0xfe, 0xf7, 0x0f, 0x06, 0xf2, 0xee, 0x03, 0xf3, 0x05, 0x18, 0xe4, 0xfc, 0x0a, 0xee, 0x05, 0x07, 0xf7, 0xeb, 0x22, 0x0e, 0xd8, + 0x12, 0x0d, 0xfa, 0x01, 0x16, 0xfc, 0xe8, 0x0b, 0x06, 0xfb, 0xfa, 0xf7, 0x07, 0x0d, 0xfc, 0x0d, 0x09, 0xfa, 0xfe, 0xfa, 0xf9, 0xfe, + 0xff, 0x00, 0x08, 0x14, 0xf1, 0x00, 0x19, 0xeb, 0xfc, 0x07, 0xf7, 0xfa, 0x0b, 0x19, 0x16, 0xf8, 0xf6, 0x00, 0xe1, 0xf5, 0x08, 0xfd, + 0xec, 0x00, 0x17, 0x0d, 0x1e, 0x0b, 0xea, 0xfb, 0xf5, 0xf7, 0x0b, 0x01, 0xfa, 0x06, 0x1c, 0xf8, 0xf0, 0x0a, 0x00, 0x0a, 0x04, 0xe8, + 0x02, 0x0c, 0x01, 0xfd, 0x03, 0xfd, 0xf1, 0x0b, 0xf4, 0xe9, 0x0a, 0x06, 0x02, 0x02, 0x00, 0xf8, 0x07, 0x14, 0xd7, 0xe4, 0x0b, 0x0c, + 0xf7, 0xfc, 0x0d, 0x00, 0xf9, 0x05, 0x17, 0xf3, 0x06, 0x18, 0xf6, 0xf8, 0x04, 0x03, 0xf6, 0xee, 0xfb, 0x11, 0x0d, 0xf4, 0xea, 0x0b, + 0xe3, 0xf0, 0x1b, 0xfb, 0xf5, 0x05, 0x11, 0xfc, 0xf9, 0x01, 0x03, 0x04, 0xff, 0xfb, 0x0c, 0xfb, 0xf4, 0x09, 0xf8, 0xeb, 0xf7, 0x11, + 0x12, 0x03, 0xf4, 0xec, 0xf7, 0x03, 0x03, 0xf0, 0xfa, 0x12, 0x0e, 0xf9, 0xee, 0xfb, 0x0a, 0x12, 0x07, 0xf3, 0xfe, 0x08, 0x06, 0x04, + 0xf8, 0xf0, 0xf7, 0x0e, 0x01, 0xf0, 0x03, 0xf4, 0xf2, 0x06, 0x1f, 0x08, 0xf8, 0x06, 0xfd, 0xf7, 0xfd, 0x10, 0x08, 0xfc, 0xfc, 0x15, + 0x00, 0xf3, 0x0a, 0x1e, 0x01, 0xe3, 0x03, 0xf4, 0xed, 0xfd, 0x0e, 0xfb, 0xf5, 0x13, 0xf3, 0xfa, 0x13, 0xfe, 0xfd, 0xfe, 0xfb, 0x13, + 0xfc, 0xec, 0x0c, 0x0b, 0x02, 0xfe, 0x04, 0xff, 0x01, 0x0a, 0x07, 0xf6, 0xf5, 0x10, 0x06, 0xfa, 0xf8, 0xf9, 0xfb, 0xf9, 0xf7, 0x02, + 0x09, 0x00, 0xf0, 0xf0, 0x04, 0x17, 0x0d, 0x0d, 0xff, 0xe3, 0x04, 0x00, 0xe8, 0xf2, 0x05, 0x0c, 0x04, 0xfa, 0x04, 0x0f, 0x0d, 0xe3, + 0xfb, 0x17, 0xd4, 0xed, 0x0c, 0x05, 0x08, 0x0a, 0x04, 0xf8, 0x04, 0xf8, 0xea, 0x0a, 0x00, 0xff, 0x16, 0xfe, 0x0c, 0x16, 0xf3, 0x07, + 0x08, 0xf6, 0xfb, 0x01, 0xfb, 0xf1, 0x0e, 0x02, 0xf5, 0x15, 0x08, 0xf8, 0xf6, 0xfc, 0xf1, 0xee, 0xfd, 0x13, 0x07, 0xf6, 0x07, 0xfd, + 0xf5, 0xf7, 0xfe, 0xee, 0xed, 0x07, 0x13, 0x05, 0xf8, 0x05, 0x00, 0xf8, 0xf7, 0xfd, 0x05, 0xff, 0xea, 0x08, 0x07, 0xf6, 0x06, 0x10, + 0x0b, 0xff, 0xfa, 0x05, 0x01, 0xe2, 0xeb, 0x04, 0x12, 0xfb, 0x18, 0x15, 0xe8, 0x18, 0x08, 0xea, 0x09, 0xff, 0xfe, 0x0a, 0xfd, 0x08, + 0x0a, 0xf8, 0x02, 0x06, 0xfc, 0xed, 0xf4, 0xff, 0x03, 0xfc, 0x03, 0x0b, 0x0a, 0x04, 0x01, 0xff, 0xfb, 0xeb, 0xf8, 0x13, 0xed, 0x01, + 0x10, 0xf0, 0x00, 0x19, 0x13, 0xde, 0xf6, 0x00, 0xe6, 0x19, 0xfe, 0xe0, 0x05, 0x0d, 0x07, 0xfc, 0xe8, 0xfe, 0x0d, 0x02, 0xfd, 0x08, + 0x0b, 0xfc, 0xff, 0x07, 0x07, 0xfd, 0xe9, 0xee, 0x0c, 0xfa, 0xfb, 0x01, 0xf2, 0xf0, 0x02, 0x0e, 0xeb, 0x00, 0x03, 0xd7, 0x05, 0x06, + 0xf1, 0x0f, 0xf7, 0xfa, 0x1a, 0xfc, 0xf6, 0xfd, 0xfd, 0xf1, 0x07, 0x1d, 0x04, 0xfe, 0xff, 0xfd, 0x0a, 0xfc, 0xf1, 0x05, 0x0c, 0x0c, + 0x06, 0xfb, 0xf9, 0xfd, 0x02, 0x05, 0x05, 0x02, 0xfc, 0xf7, 0xfa, 0x01, 0x07, 0x03, 0x01, 0x05, 0x0b, 0x00, 0xf4, 0xf8, 0x02, 0x06, + 0x02, 0xf8, 0xff, 0xf8, 0xe3, 0x0e, 0x0f, 0xfb, 0x0b, 0xfe, 0x01, 0x12, 0x05, 0xfe, 0xfe, 0xfe, 0xf8, 0x03, 0x0d, 0xf9, 0x0d, 0x09, + 0xee, 0x19, 0x05, 0xe8, 0xf9, 0x15, 0x0a, 0xf6, 0x12, 0x05, 0xf9, 0x02, 0x10, 0xfb, 0xf0, 0x11, 0xef, 0xfc, 0x1c, 0xe9, 0xfc, 0x0b, + 0xf2, 0x0d, 0x00, 0xee, 0x06, 0x07, 0x00, 0xfb, 0xf9, 0xff, 0xfe, 0xf5, 0x0b, 0x08, 0xfb, 0x04, 0xfc, 0xf9, 0xff, 0xfe, 0x00, 0xfe, + 0xf8, 0x0d, 0x02, 0xee, 0x03, 0xf4, 0xf3, 0x08, 0x05, 0xff, 0xfd, 0xfc, 0x06, 0xfa, 0xed, 0x04, 0x0c, 0x01, 0xf7, 0x20, 0x05, 0xe2, + 0xf9, 0xf7, 0xff, 0x0f, 0x0b, 0x0d, 0x01, 0xea, 0xef, 0x04, 0x0b, 0xf9, 0x04, 0x06, 0xfa, 0xee, 0xfd, 0x02, 0xf1, 0xf3, 0x02, 0x0b, + 0xfc, 0x10, 0x0b, 0xf0, 0xf3, 0x09, 0x0f, 0xfe, 0x0b, 0xff, 0xed, 0xf4, 0xfc, 0x00, 0x04, 0x0f, 0x0d, 0xfe, 0xeb, 0x03, 0x01, 0xf0, + 0xf6, 0x0b, 0x08, 0xf2, 0xfe, 0x03, 0xfe, 0xf6, 0x00, 0x06, 0x02, 0xfb, 0xfd, 0x0b, 0x16, 0xeb, 0x00, 0x19, 0xf0, 0xfe, 0x09, 0x01, + 0xf1, 0x03, 0x07, 0xf4, 0x0c, 0x14, 0x02, 0xeb, 0xf3, 0xfe, 0xff, 0x01, 0xfe, 0x02, 0x0f, 0xf3, 0xfb, 0x0d, 0xff, 0xf5, 0x06, 0x1a, + 0xfd, 0xf6, 0xfc, 0xfe, 0x02, 0x0c, 0x0f, 0xff, 0x03, 0x00, 0xf6, 0x00, 0x06, 0x01, 0xfa, 0x0a, 0x06, 0xfa, 0x12, 0xf5, 0xe8, 0xff, + 0xf4, 0xfc, 0x08, 0x05, 0xf7, 0xfd, 0x07, 0xf1, 0x07, 0x15, 0x04, 0x06, 0x08, 0xfd, 0xe5, 0xf7, 0x05, 0xff, 0xf5, 0xfc, 0x01, 0xf9, + 0xf4, 0xf6, 0xfe, 0x07, 0xfa, 0xf8, 0x06, 0x0b, 0xf4, 0xef, 0x0f, 0xed, 0xf2, 0x0f, 0x10, 0xe6, 0xef, 0x1b, 0xe7, 0xf5, 0x12, 0x05, + 0x01, 0x04, 0x01, 0xf4, 0xf2, 0xf8, 0xfe, 0xfe, 0x02, 0x04, 0xfe, 0xff, 0x01, 0x03, 0x06, 0x0f, 0x06, 0xef, 0x04, 0xf8, 0xed, 0x0c, + 0x06, 0xfc, 0xfc, 0xfd, 0xfe, 0xfd, 0xfb, 0xf5, 0x03, 0x10, 0x01, 0xff, 0xfc, 0xf9, 0x04, 0x04, 0xf9, 0xf4, 0xfe, 0x09, 0x0d, 0x09, + 0xf9, 0xf0, 0xfa, 0x1f, 0x0d, 0xf0, 0xf8, 0x08, 0x02, 0xf1, 0xf8, 0x01, 0x05, 0x01, 0x01, 0x03, 0x04, 0xff, 0x02, 0xf9, 0xf3, 0x06, + 0x07, 0xfd, 0xf7, 0x0b, 0xfc, 0xf1, 0x12, 0xf6, 0xf6, 0x0f, 0x00, 0xfb, 0xfb, 0xfb, 0x06, 0x00, 0xfa, 0x0c, 0x0a, 0xfd, 0xf7, 0x06, + 0xfc, 0xf9, 0x0a, 0xfa, 0x05, 0x13, 0xf3, 0x0d, 0x0d, 0xed, 0xfe, 0x05, 0x04, 0x04, 0x04, 0xfd, 0xf8, 0xff, 0x03, 0x01, 0xfe, 0x04, + 0xff, 0xfe, 0x0a, 0xfe, 0xfe, 0x07, 0x04, 0xfe, 0xfc, 0x00, 0x0c, 0xfb, 0xee, 0x02, 0xff, 0x02, 0x08, 0x03, 0xf3, 0xf0, 0xfd, 0x02, + 0x05, 0x02, 0xfa, 0xfd, 0x06, 0x09, 0x00, 0x00, 0x02, 0xff, 0x01, 0x01, 0x00, 0x00, 0x00, 0xfe, 0xfb, 0xf9, 0x00, 0x03, 0xfa, 0xfd, + 0xfd, 0xff, 0x08, 0x09, 0x04, 0x00, 0xfd, 0xfd, 0x02, 0x0b, 0xf7, 0xf3, 0xff, 0x08, 0xf7, 0xf5, 0x08, 0x0e, 0xfc, 0xf1, 0xff, 0x03, + 0x00, 0xfd, 0x06, 0x0b, 0x06, 0xf8, 0xfe, 0xf7, 0xf5, 0x0b, 0xfa, 0xfa, 0x06, 0xf6, 0xf2, 0xfc, 0x06, 0x0e, 0xf7, 0xeb, 0x12, 0xfc, + 0xf3, 0x07, 0x07, 0xff, 0xfb, 0xfc, 0xfd, 0xfd, 0xfc, 0xfc, 0x05, 0x0a, 0x01, 0xed, 0xf8, 0x05, 0xfe, 0x06, 0x0c, 0x05, 0xf2, 0xfd, + 0x04, 0xfb, 0x03, 0xfe, 0xfc, 0x09, 0xfb, 0xfa, 0x04, 0x02, 0xff, 0xfe, 0x00, 0x01, 0x06, 0x07, 0x03, 0xf6, 0xfc, 0x0c, 0x02, 0x08, + 0x0a, 0xfe, 0x00, 0xf7, 0xf4, 0x0b, 0x03, 0x04, 0x0c, 0xf3, 0xf9, 0x03, 0xf9, 0x01, 0x01, 0xfe, 0x07, 0x01, 0xfc, 0xff, 0x02, 0x08, + 0x02, 0xf1, 0xf9, 0x04, 0x03, 0xf2, 0x08, 0x0c, 0xf4, 0xfb, 0x05, 0x07, 0xfb, 0x04, 0xfb, 0xed, 0xfc, 0x01, 0x01, 0x01, 0xfe, 0xfd, + 0x01, 0x09, 0xf7, 0xfc, 0x0b, 0xf8, 0xef, 0xf9, 0x09, 0x01, 0x03, 0x0a, 0x05, 0xf8, 0xf8, 0x01, 0xf4, 0x05, 0x0b, 0xf3, 0x02, 0x06, + 0x01, 0x09, 0x00, 0xfb, 0x00, 0x01, 0xfb, 0xfa, 0x06, 0x02, 0x03, 0x02, 0xf7, 0xfa, 0x04, 0x08, 0x03, 0xfd, 0xfd, 0x01, 0xfd, 0xfd, + 0x01, 0xff, 0x0c, 0x0a, 0xf9, 0x01, 0xfc, 0xf8, 0x04, 0x02, 0xfe, 0x00, 0x07, 0x02, 0xfe, 0x01, 0xfd, 0xf6, 0xf9, 0x08, 0x0b, 0x06, + 0xff, 0xf7, 0x02, 0x08, 0xfd, 0x07, 0x06, 0xfc, 0xf6, 0xf8, 0x00, 0x07, 0x01, 0x04, 0x04, 0xf9, 0xfc, 0xfd, 0xfc, 0x03, 0xfc, 0xf6, + 0xfb, 0x0d, 0x02, 0xf8, 0x08, 0xf8, 0xfa, 0x07, 0xfd, 0xf6, 0xf9, 0x00, 0xfd, 0x06, 0x0c, 0x03, 0xf4, 0xfa, 0x05, 0xf6, 0xf9, 0xfe, + 0xfb, 0x05, 0xfd, 0xfa, 0x0f, 0xff, 0xf7, 0xff, 0x04, 0xfe, 0xf8, 0xf8, 0x04, 0x01, 0xf9, 0xfd, 0x07, 0x03, 0xf6, 0x02, 0xf7, 0xf0, + 0xfa, 0x04, 0xff, 0xf8, 0xf9, 0x09, 0x03, 0xef, 0x13, 0x05, 0xef, 0xfc, 0xf5, 0xff, 0x0f, 0x01, 0x06, 0x03, 0xf3, 0xf5, 0x02, 0x06, + 0xfb, 0xfb, 0xfe, 0xff, 0xfe, 0x00, 0x06, 0x0c, 0xf7, 0x03, 0x0f, 0xf4, 0x00, 0x03, 0xf7, 0xfe, 0x03, 0x00, 0xfa, 0x01, 0x07, 0x07, + 0x04, 0xf9, 0xf4, 0xf9, 0x0c, 0xfb, 0xfa, 0x19, 0x03, 0xf2, 0xf8, 0x0c, 0xfe, 0xf8, 0x02, 0x02, 0xf8, 0xfb, 0x0c, 0x08, 0xff, 0xfc, + 0x05, 0x01, 0xff, 0x04, 0x00, 0xfe, 0xfe, 0xfd, 0x06, 0x08, 0x04, 0xfd, 0x06, 0x05, 0xf9, 0xfd, 0x05, 0x04, 0xf9, 0x02, 0x06, 0x00, + 0x00, 0xfd, 0x00, 0x09, 0x04, 0x00, 0xfa, 0xef, 0xfe, 0x07, 0x01, 0x00, 0xfc, 0xfd, 0x03, 0x03, 0x05, 0x04, 0xf9, 0xfa, 0x01, 0x04, + 0xfa, 0xfa, 0x03, 0x0a, 0xfc, 0xfe, 0x05, 0xf7, 0xff, 0x06, 0x01, 0xf8, 0x02, 0x0a, 0x00, 0xfe, 0x04, 0x05, 0xf4, 0x01, 0x08, 0xfc, + 0x01, 0xff, 0xfd, 0x01, 0x08, 0x05, 0xfd, 0xfb, 0x00, 0xfd, 0xf3, 0x00, 0x05, 0x03, 0x03, 0xf9, 0xf7, 0xfd, 0xfc, 0x03, 0x08, 0x01, + 0xf3, 0xf2, 0xfd, 0x08, 0x07, 0x00, 0xfb, 0x01, 0xfb, 0xf9, 0x05, 0xf9, 0x02, 0x0c, 0xf7, 0xfe, 0x07, 0x02, 0xfe, 0xfe, 0x03, 0x0b, + 0xf7, 0xfd, 0x0b, 0xf8, 0xfa, 0x03, 0x03, 0xfd, 0xfc, 0x01, 0x06, 0x01, 0xfc, 0xfc, 0xfc, 0x07, 0x08, 0xfb, 0x00, 0xfe, 0xf9, 0xfb, + 0x07, 0x02, 0xf7, 0x06, 0x01, 0xfc, 0x05, 0xfb, 0x01, 0x0b, 0x02, 0xfa, 0xfe, 0x05, 0xfa, 0xfa, 0x02, 0x07, 0x00, 0xfc, 0xfd, 0xff, + 0x05, 0x03, 0xfd, 0x00, 0x01, 0xfd, 0xf6, 0x01, 0x03, 0xfd, 0xfb, 0x01, 0x00, 0xfb, 0xfc, 0x02, 0x03, 0xfb, 0xf8, 0xff, 0x05, 0xf9, + 0xfd, 0x03, 0x01, 0xfd, 0xfe, 0xff, 0xfb, 0xf9, 0xfd, 0x01, 0xfe, 0xfa, 0xfc, 0x03, 0x02, 0xfc, 0xfb, 0x07, 0xf7, 0xf7, 0x08, 0xfe, + 0x00, 0x02, 0xfa, 0xf9, 0x02, 0x06, 0xfb, 0xfc, 0x02, 0x05, 0x02, 0xff, 0x00, 0x06, 0xff, 0xfc, 0xfe, 0xfc, 0x03, 0x07, 0x02, 0x04, + 0xfc, 0xfa, 0x07, 0x01, 0xfb, 0xfc, 0x05, 0xfb, 0xf9, 0x03, 0x03, 0x01, 0xfe, 0xfd, 0xff, 0x03, 0x04, 0x03, 0xff, 0x00, 0x07, 0x01, + 0x03, 0x04, 0xfd, 0xfc, 0xff, 0xff, 0xfb, 0xfb, 0x03, 0x0c, 0x07, 0xff, 0xfa, 0xf9, 0x02, 0x05, 0xfe, 0x00, 0xfb, 0xfb, 0x03, 0x04, + 0x02, 0x00, 0xfd, 0xfc, 0xfd, 0xfc, 0xf7, 0x01, 0x08, 0x00, 0x02, 0x00, 0xfc, 0x01, 0xfc, 0xfa, 0xfe, 0x02, 0x00, 0xff, 0x06, 0x01, + 0xfa, 0xf7, 0xf9, 0x00, 0x03, 0xff, 0xfd, 0xf7, 0xf7, 0x03, 0x01, 0x01, 0x03, 0xfd, 0xf5, 0xf6, 0xff, 0xfc, 0x00, 0x05, 0x03, 0xfe, + 0xfd, 0xfe, 0x00, 0xfa, 0xfa, 0x03, 0x04, 0xfd, 0xf9, 0xff, 0xfe, 0xfd, 0xfe, 0x08, 0x00, 0xfb, 0x05, 0xfe, 0xfb, 0xfe, 0xff, 0x05, + 0x06, 0x01, 0x04, 0x02, 0xff, 0xfd, 0x04, 0x02, 0xfd, 0xfd, 0x01, 0x03, 0x01, 0xf9, 0xfe, 0x03, 0xf9, 0x01, 0x04, 0x00, 0x01, 0xff, + 0xff, 0x02, 0xfc, 0x01, 0x0a, 0x06, 0xfc, 0xfc, 0x02, 0xf8, 0x01, 0x05, 0xfa, 0x06, 0x0b, 0x04, 0xfd, 0x00, 0x05, 0x04, 0xfc, 0x00, + 0x03, 0xfa, 0xff, 0x04, 0x04, 0x04, 0x02, 0x02, 0x03, 0x00, 0xf4, 0xf7, 0x0d, 0xfb, 0xfb, 0x0a, 0xfd, 0x04, 0x06, 0xfa, 0xfe, 0x01, + 0xff, 0xfb, 0x00, 0x01, 0xfe, 0x00, 0x01, 0x00, 0xff, 0xfc, 0xff, 0x00, 0xf7, 0xf8, 0x01, 0x07, 0xff, 0xfe, 0x02, 0x03, 0xfc, 0xfd, + 0xfe, 0xf3, 0x01, 0x06, 0xfc, 0x04, 0xff, 0xff, 0x0a, 0xfa, 0xf5, 0xfc, 0xfa, 0x02, 0x06, 0x03, 0x08, 0xfe, 0xf7, 0x01, 0xfd, 0x01, + 0x06, 0xfc, 0xff, 0x03, 0xfe, 0x03, 0xff, 0xfb, 0x01, 0x05, 0x06, 0x03, 0x03, 0xf8, 0xf6, 0x00, 0x05, 0x01, 0xfd, 0x00, 0x03, 0xff, + 0xf9, 0x05, 0xff, 0xfb, 0x03, 0x05, 0x01, 0xfb, 0xf3, 0x07, 0x0c, 0xff, 0x05, 0x03, 0xfb, 0xf6, 0xfa, 0x03, 0x09, 0x05, 0x01, 0xfd, + 0xfc, 0x03, 0x00, 0xfe, 0x04, 0xfc, 0xfb, 0xff, 0xfc, 0xfe, 0xff, 0xfe, 0x02, 0x00, 0xfe, 0x03, 0xfb, 0xf9, 0xfe, 0xff, 0xfd, 0xfe, + 0x04, 0xfb, 0xfb, 0xfe, 0xfe, 0xfc, 0x00, 0x05, 0x01, 0xfc, 0xfb, 0xff, 0xff, 0x01, 0x01, 0xfe, 0xff, 0x01, 0x01, 0xfe, 0xfb, 0xfb, + 0x00, 0xff, 0x02, 0x03, 0xf8, 0x00, 0x05, 0xff, 0x03, 0xfd, 0xfa, 0x02, 0x03, 0x00, 0xfe, 0xfc, 0x01, 0x03, 0xfe, 0xfd, 0x01, 0x04, + 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x02, 0x03, 0x01, 0x04, 0x03, 0xf9, 0xfc, 0x00, 0x00, 0x00, 0x06, 0x03, 0xfa, 0x07, 0x04, 0xfb, + 0xfe, 0xff, 0x01, 0x03, 0x01, 0xff, 0xfd, 0xfb, 0x02, 0x09, 0x06, 0xf6, 0xff, 0x03, 0xfb, 0x04, 0x03, 0x02, 0x08, 0x00, 0xfc, 0xfe, + 0x00, 0xfd, 0xfd, 0x02, 0xfb, 0xfe, 0x00, 0xfb, 0x00, 0x02, 0xff, 0xfe, 0xfd, 0xfe, 0xff, 0xff, 0x01, 0x01, 0xfa, 0xff, 0x01, 0xfd, + 0xfa, 0xfd, 0xfd, 0xf9, 0x02, 0x01, 0xfd, 0x04, 0x01, 0xf6, 0xf2, 0x05, 0x02, 0xfb, 0x01, 0xf9, 0xfc, 0x01, 0xf9, 0xff, 0x00, 0xfa, + 0x02, 0x00, 0xfc, 0xfd, 0x02, 0x03, 0xfe, 0xfc, 0xfd, 0x00, 0x01, 0x02, 0xfd, 0xfb, 0x04, 0xfc, 0xfe, 0x06, 0x01, 0x01, 0x04, 0x03, + 0xf8, 0xfb, 0x05, 0x07, 0x02, 0xfe, 0xfe, 0xff, 0x01, 0x02, 0x00, 0xfe, 0xff, 0x03, 0x05, 0x02, 0xfd, 0xfd, 0x0b, 0x01, 0xf9, 0x03, + 0x06, 0x05, 0x02, 0x02, 0xfe, 0xff, 0x03, 0x02, 0x01, 0x01, 0x00, 0xfb, 0xfb, 0xff, 0x00, 0x04, 0x05, 0x03, 0x01, 0x00, 0xfd, 0xf8, + 0x01, 0x03, 0xfe, 0xfe, 0x02, 0x01, 0xfc, 0x01, 0x02, 0xfd, 0xf7, 0xfc, 0x00, 0x01, 0x03, 0x00, 0xfc, 0xfb, 0xf9, 0x00, 0x05, 0xfc, + 0xfd, 0xfc, 0xf9, 0xfe, 0xfd, 0xff, 0x05, 0xfe, 0xfc, 0xff, 0xff, 0xfd, 0x00, 0x03, 0xfa, 0xfe, 0x02, 0xfb, 0xff, 0x00, 0x00, 0x05, + 0x00, 0xfb, 0xfd, 0x01, 0x01, 0xff, 0xff, 0xfc, 0x00, 0x07, 0x05, 0xfd, 0xfc, 0x01, 0xfd, 0x00, 0x03, 0xff, 0x04, 0x01, 0xfa, 0xfe, + 0x00, 0x01, 0x04, 0x03, 0x02, 0x00, 0xf9, 0x01, 0x01, 0xfd, 0x07, 0x07, 0xff, 0xfa, 0x00, 0xfe, 0xfd, 0x07, 0x00, 0xfe, 0x04, 0x05, + 0xfe, 0xfd, 0x05, 0xff, 0xfe, 0x02, 0xff, 0xfe, 0x00, 0x04, 0x04, 0x04, 0x00, 0xfc, 0xff, 0x00, 0x00, 0xfe, 0x02, 0x00, 0xfc, 0x05, + 0x03, 0xfe, 0x00, 0x01, 0xfe, 0xfe, 0x03, 0xff, 0xfc, 0xff, 0xfd, 0x02, 0x04, 0xfb, 0xfc, 0xfe, 0xfd, 0xfe, 0x00, 0x00, 0xfd, 0xff, + 0x01, 0xff, 0xfb, 0xfe, 0x02, 0x02, 0xf9, 0xfb, 0xff, 0xfd, 0xf7, 0x02, 0x0c, 0xff, 0xfb, 0xff, 0x02, 0xfd, 0xfd, 0xff, 0x01, 0x02, + 0x02, 0xff, 0xfe, 0xff, 0xff, 0xfe, 0x00, 0x02, 0x01, 0xfa, 0xfc, 0xff, 0x00, 0xff, 0xfe, 0x00, 0x05, 0xfb, 0xfe, 0x03, 0xfd, 0xfd, + 0xfd, 0xfd, 0x07, 0x00, 0xfa, 0x00, 0x02, 0xff, 0xfc, 0xff, 0x00, 0xff, 0xff, 0xfd, 0x01, 0x03, 0xff, 0x02, 0x02, 0x01, 0xff, 0xfd, + 0xfe, 0x01, 0xfe, 0x02, 0x03, 0xfe, 0x01, 0x04, 0x01, 0xfa, 0xfe, 0x01, 0x00, 0x02, 0x04, 0x03, 0x01, 0xfe, 0x00, 0x02, 0xfb, 0xff, + 0x02, 0xfe, 0xfe, 0xff, 0x01, 0x00, 0x04, 0x01, 0xfc, 0xff, 0xff, 0xfd, 0xfd, 0x00, 0x00, 0xfe, 0xfd, 0x03, 0x01, 0xfd, 0x05, 0x00, + 0xfc, 0xff, 0xff, 0xfe, 0xfe, 0x03, 0x00, 0x01, 0x05, 0x02, 0x03, 0x00, 0xf9, 0xff, 0x01, 0xff, 0x02, 0x00, 0xfc, 0xfc, 0xff, 0xff, + 0x00, 0x04, 0xfc, 0xfe, 0x03, 0xfb, 0xfe, 0x02, 0x01, 0x04, 0x01, 0xfe, 0xfe, 0x02, 0x01, 0xfe, 0xfd, 0xff, 0xff, 0xfd, 0x00, 0x03, + 0x00, 0xf9, 0xfe, 0x02, 0x00, 0xfc, 0xfe, 0x00, 0xfe, 0xfe, 0xff, 0x01, 0x01, 0x02, 0xff, 0xfb, 0xff, 0x01, 0x01, 0xff, 0x01, 0x01, + 0x00, 0xff, 0x02, 0x01, 0xfd, 0x00, 0xfe, 0xfc, 0xfd, 0xfc, 0xfe, 0x00, 0x00, 0xfe, 0xff, 0x02, 0xfb, 0xfe, 0x02, 0xfd, 0xff, 0xfe, + 0xfc, 0x06, 0x02, 0xff, 0x03, 0xfe, 0xfa, 0xfc, 0x03, 0xfe, 0xff, 0x04, 0x01, 0xfb, 0xfe, 0x05, 0xfc, 0xfb, 0x00, 0x00, 0x01, 0x00, + 0xfe, 0x00, 0xff, 0xfe, 0xff, 0x02, 0x02, 0xff, 0xfc, 0x02, 0x01, 0xfa, 0x02, 0x02, 0x00, 0x02, 0x05, 0x00, 0xfa, 0x00, 0xff, 0xfe, + 0x02, 0xff, 0x03, 0x05, 0xff, 0xfb, 0xfe, 0x02, 0x05, 0x00, 0xfd, 0xfe, 0xfd, 0xff, 0x02, 0x04, 0x01, 0xff, 0xff, 0xff, 0xfe, 0xff, + 0x02, 0xff, 0xfe, 0xff, 0x01, 0x02, 0x01, 0xff, 0xff, 0xfe, 0xff, 0x01, 0x04, 0x02, 0x00, 0x01, 0xfc, 0xfe, 0x04, 0xfe, 0x00, 0x01, + 0xfc, 0x00, 0xfe, 0xfc, 0x05, 0x00, 0xfe, 0x02, 0x00, 0xff, 0xfe, 0xfe, 0xfe, 0x02, 0x04, 0xfb, 0xff, 0x02, 0xfd, 0xfc, 0x00, 0x03, + 0xfe, 0x03, 0x02, 0xfd, 0xfe, 0xfe, 0x00, 0x04, 0x00, 0x01, 0x03, 0xfe, 0xfb, 0xfe, 0x01, 0xfd, 0x00, 0x03, 0x00, 0x03, 0x00, 0xfc, + 0x00, 0x01, 0x01, 0x00, 0xfc, 0x00, 0x03, 0xfe, 0x02, 0x01, 0xfe, 0x00, 0x02, 0x00, 0xff, 0x00, 0x01, 0xff, 0xfd, 0x02, 0x02, 0xff, + 0x00, 0xfd, 0xfe, 0x00, 0xfc, 0xff, 0x01, 0xfd, 0x03, 0x01, 0xfb, 0x02, 0x00, 0xff, 0x02, 0x00, 0xfd, 0xfc, 0x00, 0x00, 0x02, 0x03, + 0xfe, 0x00, 0x01, 0xfd, 0x01, 0xfe, 0xfb, 0xfe, 0x02, 0x01, 0xfe, 0x01, 0x02, 0x01, 0x00, 0xfe, 0xfe, 0x00, 0x01, 0x01, 0x01, 0x01, + 0xfe, 0xfe, 0x00, 0x01, 0x03, 0xfe, 0xfa, 0x00, 0xff, 0xfd, 0x00, 0x00, 0xfe, 0xff, 0x01, 0xff, 0xff, 0x00, 0xfa, 0x02, 0x03, 0xf9, + 0x01, 0x02, 0xff, 0x02, 0xfc, 0xfd, 0x03, 0xfe, 0xff, 0x01, 0x01, 0xff, 0xfe, 0xff, 0x02, 0x00, 0x00, 0x01, 0x00, 0xfe, 0x00, 0x03, + 0x03, 0xff, 0xfe, 0x04, 0xfe, 0xfd, 0x01, 0xff, 0xfe, 0x00, 0x01, 0xfe, 0xfe, 0x01, 0x03, 0xff, 0xfe, 0x00, 0xfc, 0xfe, 0x00, 0x00, + 0xfe, 0xfe, 0x00, 0xff, 0x02, 0x03, 0x00, 0xfc, 0xfd, 0x00, 0x01, 0x00, 0x01, 0x01, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, + 0x02, 0x02, 0x00, 0xfe, 0x00, 0x01, 0x00, 0x01, 0xfd, 0xfc, 0x02, 0x01, 0xff, 0xff, 0xfe, 0xfd, 0xff, 0x02, 0x00, 0xff, 0xff, 0xfd, + 0xff, 0x00, 0x00, 0x01, 0x00, 0xfe, 0xfe, 0x03, 0x01, 0xfc, 0xfe, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x00, 0x00, 0x00, 0x00, + 0xfe, 0xfe, 0x01, 0xff, 0x01, 0x02, 0xfe, 0x00, 0x01, 0x00, 0xff, 0x01, 0x02, 0xfe, 0xff, 0xff, 0xfe, 0xff, 0x00, 0x00, 0xff, 0x00, + 0xff, 0xfe, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x01, 0xfe, 0x01, 0x04, 0xff, 0x01, 0x00, 0xfd, 0xfd, 0x00, 0x00, 0xff, 0x02, + 0x01, 0xff, 0xff, 0xfe, 0xff, 0x01, 0xfe, 0xfe, 0xfe, 0xfe, 0x00, 0xfe, 0xfd, 0xff, 0x01, 0x02, 0x00, 0xfc, 0xfd, 0x00, 0x00, 0xfd, + 0xff, 0x02, 0xff, 0xfd, 0xff, 0x02, 0xff, 0xff, 0xff, 0xff, 0x02, 0xff, 0xfc, 0x00, 0xff, 0xff, 0x02, 0x02, 0x00, 0xff, 0x00, 0xff, + 0xff, 0xff, 0xff, 0x02, 0x02, 0xfe, 0x01, 0x01, 0x00, 0x00, 0x01, 0x00, 0xff, 0xff, 0x00, 0x01, 0x00, 0x02, 0x00, 0xfd, 0xfd, 0x02, + 0x04, 0x01, 0xfb, 0xff, 0x03, 0x01, 0xff, 0x00, 0x01, 0x00, 0xfe, 0xff, 0x01, 0x00, 0xff, 0xff, 0xff, 0x00, 0x01, 0x00, 0x00, 0xff, + 0xff, 0xff, 0x00, 0xff, 0xff, 0x01, 0xfd, 0xff, 0x03, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xfe, 0xfe, 0x01, 0x00, 0xff, + 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x01, 0xff, 0xfe, 0xfe, 0x00, 0xff, 0xfd, 0xfe, 0x01, 0x02, 0xfd, 0xfe, 0xff, 0xff, 0xfe, 0xff, + 0x01, 0x02, 0xff, 0xfe, 0xff, 0xfe, 0xff, 0x00, 0x01, 0x01, 0x00, 0x00, 0x02, 0xfe, 0xfe, 0x01, 0x01, 0xff, 0xff, 0x01, 0x01, 0x01, + 0x00, 0xfe, 0x01, 0x01, 0x00, 0x01, 0xff, 0xff, 0x01, 0xfd, 0xff, 0x02, 0x02, 0x02, 0x01, 0x00, 0xfd, 0xff, 0x00, 0xfd, 0x01, 0x02, + 0x01, 0x01, 0x00, 0x00, 0x01, 0x01, 0xff, 0xfe, 0xfe, 0x03, 0x00, 0xfc, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0xfe, 0xfe, 0x00, + 0x01, 0xfc, 0x01, 0x02, 0xff, 0xff, 0x00, 0xfe, 0xfd, 0xfe, 0x00, 0x00, 0x01, 0xfe, 0xfe, 0x01, 0xff, 0xfe, 0xff, 0xfe, 0xfe, 0xfe, + 0xfe, 0xff, 0x00, 0x00, 0xfe, 0x00, 0x00, 0xff, 0x01, 0x00, 0xfe, 0xff, 0xff, 0x00, 0x01, 0x01, 0x01, 0xff, 0xfd, 0xff, 0x00, 0x00, + 0xff, 0x01, 0xff, 0xfe, 0x00, 0x00, 0x00, 0x00, 0x01, 0xff, 0xfe, 0x01, 0xfd, 0xff, 0x02, 0x00, 0x02, 0x01, 0x00, 0x01, 0x00, 0xfe, + 0xff, 0x00, 0x01, 0x02, 0x03, 0x00, 0xfe, 0xfe, 0xfd, 0x01, 0x03, 0x01, 0x00, 0x02, 0x01, 0xfd, 0xfd, 0x00, 0x03, 0x02, 0x00, 0xfe, + 0xff, 0xfe, 0xff, 0x00, 0xfe, 0x00, 0x02, 0x01, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x00, 0xff, 0xfe, + 0xff, 0x00, 0x00, 0xff, 0xfc, 0xfe, 0xff, 0xfd, 0x02, 0x00, 0xfe, 0x00, 0xff, 0xff, 0x00, 0xfd, 0xfe, 0xff, 0xff, 0xff, 0x00, 0x01, + 0xfe, 0xfe, 0xfe, 0xfd, 0xfe, 0xff, 0x00, 0x01, 0xfd, 0xff, 0x00, 0xfc, 0xff, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x01, + 0xff, 0x00, 0x00, 0xfe, 0xfe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x01, 0x01, 0x02, 0x01, 0x00, + 0xfe, 0x00, 0x02, 0x02, 0x00, 0xfe, 0xfe, 0xff, 0x01, 0x03, 0x02, 0x00, 0xff, 0xfe, 0xff, 0xff, 0xfe, 0x00, 0x03, 0x02, 0xff, 0xff, + 0x00, 0x01, 0x00, 0xff, 0x00, 0x00, 0x00, 0xfe, 0x00, 0x02, 0x02, 0xfe, 0x00, 0x02, 0x00, 0xfe, 0xff, 0x00, 0xff, 0xfe, 0xff, 0x01, + 0x00, 0x00, 0x00, 0xfe, 0xff, 0x00, 0x01, 0xff, 0x02, 0x01, 0xfd, 0x00, 0x00, 0xff, 0x01, 0x01, 0x00, 0xff, 0xfd, 0xfe, 0x00, 0x00, + 0x00, 0xfe, 0xfe, 0x01, 0x00, 0xfd, 0xfe, 0x00, 0xff, 0xfe, 0xfe, 0x00, 0x01, 0x00, 0x01, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, + 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xfe, 0x01, 0x01, 0xff, 0x01, 0xfe, 0xfe, 0x01, 0x01, 0x00, 0xfe, 0xff, + 0x00, 0x01, 0x01, 0x02, 0xfe, 0xfe, 0x01, 0x00, 0xfe, 0xff, 0x01, 0x00, 0xff, 0xfe, 0x01, 0x00, 0x00, 0x01, 0xff, 0xfd, 0xfd, 0xff, + 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0xfe, 0xfe, 0x00, 0xfe, + 0x00, 0x00, 0xfe, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xfe, 0xfe, 0x00, 0x02, 0x00, 0xff, 0xff, 0xff, 0x00, 0x01, 0xff, 0xff, + 0xfe, 0xfe, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xfe, 0xff, 0x00, 0xfe, 0x00, 0x01, 0xff, 0xff, 0x00, 0xff, 0xfe, 0x00, 0x00, 0xff, 0xff, + 0x00, 0xff, 0xfe, 0x01, 0x00, 0xff, 0x01, 0x00, 0xff, 0x00, 0x01, 0x00, 0x00, 0x00, 0xff, 0xff, 0x01, 0x00, 0x00, 0x00, 0xff, 0x01, + 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x01, 0x01, 0xfd, 0x01, 0x01, 0xff, 0x01, 0x00, 0xff, 0x00, 0x01, + 0x00, 0xfe, 0xfe, 0x00, 0x00, 0xfe, 0x00, 0x00, 0xff, 0xff, 0x01, 0x01, 0xff, 0x00, 0x00, 0xff, 0xfe, 0xff, 0xff, 0xff, 0x00, 0x00, + 0x00, 0x00, 0xff, 0xff, 0xff, 0xfe, 0xff, 0x01, 0x00, 0xfe, 0xff, 0x00, 0x00, 0xfe, 0xff, 0xff, 0xfe, 0xfe, 0xff, 0x01, 0xff, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x01, 0x00, 0xff, 0xff, 0x00, 0x01, 0xff, 0xff, 0x01, 0x01, 0xff, 0xff, 0xff, 0x00, 0x01, 0x00, + 0xff, 0xff, 0x00, 0x00, 0xff, 0x01, 0x00, 0xff, 0xfe, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, + 0x00, 0xfe, 0x01, 0x01, 0xff, 0xfe, 0x01, 0x01, 0xfe, 0xff, 0x00, 0x00, 0xff, 0x01, 0x01, 0x00, 0xff, 0x00, 0x00, 0xfd, 0xff, 0x00, + 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0xff, 0xfe, 0xfe, 0xff, 0x00, 0x00, 0xff, 0x00, 0x01, 0xfe, 0xfd, 0xff, 0x01, 0xfe, 0xfe, + 0x00, 0x01, 0xff, 0x00, 0x01, 0xfe, 0xff, 0x00, 0xfe, 0xfe, 0xff, 0xff, 0xfe, 0xff, 0xff, 0x00, 0xff, 0x00, 0x01, 0x00, 0xff, 0xff, + 0xfe, 0xff, 0x00, 0x01, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x01, 0x01, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, + 0x01, 0xff, 0x00, 0x00, 0xfe, 0x00, 0x01, 0x01, 0x01, 0xff, 0xff, 0x00, 0xfe, 0xff, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, + 0xff, 0x01, 0x00, 0x00, 0x01, 0xff, 0xfe, 0xff, 0xff, 0x01, 0x00, 0xfe, 0x01, 0x00, 0xff, 0x01, 0xff, 0x00, 0x01, 0x01, 0x00, 0xff, + 0xff, 0xfd, 0x00, 0x02, 0x01, 0x00, 0xff, 0xff, 0xff, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xfe, 0xff, 0x00, 0x01, 0xff, 0xfe, + 0xff, 0xff, 0xff, 0x00, 0xfe, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xfe, 0xff, 0xff, 0xfe, 0xff, 0x01, 0x01, 0xff, 0xfe, 0xff, + 0x00, 0x01, 0x00, 0xff, 0x00, 0xfe, 0xfe, 0x01, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, + 0x01, 0x00, 0xfe, 0xfe, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xff, 0xff, 0xff, 0x00, 0xff, 0xfe, 0xfe, 0x01, 0x01, 0x00, + 0x00, 0xff, 0xfe, 0xfe, 0x00, 0x01, 0x00, 0xff, 0x00, 0xff, 0xff, 0x00, 0x01, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, + 0xff, 0x00, 0x01, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x01, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, + 0xff, 0x00, 0x00, 0x00, 0x01, 0x01, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0x02, 0x01, 0xff, 0xff, 0xfe, 0xfe, 0x00, + 0x01, 0x00, 0x00, 0x00, 0xfe, 0xff, 0x00, 0xfe, 0xfe, 0xff, 0xff, 0xff, 0xff, 0x00, 0x01, 0x01, 0x00, 0xff, 0xff, 0xfe, 0xfe, 0x00, + 0xfe, 0xfe, 0xff, 0xff, 0x00, 0x00, 0xff, 0xfe, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xfe, 0xff, 0x00, 0x00, 0xff, 0xff, 0xfe, 0xfd, + 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0x00, 0x01, 0x00, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xfe, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0xff, + 0x01, 0x00, 0xfe, 0x00, 0x00, 0xff, 0x00, 0x00, 0x01, 0x01, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xfe, 0xff, 0x00, 0x00, 0x01, + 0x01, 0x00, 0xff, 0xfe, 0xfe, 0xff, 0x00, 0x01, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, + 0x00, 0x00, 0xff, 0xfe, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0xff, 0xfe, 0x01, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x01, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x01, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x01, 0xff, + 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x01, 0x00, 0xfe, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xfe, 0xff, 0x00, 0xff, 0xff, 0x00, + 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, + 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xfe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xff, + 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xfe, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, + 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x01, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, + 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, + 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, + 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x01, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, + 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, + 0xff, 0xff, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, + 0xff, 0xff, 0xfe, 0xfe, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, + 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, + 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xfe, 0xff, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, + 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x01, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, + 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, + 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, + 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, + 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, + 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, + 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, + 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, + 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, + 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, + 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, + 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, + 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, + 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, + 0x00, 0xff, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, + 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, + 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, + 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, + 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, + 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, + 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, + 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, + 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, + 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, + 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, + 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, + 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, + 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, + 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, + 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, + 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, + 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, + 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, + 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, + 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, + 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0xff, + 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, + 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, + 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, + 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, + 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, + 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, + 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0x00, + 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, + 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, + 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, + 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, + 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, + 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, + 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, + 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, + 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, + 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0x00, 0x00, + 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, + 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, + 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xff, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, + 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, + 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, + 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, + 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, + 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, + 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0x00, + 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, + 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, + 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, +}; + +static const unsigned char RIM_2608[3042] = { + 0x52, 0x49, 0x46, 0x46, 0x90, 0x17, 0x00, 0x00, 0x57, 0x41, 0x56, 0x45, 0x66, 0x6d, 0x74, 0x20, 0x10, 0x00, 0x00, 0x00, 0x01, 0x00, + 0x01, 0x00, 0x44, 0xac, 0x00, 0x00, 0x88, 0x58, 0x01, 0x00, 0x02, 0x00, 0x10, 0x00, 0x66, 0x61, 0x63, 0x74, 0x04, 0x00, 0x00, 0x00, + 0x0b, 0x00, 0x61, 0x61, 0x17, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x04, 0x01, 0xfb, 0xf5, 0xf3, 0xfe, 0x12, 0x1f, 0x0f, + 0xf0, 0xd9, 0xe1, 0xf6, 0x1c, 0x48, 0x63, 0x44, 0x08, 0xef, 0x0a, 0x3e, 0x5f, 0x5e, 0x4d, 0x40, 0x3f, 0x36, 0x2a, 0x10, 0xdc, 0xa0, + 0x80, 0x85, 0x94, 0xa4, 0xaf, 0xb6, 0xb7, 0xba, 0xc2, 0xd1, 0xf2, 0x19, 0x34, 0x2d, 0x1c, 0x09, 0xf8, 0xf5, 0x06, 0x23, 0x37, 0x48, + 0x49, 0x33, 0x0b, 0xed, 0xdb, 0xca, 0xad, 0x9e, 0xb1, 0xd5, 0x0a, 0x39, 0x4c, 0x3e, 0x2e, 0x34, 0x49, 0x56, 0x4f, 0x36, 0x1f, 0xfb, + 0xd3, 0xb6, 0x97, 0x8d, 0x9b, 0xb5, 0xd1, 0xe6, 0xe6, 0xc0, 0xb4, 0xd7, 0x0c, 0x30, 0x21, 0xf5, 0xdd, 0xe1, 0xe9, 0xe3, 0xdf, 0xea, + 0x02, 0x12, 0x03, 0xdf, 0xc6, 0xcc, 0xe6, 0xf1, 0xe8, 0xec, 0x01, 0x1a, 0x1e, 0x19, 0x0e, 0x0e, 0x25, 0x41, 0x4d, 0x41, 0x2f, 0x19, + 0x05, 0xf7, 0xe5, 0xda, 0xda, 0xe3, 0xe4, 0xee, 0x08, 0x21, 0x1a, 0xfe, 0xf1, 0x02, 0x1e, 0x2c, 0x28, 0x1d, 0x12, 0x0c, 0x17, 0x2f, + 0x3c, 0x27, 0x0d, 0x04, 0x0f, 0x15, 0x11, 0x00, 0xea, 0xdd, 0xdf, 0xeb, 0xfc, 0x13, 0x29, 0x38, 0x40, 0x41, 0x39, 0x2a, 0x1c, 0x16, + 0x17, 0x1b, 0x19, 0x11, 0x09, 0x06, 0x00, 0xf7, 0xf1, 0xf5, 0xfb, 0xfc, 0xf9, 0xf3, 0xe7, 0xd8, 0xd9, 0xe6, 0xfa, 0x0c, 0x1c, 0x1a, + 0x06, 0xf3, 0xf0, 0xfb, 0x08, 0x13, 0x17, 0x18, 0x16, 0x13, 0x08, 0xfa, 0xfa, 0x07, 0x15, 0x19, 0x14, 0x0f, 0x11, 0x18, 0x18, 0x14, + 0x16, 0x22, 0x2e, 0x31, 0x29, 0x24, 0x22, 0x1f, 0x17, 0x0b, 0xfc, 0xf0, 0xf0, 0xed, 0xe7, 0xe6, 0xf5, 0x02, 0xff, 0xf1, 0xe9, 0xf1, + 0x03, 0x16, 0x14, 0x02, 0xf1, 0xec, 0xe7, 0xdd, 0xd4, 0xd9, 0xee, 0x03, 0x08, 0xfd, 0xed, 0xe2, 0xe1, 0xe6, 0xea, 0xe7, 0xe5, 0xe5, + 0xe7, 0xec, 0xf6, 0x01, 0x04, 0x00, 0xfa, 0xf5, 0xf0, 0xea, 0xe1, 0xd7, 0xd5, 0xdd, 0xe6, 0xe9, 0xe8, 0xe7, 0xeb, 0xf1, 0xf9, 0x01, + 0x06, 0xfd, 0xeb, 0xdc, 0xd4, 0xd3, 0xda, 0xe4, 0xed, 0xf1, 0xf2, 0xf3, 0xf6, 0xef, 0xe2, 0xde, 0xe5, 0xf0, 0xf7, 0xfb, 0xfc, 0xf9, + 0xf5, 0xf9, 0x04, 0x0e, 0x0c, 0x04, 0xfa, 0xf3, 0xf2, 0xf7, 0xfd, 0x04, 0x04, 0xff, 0xf9, 0xf5, 0xf1, 0xec, 0xe5, 0xe6, 0xf0, 0x01, + 0x10, 0x15, 0x0e, 0x02, 0xfc, 0x00, 0x06, 0x04, 0xfd, 0xf5, 0xef, 0xf0, 0xf7, 0x04, 0x16, 0x21, 0x20, 0x16, 0x0a, 0x04, 0x01, 0xff, + 0xfc, 0xfb, 0xfe, 0x01, 0x08, 0x0c, 0x09, 0x01, 0xfa, 0xf7, 0xfb, 0x04, 0x0c, 0x0e, 0x0d, 0x0e, 0x12, 0x16, 0x13, 0x0a, 0xff, 0xf6, + 0xf5, 0xf8, 0xfd, 0x02, 0x03, 0x03, 0x04, 0x02, 0xfd, 0xff, 0x0a, 0x15, 0x1b, 0x1b, 0x1a, 0x16, 0x14, 0x14, 0x18, 0x18, 0x16, 0x12, + 0x0c, 0x04, 0xfb, 0xf7, 0xfa, 0x03, 0x0d, 0x17, 0x1b, 0x17, 0x0f, 0x06, 0x02, 0x05, 0x0d, 0x12, 0x10, 0x07, 0xfd, 0xf7, 0xf7, 0xfb, + 0x02, 0x0d, 0x18, 0x1e, 0x1e, 0x1c, 0x1b, 0x1c, 0x1b, 0x19, 0x15, 0x10, 0x08, 0x00, 0xfe, 0x01, 0x05, 0x07, 0x08, 0x08, 0x08, 0x05, + 0x05, 0x06, 0x07, 0x07, 0x05, 0x01, 0x00, 0x02, 0x03, 0x02, 0x00, 0xfe, 0xfc, 0xf9, 0xf3, 0xf0, 0xed, 0xec, 0xec, 0xef, 0xf1, 0xf0, + 0xef, 0xec, 0xe5, 0xe0, 0xe1, 0xe6, 0xec, 0xf0, 0xf2, 0xf2, 0xf2, 0xf1, 0xf0, 0xed, 0xef, 0xf5, 0xfd, 0x03, 0x08, 0x0b, 0x0b, 0x0a, + 0x0c, 0x10, 0x14, 0x12, 0x0d, 0x06, 0xfb, 0xef, 0xe6, 0xe1, 0xdd, 0xde, 0xde, 0xdb, 0xdb, 0xdc, 0xde, 0xe0, 0xe4, 0xe9, 0xef, 0xf7, + 0xfa, 0xfc, 0xff, 0x00, 0xfa, 0xf2, 0xef, 0xee, 0xef, 0xf1, 0xf4, 0xf8, 0xfc, 0xfe, 0xfb, 0xf6, 0xf3, 0xf4, 0xf9, 0x00, 0x06, 0x07, + 0x05, 0x04, 0x03, 0x03, 0x01, 0xfd, 0xf8, 0xf5, 0xf2, 0xef, 0xee, 0xf0, 0xf4, 0xf7, 0xfa, 0xfb, 0xf8, 0xf5, 0xf5, 0xf9, 0xfe, 0x00, + 0x01, 0x00, 0x00, 0xfe, 0xf9, 0xf6, 0xf9, 0x01, 0x06, 0x03, 0xfa, 0xf3, 0xf3, 0xf7, 0xf8, 0xf9, 0xfc, 0x00, 0x01, 0x02, 0x05, 0x0a, + 0x0d, 0x0e, 0x0d, 0x0a, 0x04, 0xfd, 0xf8, 0xf6, 0xf6, 0xf7, 0xfc, 0x02, 0x07, 0x07, 0x06, 0x04, 0x03, 0x05, 0x05, 0x03, 0x01, 0x01, + 0x01, 0x00, 0xfe, 0xfd, 0xfc, 0xfc, 0x01, 0x06, 0x0b, 0x0e, 0x12, 0x10, 0x09, 0x06, 0x0a, 0x13, 0x1c, 0x1c, 0x1b, 0x1d, 0x1e, 0x19, + 0x10, 0x0c, 0x0a, 0x0b, 0x09, 0x00, 0xfb, 0xf9, 0xf8, 0xf8, 0xfd, 0x02, 0x03, 0x04, 0x04, 0x04, 0x08, 0x0a, 0x0b, 0x0c, 0x0c, 0x0f, + 0x0f, 0x0a, 0x04, 0x05, 0x08, 0x05, 0x01, 0x00, 0x03, 0x06, 0x05, 0x02, 0x01, 0x02, 0x00, 0xfe, 0x02, 0x07, 0x0b, 0x0a, 0x0a, 0x05, + 0x03, 0x06, 0x07, 0x04, 0x01, 0x05, 0x04, 0x01, 0xfd, 0xfe, 0xfb, 0xf6, 0xf6, 0xfb, 0x02, 0x08, 0x09, 0x09, 0x08, 0x05, 0x02, 0x01, + 0x01, 0x01, 0x05, 0x07, 0x08, 0x0b, 0x0c, 0x0a, 0x06, 0x07, 0x08, 0x0a, 0x0b, 0x0d, 0x0e, 0x0c, 0x06, 0x01, 0xfc, 0xfa, 0xf7, 0xf7, + 0xf8, 0xf7, 0xf7, 0xf8, 0xf8, 0xf8, 0xfb, 0x00, 0x02, 0x02, 0x00, 0xfd, 0xfb, 0xfd, 0xfb, 0xf4, 0xf1, 0xf2, 0xf3, 0xef, 0xed, 0xef, + 0xf1, 0xf0, 0xf0, 0xef, 0xee, 0xed, 0xee, 0xee, 0xec, 0xee, 0xf0, 0xf1, 0xf4, 0xfa, 0xfe, 0x00, 0x01, 0x01, 0x02, 0x04, 0x08, 0x0c, + 0x0b, 0x03, 0xfc, 0xfb, 0x01, 0x06, 0x07, 0x06, 0x04, 0x00, 0xfa, 0xf5, 0xf3, 0xf3, 0xf6, 0xf7, 0xf6, 0xf1, 0xec, 0xee, 0xee, 0xed, + 0xec, 0xed, 0xee, 0xf1, 0xf7, 0xfb, 0xfa, 0xf6, 0xf3, 0xf2, 0xf3, 0xf7, 0xfe, 0xff, 0xff, 0x00, 0x04, 0x07, 0x06, 0x06, 0x08, 0x0b, + 0x0c, 0x0e, 0x0e, 0x0c, 0x08, 0x01, 0xfc, 0xfa, 0xfa, 0xf8, 0xf3, 0xf1, 0xf4, 0xfa, 0x00, 0x01, 0xfe, 0xfa, 0xf9, 0xf7, 0xf9, 0xfc, + 0xfc, 0x00, 0x03, 0x03, 0xff, 0x00, 0x04, 0x07, 0x08, 0x04, 0x02, 0x05, 0x0b, 0x0b, 0x0a, 0x0e, 0x10, 0x10, 0x0d, 0x09, 0x06, 0x07, + 0x0b, 0x0f, 0x11, 0x11, 0x0d, 0x0d, 0x0f, 0x0d, 0x0d, 0x0e, 0x0d, 0x0b, 0x07, 0x02, 0xff, 0x01, 0x01, 0x01, 0x01, 0x02, 0x01, 0xfe, + 0xfd, 0xfe, 0x03, 0x08, 0x09, 0x05, 0x02, 0x03, 0x06, 0x06, 0x04, 0x03, 0x01, 0x02, 0x03, 0x07, 0x07, 0x06, 0x08, 0x0c, 0x0e, 0x0b, + 0x08, 0x08, 0x0b, 0x0c, 0x0c, 0x0b, 0x09, 0x07, 0x07, 0x04, 0xff, 0xfd, 0xfb, 0xf8, 0xf5, 0xf6, 0xf9, 0xfb, 0xf9, 0xf7, 0xf5, 0xf4, + 0xf3, 0xf8, 0xfa, 0xf9, 0xf7, 0xf9, 0xff, 0x03, 0x02, 0x01, 0x00, 0xfe, 0xfe, 0xff, 0x02, 0x07, 0x0b, 0x0a, 0x07, 0x04, 0x01, 0xfe, + 0xfe, 0xfe, 0xfc, 0xfb, 0x00, 0x06, 0x08, 0x06, 0x04, 0x04, 0x03, 0xfe, 0xfa, 0xf8, 0xfa, 0xfa, 0xf8, 0xf5, 0xf6, 0xf5, 0xf5, 0xf5, + 0xf6, 0xf6, 0xf6, 0xf9, 0xfd, 0x02, 0x06, 0x06, 0x04, 0x02, 0x02, 0x05, 0x03, 0xff, 0xfe, 0xfd, 0xfd, 0xfc, 0xfb, 0xfa, 0xfd, 0x01, + 0x01, 0xff, 0xff, 0xfe, 0xfb, 0xf8, 0xf7, 0xf6, 0xf8, 0xfb, 0xfc, 0xfc, 0xfb, 0xfa, 0xf8, 0xf9, 0xfa, 0xf8, 0xf6, 0xf6, 0xf8, 0xf8, + 0xf8, 0xf9, 0xfb, 0xfc, 0xfb, 0xfb, 0xfc, 0xff, 0x00, 0x00, 0x01, 0xfd, 0xf7, 0xf4, 0xf3, 0xf3, 0xf3, 0xf5, 0xf5, 0xf4, 0xf3, 0xf7, + 0xf9, 0xfb, 0xfb, 0xf7, 0xf4, 0xf7, 0xfe, 0x01, 0x01, 0xff, 0x00, 0xfd, 0xfc, 0xfd, 0xfc, 0xf9, 0xf8, 0xfc, 0x00, 0x02, 0x02, 0x01, + 0x00, 0x01, 0x03, 0x05, 0x05, 0x03, 0x01, 0xfe, 0xfc, 0xfc, 0xfe, 0xff, 0xff, 0xfe, 0xff, 0x00, 0x02, 0x07, 0x0b, 0x0c, 0x0c, 0x0e, + 0x0c, 0x07, 0x04, 0x03, 0x03, 0x03, 0x05, 0x05, 0x05, 0x05, 0x03, 0xfe, 0xfa, 0xf9, 0xfc, 0x00, 0x00, 0xfd, 0xfa, 0xfa, 0xfd, 0xfe, + 0xfb, 0xfa, 0xfb, 0xfb, 0xfb, 0xfd, 0x02, 0x06, 0x09, 0x09, 0x06, 0x03, 0x01, 0x02, 0x04, 0x07, 0x07, 0x04, 0xfe, 0xf9, 0xf7, 0xf7, + 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfb, 0xfc, 0xfc, 0xfd, 0xfe, 0xfe, 0xff, 0xff, 0xff, 0x02, 0x05, 0x06, 0x05, 0x05, 0x06, 0x06, 0x06, + 0x08, 0x0b, 0x0b, 0x07, 0x03, 0xff, 0xfc, 0xf9, 0xfa, 0xfd, 0x01, 0x04, 0x04, 0x04, 0x05, 0x07, 0x0a, 0x0a, 0x08, 0x07, 0x08, 0x0a, + 0x0a, 0x06, 0x04, 0x02, 0x04, 0x06, 0x04, 0x04, 0x07, 0x0a, 0x09, 0x08, 0x06, 0x05, 0x07, 0x08, 0x06, 0x02, 0x01, 0x02, 0x02, 0x05, + 0x07, 0x04, 0xfb, 0xf5, 0xf4, 0xf6, 0xf6, 0xf5, 0xf4, 0xf5, 0xf6, 0xf7, 0xf9, 0xfa, 0xf9, 0xf8, 0xf9, 0xfc, 0x00, 0x03, 0x05, 0x06, + 0x07, 0x08, 0x07, 0x02, 0xff, 0xfe, 0xff, 0x00, 0x00, 0x00, 0xfd, 0xfd, 0x01, 0x04, 0xff, 0xf8, 0xf7, 0xf9, 0xfc, 0xfe, 0xfe, 0xfb, + 0xfb, 0xff, 0x03, 0x01, 0xfd, 0xfc, 0xfd, 0xfd, 0xfd, 0xff, 0xfc, 0xfa, 0xf9, 0xfb, 0xfa, 0xf7, 0xf6, 0xf7, 0xf7, 0xf7, 0xf9, 0xfc, + 0xff, 0x02, 0x02, 0x00, 0xff, 0x00, 0x03, 0x06, 0x06, 0x05, 0x05, 0x06, 0x08, 0x0a, 0x08, 0x05, 0x04, 0x03, 0xfe, 0xf8, 0xf7, 0xf8, + 0xf9, 0xfa, 0xfb, 0xf9, 0xf7, 0xf8, 0xfa, 0xfc, 0xfc, 0xfc, 0xfa, 0xf8, 0xfa, 0xfe, 0x00, 0x02, 0x03, 0x02, 0x01, 0x02, 0x01, 0xfe, + 0xfd, 0xfc, 0xfa, 0xf8, 0xf8, 0xf5, 0xf4, 0xf5, 0xf8, 0xf5, 0xf5, 0xf9, 0xfd, 0xfc, 0xfb, 0xfa, 0xfa, 0xfa, 0xfb, 0xfd, 0xff, 0xff, + 0xfd, 0xfa, 0xfc, 0xfd, 0xfc, 0xfd, 0x00, 0x01, 0xfe, 0xff, 0x02, 0x03, 0x00, 0xfc, 0xfb, 0xff, 0x02, 0x01, 0xfe, 0xfe, 0x02, 0x06, + 0x08, 0x09, 0x07, 0x05, 0x06, 0x0a, 0x0d, 0x10, 0x11, 0x0e, 0x0b, 0x0a, 0x09, 0x06, 0x05, 0x04, 0x04, 0x03, 0x03, 0x05, 0x06, 0x04, + 0x02, 0xff, 0x01, 0x02, 0x00, 0xff, 0x03, 0x08, 0x0a, 0x0b, 0x09, 0x06, 0x04, 0x03, 0x02, 0x04, 0x09, 0x0b, 0x08, 0x03, 0x00, 0x00, + 0x02, 0x04, 0x06, 0x07, 0x07, 0x07, 0x06, 0x06, 0x05, 0x05, 0x03, 0x00, 0xfd, 0xfe, 0xfe, 0xfb, 0xf8, 0xf7, 0xf7, 0xf8, 0xf9, 0xf9, + 0xfa, 0xfd, 0xfd, 0xfa, 0xfa, 0xfc, 0xfd, 0xfd, 0xfe, 0xfc, 0xf7, 0xf5, 0xfa, 0xff, 0xff, 0xfd, 0xfa, 0xf9, 0xf9, 0xf8, 0xf9, 0xfa, + 0xfa, 0xf8, 0xf6, 0xf6, 0xf9, 0xfd, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x03, 0x06, 0x05, 0x00, 0xfe, 0x00, 0x01, 0xff, 0xfb, 0xf9, + 0xfa, 0xfb, 0xfe, 0x01, 0x03, 0x04, 0x05, 0x05, 0x06, 0x04, 0x00, 0xfa, 0xfa, 0xfb, 0xfe, 0x01, 0x02, 0x03, 0x02, 0xff, 0xfc, 0xfc, + 0xff, 0x03, 0x04, 0x01, 0xfe, 0xfb, 0xfb, 0xfa, 0xfa, 0xfb, 0xfc, 0xfe, 0xfe, 0xfe, 0xff, 0xfe, 0xfb, 0xf9, 0xf9, 0xf9, 0xf9, 0xfa, + 0xff, 0xff, 0xfe, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xfc, 0xfa, 0xfb, 0xff, 0x05, 0x08, 0x05, 0xff, 0xfa, 0xf8, 0xfa, 0x00, 0x05, + 0x06, 0x03, 0x01, 0x01, 0x03, 0x06, 0x07, 0x06, 0x05, 0x06, 0x07, 0x08, 0x08, 0x09, 0x09, 0x08, 0x07, 0x06, 0x02, 0xff, 0xfe, 0xff, + 0x01, 0x02, 0x03, 0x03, 0x04, 0x03, 0x02, 0x02, 0x02, 0x03, 0x05, 0x06, 0x06, 0x04, 0x01, 0x01, 0x02, 0x03, 0x03, 0x02, 0x00, 0xfe, + 0xfd, 0x00, 0x05, 0x0a, 0x0a, 0x07, 0x04, 0x04, 0x05, 0x06, 0x06, 0x03, 0x00, 0xff, 0x00, 0xff, 0x00, 0x02, 0x05, 0x03, 0xff, 0xfe, + 0xfe, 0xfd, 0xfc, 0xfb, 0xf9, 0xfa, 0xfa, 0xf7, 0xf5, 0xf6, 0xf7, 0xf8, 0xf8, 0xf9, 0xfc, 0xff, 0x00, 0x00, 0xff, 0xfd, 0xfa, 0xfa, + 0xf9, 0xfb, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0xff, 0xfc, 0xfb, 0xfa, 0xf9, 0xfa, 0xfd, 0x00, 0x02, + 0x03, 0x03, 0x03, 0x03, 0x03, 0x02, 0xff, 0xfd, 0xfb, 0xfb, 0xfa, 0xfa, 0xfb, 0xfc, 0xfb, 0xfa, 0xf9, 0xf9, 0xfc, 0xfc, 0xfc, 0xfc, + 0xfb, 0xfb, 0xfc, 0xff, 0x01, 0x02, 0x02, 0xff, 0xff, 0x01, 0x00, 0x00, 0x00, 0xff, 0xfd, 0xfc, 0xfd, 0xff, 0xff, 0xfe, 0xff, 0x02, + 0x03, 0x04, 0x03, 0x00, 0xfe, 0xff, 0x02, 0x05, 0x05, 0x03, 0x01, 0x00, 0x01, 0x02, 0x03, 0x03, 0x02, 0x00, 0xfc, 0xfb, 0xfd, 0x00, + 0x02, 0x03, 0x02, 0x00, 0xfd, 0xfb, 0xfb, 0xfc, 0xfe, 0x00, 0x02, 0x02, 0x00, 0x00, 0x01, 0x02, 0x03, 0x03, 0xff, 0xfd, 0xfc, 0xfd, + 0xfc, 0xfb, 0xfd, 0x01, 0x03, 0x02, 0x03, 0x04, 0x06, 0x06, 0x03, 0xfe, 0xfb, 0xfd, 0x01, 0x03, 0x01, 0x01, 0x01, 0x02, 0x03, 0x04, + 0x03, 0x00, 0xfb, 0xfc, 0xff, 0x01, 0x00, 0xfe, 0xfd, 0xfe, 0x03, 0x05, 0x03, 0xff, 0xfe, 0xfd, 0xfc, 0xfc, 0xfd, 0xff, 0x00, 0x00, + 0xff, 0xff, 0x01, 0xfe, 0xfb, 0xfa, 0xfc, 0xff, 0x01, 0x01, 0x01, 0xfe, 0xfc, 0xfb, 0xfd, 0xff, 0xfd, 0xfc, 0xfe, 0x00, 0x01, 0x00, + 0x00, 0x01, 0x00, 0x00, 0x01, 0x03, 0x04, 0x03, 0x01, 0x00, 0x00, 0x01, 0x00, 0xfe, 0xfc, 0xfc, 0xfe, 0x00, 0x00, 0xff, 0xfe, 0xfd, + 0xfe, 0x00, 0x03, 0x02, 0xff, 0xfc, 0xfc, 0xfc, 0xfa, 0xfb, 0xfe, 0x01, 0x02, 0x02, 0x02, 0x01, 0x01, 0x02, 0x03, 0x03, 0x01, 0x01, + 0x02, 0x03, 0x02, 0x00, 0xff, 0xff, 0xff, 0x00, 0x01, 0x03, 0x02, 0x00, 0xfe, 0xfe, 0xfd, 0xfc, 0xfb, 0xfd, 0x00, 0x03, 0x04, 0x04, + 0x03, 0x01, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0xfe, 0xfb, 0xfa, 0xf9, 0xfa, 0xfb, 0xfd, 0xfe, 0xff, 0x00, 0x01, 0x00, + 0xfe, 0xfe, 0xfe, 0xfe, 0xff, 0x02, 0x04, 0x04, 0x02, 0x02, 0x03, 0x02, 0xff, 0xfc, 0xfb, 0xfd, 0x00, 0x02, 0x03, 0x03, 0x03, 0x03, + 0x02, 0xff, 0xff, 0x01, 0x02, 0x02, 0x03, 0x03, 0x01, 0xff, 0xff, 0xff, 0xff, 0xfb, 0xf9, 0xfb, 0xfe, 0x00, 0x01, 0xff, 0xfd, 0xfc, + 0xfb, 0xf8, 0xf8, 0xf9, 0xfb, 0xfc, 0xfd, 0xfe, 0x00, 0x02, 0x04, 0x05, 0x04, 0x01, 0xff, 0xff, 0xfe, 0x00, 0x03, 0x07, 0x07, 0x04, + 0xff, 0xfc, 0xfd, 0xff, 0x00, 0xfd, 0xf9, 0xf8, 0xfa, 0xfd, 0xff, 0xfe, 0xfe, 0xfe, 0xfd, 0xfd, 0xfe, 0x01, 0x03, 0x01, 0xff, 0x00, + 0x02, 0x00, 0xfe, 0xfd, 0xfe, 0x01, 0x04, 0x03, 0x00, 0xfd, 0xfd, 0x01, 0x01, 0x01, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x01, 0x03, 0x03, 0x03, 0x02, 0x01, 0x02, 0x01, 0xff, 0xfc, 0xfc, 0xff, 0xff, 0xfe, 0xff, 0x03, 0x02, 0x00, 0xfe, 0x00, 0x01, 0x01, + 0xff, 0xfe, 0xfe, 0xfe, 0xfd, 0xfb, 0xfc, 0xfd, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x01, 0x01, 0x01, 0x02, 0x03, 0x02, 0x01, 0x00, + 0x01, 0x01, 0x01, 0x03, 0x03, 0x02, 0x00, 0xff, 0xfe, 0x00, 0x02, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0xff, 0xfe, 0xfe, 0xff, + 0x00, 0xff, 0x00, 0x02, 0x02, 0x00, 0xfe, 0xfe, 0x00, 0x02, 0x02, 0x00, 0xff, 0x00, 0x00, 0xfd, 0xfb, 0xfa, 0xfb, 0xfe, 0x00, 0x01, + 0x01, 0x00, 0xfe, 0xfc, 0xfb, 0xfe, 0x00, 0xfe, 0xfd, 0xfe, 0x01, 0x02, 0x01, 0x00, 0xff, 0xfe, 0xff, 0x00, 0x01, 0x01, 0x01, 0x01, + 0x01, 0x00, 0x00, 0x02, 0x05, 0x06, 0x04, 0x01, 0xff, 0x00, 0x03, 0x05, 0x03, 0x00, 0xff, 0x00, 0xff, 0xfd, 0xfe, 0xff, 0xff, 0xff, + 0xfe, 0xfc, 0xfc, 0xfe, 0xff, 0xff, 0xfe, 0xfe, 0xfe, 0xfe, 0xff, 0x01, 0x02, 0x03, 0x03, 0x01, 0xff, 0xfe, 0xff, 0xfe, 0xff, 0x01, + 0x02, 0x02, 0x02, 0x03, 0x01, 0xff, 0x00, 0x01, 0x00, 0xff, 0x00, 0x01, 0x02, 0x01, 0xfe, 0xfc, 0xfc, 0xfd, 0xfe, 0xff, 0xfe, 0xfe, + 0xfd, 0xfd, 0xfd, 0xfe, 0xfe, 0xfd, 0xfb, 0xfb, 0xfc, 0xfe, 0xff, 0x02, 0x03, 0x01, 0xff, 0xff, 0xfe, 0xfc, 0xfa, 0xf9, 0xf9, 0xfc, + 0xfd, 0xff, 0xff, 0xfd, 0xfc, 0xfd, 0x00, 0x01, 0x01, 0xff, 0xfe, 0xfe, 0x00, 0x01, 0x02, 0x01, 0x01, 0x03, 0x02, 0x00, 0xfe, 0xfe, + 0xff, 0x01, 0x03, 0x03, 0x00, 0xff, 0xff, 0x00, 0x00, 0x01, 0x01, 0xff, 0xfe, 0xfd, 0xfc, 0xfa, 0xfa, 0xfe, 0x00, 0x01, 0x01, 0x00, + 0xfe, 0xff, 0x02, 0x05, 0x05, 0x03, 0x02, 0x01, 0x00, 0x00, 0x00, 0xfe, 0xfe, 0x00, 0x03, 0x02, 0x00, 0xff, 0x00, 0x02, 0x03, 0x02, + 0x01, 0xff, 0xfe, 0xfe, 0x00, 0x01, 0x02, 0x01, 0x01, 0x03, 0x03, 0x03, 0x03, 0x02, 0x01, 0x01, 0x02, 0x02, 0x01, 0x01, 0x01, 0x01, + 0x02, 0x01, 0x01, 0x00, 0x00, 0xff, 0xfd, 0xfd, 0xfe, 0xfe, 0xfe, 0xfe, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfe, 0xfe, 0xfe, 0xff, 0xfe, + 0xff, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xfe, 0xff, 0x00, 0xff, 0xfe, 0xff, 0xff, 0xfe, 0xfd, 0xfd, + 0xfd, 0xfd, 0xfd, 0xfe, 0xff, 0xff, 0xfe, 0xfe, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xfe, 0xfe, 0xfe, 0xff, 0xff, + 0x00, 0x01, 0x02, 0x01, 0xff, 0xfe, 0xff, 0xff, 0xfe, 0xfd, 0xfe, 0x00, 0x01, 0x00, 0xff, 0x00, 0x01, 0x02, 0x02, 0x01, 0x00, 0x01, + 0x01, 0x00, 0x00, 0x00, 0xff, 0xfe, 0xff, 0x00, 0xff, 0xfe, 0x00, 0x01, 0x01, 0xff, 0xff, 0xff, 0x01, 0x02, 0x01, 0x00, 0xff, 0x00, + 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xfe, 0xfe, + 0xff, 0xff, 0x01, 0x02, 0x02, 0x02, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x02, 0x03, 0x03, 0x01, 0xff, 0xff, + 0x00, 0x00, 0xff, 0xfd, 0xfd, 0xfe, 0xff, 0x00, 0x01, 0xff, 0xff, 0xff, 0x00, 0x02, 0x02, 0x01, 0xff, 0xfe, 0xfe, 0x00, 0x01, 0x02, + 0x02, 0x00, 0xff, 0xfe, 0xff, 0x00, 0x00, 0xfe, 0xfb, 0xfb, 0xfe, 0x01, 0x01, 0xff, 0xfe, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x01, 0x02, 0x02, 0x00, 0xff, 0xfe, 0xfe, 0xfc, 0xfc, 0xfc, 0xfd, 0xfd, 0xfc, 0xfd, 0xfe, 0xff, 0xfe, 0xfe, 0xfe, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x01, 0x01, 0x01, 0xff, 0xff, 0xfe, 0xfd, 0xfc, 0xfd, 0xfe, 0xff, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, + 0x01, 0x01, 0x01, 0x00, 0xfe, 0xfd, 0xfd, 0xfe, 0xfe, 0xfe, 0xff, 0x00, 0x01, 0x01, 0x01, 0x01, 0x00, 0xff, 0xff, 0xff, 0xff, 0xfe, + 0xfe, 0x00, 0x01, 0x00, 0xff, 0xfe, 0xff, 0x01, 0x01, 0x02, 0x03, 0x02, 0x00, 0xfe, 0xfe, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, + 0xff, 0xff, 0x00, 0x01, 0x03, 0x03, 0x01, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x00, 0x00, 0x01, 0x00, + 0xff, 0xff, 0x00, 0x01, 0x01, 0xff, 0xfe, 0xfe, 0x00, 0x00, 0xff, 0xfd, 0xfc, 0xfb, 0xfc, 0xff, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, + 0xff, 0xff, 0x00, 0x02, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xfe, 0xfd, 0xfe, 0xff, + 0x00, 0xff, 0xff, 0xfe, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xfe, 0xfe, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, + 0xff, 0xff, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xfe, 0xfe, 0xff, 0x00, 0x01, 0x02, 0x02, 0x02, 0x01, 0x01, 0x00, + 0xff, 0xfe, 0xfe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xfe, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, + 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x01, + 0x02, 0x02, 0x01, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x01, 0x02, 0x01, 0xff, 0xfd, 0xfd, 0xfe, 0xff, 0x00, 0x00, 0xff, + 0xfe, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x01, 0x00, + 0xff, 0xff, 0xff, 0xfe, 0xfe, 0xfe, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xff, 0xff, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x01, 0x00, 0xff, 0xff, 0x00, 0xff, 0xfe, 0xfe, 0xfe, 0xff, 0x01, 0x01, 0x00, 0xff, 0xff, 0xfe, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfe, 0xfe, 0xfe, 0xff, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x01, 0x02, 0x01, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, + 0x00, 0x00, 0xff, 0xfe, 0xff, 0x00, 0x00, 0xff, 0xfe, 0xfe, 0xfe, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xff, 0xff, 0xff, 0xff, 0xfe, 0xfe, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xfe, 0xfe, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, + 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +}; + +static const unsigned char SD_2608[10674] = { + 0x52, 0x49, 0x46, 0x46, 0x30, 0x53, 0x00, 0x00, 0x57, 0x41, 0x56, 0x45, 0x66, 0x6d, 0x74, 0x20, 0x10, 0x00, 0x00, 0x00, 0x01, 0x00, + 0x01, 0x00, 0x44, 0xac, 0x00, 0x00, 0x88, 0x58, 0x01, 0x00, 0x02, 0x00, 0x10, 0x00, 0x66, 0x61, 0x63, 0x74, 0x04, 0x00, 0x00, 0x00, + 0x29, 0x00, 0x61, 0x61, 0x53, 0x00, 0xfe, 0xfe, 0xfd, 0x01, 0x0a, 0x14, 0x1f, 0x26, 0x26, 0x26, 0x24, 0x21, 0x1e, 0x1c, 0x1a, 0x19, + 0x18, 0x18, 0x18, 0x18, 0x1a, 0x1a, 0x19, 0x19, 0x17, 0x15, 0x14, 0x14, 0x12, 0x11, 0x12, 0x0c, 0x0b, 0x0b, 0x07, 0xfc, 0xf8, 0xfb, + 0xf9, 0xee, 0xed, 0xfe, 0x11, 0x0a, 0xf3, 0xe7, 0xff, 0x14, 0x0a, 0xfe, 0xf0, 0xee, 0xf6, 0xf7, 0xf1, 0xf3, 0x07, 0x0b, 0x05, 0xff, + 0xf3, 0xf1, 0xf5, 0xf9, 0xf8, 0xfd, 0x11, 0x2e, 0x4d, 0x64, 0x6b, 0x60, 0x3d, 0x0f, 0xe8, 0xbd, 0xa4, 0xaa, 0xce, 0xfb, 0x23, 0x42, + 0x5a, 0x6b, 0x6d, 0x5b, 0x3d, 0x1f, 0x07, 0xf0, 0xdd, 0xcc, 0xbc, 0xaf, 0xa6, 0x9f, 0x98, 0xa0, 0xaa, 0xad, 0xb4, 0xb7, 0xb9, 0xbb, + 0xbc, 0xb7, 0xaf, 0xad, 0xad, 0xb2, 0xb8, 0xb5, 0xb2, 0xb3, 0xbc, 0xcc, 0xd7, 0xd8, 0xd3, 0xcb, 0xc7, 0xca, 0xd2, 0xdb, 0xde, 0xdd, + 0xd9, 0xdd, 0xe8, 0xf0, 0xf6, 0xf7, 0xf4, 0xf1, 0xf1, 0xf3, 0xf5, 0xf6, 0xf5, 0xf1, 0xf4, 0xf5, 0xf1, 0xea, 0xe6, 0xdf, 0xdd, 0xe7, + 0xf3, 0xf7, 0xf4, 0xf4, 0xec, 0xe0, 0xd9, 0xd5, 0xd5, 0xdb, 0xe5, 0xed, 0xf4, 0xfc, 0x03, 0xfa, 0xe7, 0xd4, 0xc3, 0xb2, 0xa6, 0xa7, + 0xaf, 0xbc, 0xcd, 0xe3, 0xfb, 0x0e, 0x16, 0x13, 0x06, 0xf6, 0xe4, 0xd2, 0xc0, 0xb0, 0xa5, 0x9e, 0xa1, 0xb0, 0xca, 0xe2, 0xf4, 0x03, + 0x0c, 0x0e, 0x0b, 0x0e, 0x0e, 0x09, 0x07, 0xfd, 0xfa, 0xfc, 0xf6, 0xe6, 0xe2, 0xf4, 0xfb, 0x00, 0x0b, 0x19, 0x22, 0x23, 0x22, 0x2c, + 0x31, 0x31, 0x34, 0x37, 0x3d, 0x47, 0x52, 0x5a, 0x61, 0x6a, 0x6d, 0x70, 0x75, 0x7b, 0x7c, 0x7a, 0x77, 0x71, 0x6f, 0x70, 0x72, 0x77, + 0x7b, 0x7c, 0x7e, 0x7e, 0x7e, 0x7d, 0x7b, 0x77, 0x72, 0x6d, 0x67, 0x62, 0x60, 0x5e, 0x5e, 0x5d, 0x5a, 0x57, 0x53, 0x4f, 0x4b, 0x46, + 0x41, 0x3b, 0x36, 0x38, 0x38, 0x33, 0x30, 0x34, 0x3a, 0x3b, 0x3d, 0x3c, 0x39, 0x35, 0x30, 0x2c, 0x28, 0x22, 0x23, 0x27, 0x24, 0x27, + 0x2b, 0x2b, 0x25, 0x2b, 0x33, 0x32, 0x2e, 0x2b, 0x2a, 0x27, 0x26, 0x26, 0x24, 0x25, 0x24, 0x26, 0x2d, 0x2a, 0x25, 0x22, 0x1e, 0x1c, + 0x1e, 0x22, 0x23, 0x22, 0x1f, 0x1b, 0x16, 0x11, 0x0e, 0x0b, 0x08, 0x06, 0x04, 0x01, 0xfc, 0xf6, 0xf2, 0xee, 0xeb, 0xe7, 0xe3, 0xdd, + 0xd8, 0xd4, 0xd1, 0xcd, 0xc8, 0xc4, 0xbe, 0xbb, 0xba, 0xbb, 0xb9, 0xb9, 0xb9, 0xb4, 0xb2, 0xb2, 0xb2, 0xb4, 0xb5, 0xb4, 0xb2, 0xad, + 0xa7, 0xa1, 0x99, 0x95, 0x95, 0x98, 0x9c, 0x9f, 0xa2, 0xa4, 0xa3, 0xa1, 0x9d, 0x97, 0x91, 0x8a, 0x84, 0x83, 0x85, 0x87, 0x8b, 0x8f, + 0x94, 0x99, 0x9e, 0x9e, 0x99, 0x92, 0x8b, 0x85, 0x81, 0x80, 0x82, 0x87, 0x89, 0x8b, 0x8c, 0x8e, 0x92, 0x90, 0x8f, 0x92, 0x94, 0x93, + 0x93, 0x9a, 0x9b, 0x9b, 0x9c, 0x98, 0x9d, 0xa0, 0xa0, 0xa5, 0xb1, 0xbc, 0xc1, 0xc4, 0xca, 0xd3, 0xdd, 0xe2, 0xe1, 0xdf, 0xd9, 0xd5, + 0xd4, 0xd5, 0xd2, 0xd1, 0xd8, 0xe5, 0xf3, 0xfe, 0x05, 0x0b, 0x0e, 0x10, 0x13, 0x17, 0x1c, 0x21, 0x25, 0x2d, 0x36, 0x3e, 0x49, 0x4d, + 0x4a, 0x44, 0x46, 0x49, 0x47, 0x4c, 0x4f, 0x50, 0x53, 0x57, 0x5a, 0x5d, 0x61, 0x60, 0x59, 0x53, 0x53, 0x5a, 0x64, 0x68, 0x63, 0x59, + 0x52, 0x4e, 0x4e, 0x52, 0x55, 0x52, 0x4c, 0x4a, 0x4d, 0x51, 0x50, 0x4b, 0x44, 0x43, 0x45, 0x44, 0x3d, 0x37, 0x32, 0x2d, 0x2b, 0x31, + 0x3a, 0x3d, 0x42, 0x46, 0x46, 0x3e, 0x3c, 0x44, 0x4a, 0x48, 0x40, 0x38, 0x38, 0x40, 0x48, 0x48, 0x46, 0x46, 0x48, 0x4c, 0x4d, 0x51, + 0x5a, 0x60, 0x5e, 0x57, 0x54, 0x56, 0x5b, 0x5c, 0x51, 0x47, 0x41, 0x3f, 0x46, 0x4f, 0x53, 0x4d, 0x48, 0x45, 0x46, 0x47, 0x4d, 0x4e, + 0x47, 0x3f, 0x42, 0x49, 0x49, 0x3c, 0x28, 0x1e, 0x26, 0x2b, 0x25, 0x1c, 0x16, 0x13, 0x14, 0x15, 0x15, 0x16, 0x17, 0x0f, 0x09, 0x04, + 0xfd, 0xfa, 0xfb, 0xf9, 0xef, 0xe1, 0xd5, 0xd6, 0xde, 0xe5, 0xdf, 0xce, 0xb8, 0xae, 0xb4, 0xbf, 0xc3, 0xc5, 0xc8, 0xc1, 0xb8, 0xb2, + 0xb2, 0xb2, 0xb0, 0xac, 0xa8, 0xa7, 0xa8, 0xab, 0xb1, 0xc0, 0xca, 0xbd, 0xad, 0xa4, 0xa6, 0xb0, 0xbb, 0xbe, 0xb7, 0xb2, 0xb1, 0xb4, + 0xbb, 0xb8, 0xad, 0xa2, 0x9f, 0xa4, 0xb1, 0xbf, 0xbd, 0xb4, 0xad, 0xae, 0xb6, 0xc1, 0xc7, 0xc3, 0xb8, 0xae, 0xab, 0xb5, 0xc6, 0xd4, + 0xdf, 0xd7, 0xcb, 0xca, 0xd4, 0xd9, 0xd7, 0xd3, 0xc7, 0xbd, 0xbc, 0xc2, 0xc5, 0xc6, 0xc7, 0xc6, 0xc4, 0xc2, 0xc6, 0xc6, 0xcb, 0xd2, + 0xd1, 0xd2, 0xd5, 0xd8, 0xd0, 0xcc, 0xd1, 0xdb, 0xe2, 0xe7, 0xea, 0xdf, 0xd4, 0xce, 0xcb, 0xc7, 0xc8, 0xcf, 0xd9, 0xe8, 0xf3, 0xf6, + 0xf0, 0xef, 0xf1, 0xee, 0xeb, 0xeb, 0xef, 0xf1, 0xf0, 0xed, 0xea, 0xeb, 0xf4, 0xff, 0x05, 0x01, 0xff, 0xff, 0xf5, 0xfe, 0x13, 0x25, + 0x31, 0x31, 0x24, 0x13, 0x0f, 0x1a, 0x28, 0x2b, 0x22, 0x1b, 0x21, 0x2e, 0x37, 0x38, 0x34, 0x3c, 0x4a, 0x51, 0x4a, 0x38, 0x2e, 0x37, + 0x42, 0x4b, 0x55, 0x62, 0x59, 0x46, 0x39, 0x37, 0x3e, 0x48, 0x4e, 0x49, 0x3e, 0x33, 0x2a, 0x2d, 0x38, 0x44, 0x46, 0x4c, 0x53, 0x4f, + 0x46, 0x3b, 0x34, 0x33, 0x38, 0x3f, 0x45, 0x49, 0x45, 0x3a, 0x33, 0x35, 0x3e, 0x47, 0x49, 0x40, 0x36, 0x34, 0x33, 0x2f, 0x2c, 0x2e, + 0x36, 0x39, 0x33, 0x27, 0x24, 0x2c, 0x2f, 0x29, 0x1d, 0x15, 0x1c, 0x23, 0x22, 0x1c, 0x1c, 0x26, 0x31, 0x34, 0x22, 0x11, 0x0a, 0x03, + 0x00, 0x05, 0x0c, 0x0e, 0x07, 0x02, 0x08, 0x1a, 0x25, 0x23, 0x18, 0x0e, 0x0a, 0x08, 0x05, 0x06, 0x0b, 0x0c, 0x0a, 0x05, 0xff, 0xf7, + 0xf0, 0xec, 0xe9, 0xee, 0xf3, 0xf6, 0xfd, 0x02, 0x05, 0x08, 0x0b, 0x06, 0xfe, 0xfb, 0xf7, 0xf6, 0xf2, 0xed, 0xe7, 0xe8, 0xf0, 0xfa, + 0xfe, 0xfe, 0xff, 0xfe, 0xfb, 0xfa, 0x00, 0x03, 0xff, 0xf5, 0xe5, 0xe2, 0xe7, 0xe5, 0xe2, 0xe6, 0xef, 0xed, 0xeb, 0xea, 0xec, 0xec, + 0xf1, 0xf5, 0xf4, 0xef, 0xe5, 0xd7, 0xcc, 0xc4, 0xc3, 0xcb, 0xda, 0xd9, 0xcb, 0xc3, 0xbc, 0xb7, 0xb4, 0xb5, 0xb3, 0xb4, 0xbe, 0xb7, + 0xb7, 0xc4, 0xd2, 0xca, 0xc2, 0xc7, 0xbf, 0xb8, 0xb4, 0xb2, 0xaf, 0xb3, 0xb8, 0xb4, 0xb9, 0xc2, 0xc6, 0xc0, 0xbb, 0xbb, 0xba, 0xb8, + 0xb8, 0xb7, 0xaf, 0xac, 0xaf, 0xb3, 0xbb, 0xbc, 0xba, 0xbd, 0xca, 0xd1, 0xd2, 0xdb, 0xe5, 0xee, 0xf1, 0xee, 0xe5, 0xde, 0xe2, 0xe6, + 0xe5, 0xde, 0xd8, 0xdc, 0xe8, 0xf2, 0xee, 0xe3, 0xdb, 0xdf, 0xe6, 0xf8, 0x10, 0x1c, 0x18, 0x0a, 0x00, 0x06, 0x11, 0x16, 0x14, 0x16, + 0x1a, 0x1a, 0x14, 0x12, 0x10, 0x0a, 0x04, 0x04, 0x0c, 0x15, 0x1a, 0x1a, 0x19, 0x1d, 0x20, 0x22, 0x27, 0x2a, 0x24, 0x1b, 0x22, 0x2c, + 0x31, 0x30, 0x35, 0x34, 0x2c, 0x25, 0x16, 0x0c, 0x14, 0x30, 0x3a, 0x33, 0x2a, 0x25, 0x24, 0x26, 0x2a, 0x29, 0x2a, 0x2b, 0x25, 0x1c, + 0x1a, 0x26, 0x2e, 0x34, 0x37, 0x36, 0x3b, 0x44, 0x46, 0x3a, 0x2c, 0x22, 0x20, 0x23, 0x20, 0x18, 0x16, 0x19, 0x1e, 0x25, 0x2f, 0x3a, + 0x40, 0x3d, 0x3c, 0x42, 0x49, 0x46, 0x3f, 0x3a, 0x3b, 0x40, 0x3f, 0x32, 0x1f, 0x15, 0x11, 0x0e, 0x0d, 0x13, 0x1d, 0x28, 0x2d, 0x33, + 0x3c, 0x49, 0x46, 0x3c, 0x33, 0x2c, 0x25, 0x24, 0x29, 0x28, 0x1f, 0x12, 0x0c, 0x0f, 0x19, 0x22, 0x26, 0x22, 0x1e, 0x1d, 0x1b, 0x14, + 0x07, 0xfc, 0xfe, 0x08, 0x15, 0x20, 0x26, 0x21, 0x14, 0x0e, 0x10, 0x16, 0x1b, 0x14, 0x07, 0xf9, 0xe7, 0xe1, 0xe7, 0xf1, 0xf7, 0xfd, + 0x03, 0x08, 0x05, 0xfc, 0xf5, 0xf0, 0xf1, 0xf1, 0xe9, 0xdb, 0xd5, 0xd7, 0xcf, 0xd0, 0xd8, 0xe2, 0xf0, 0xfa, 0xf7, 0xe7, 0xe4, 0xe6, + 0xe5, 0xdf, 0xdb, 0xd9, 0xd6, 0xd2, 0xce, 0xcd, 0xcd, 0xd5, 0xdc, 0xdd, 0xd8, 0xdc, 0xe1, 0xd8, 0xd8, 0xd8, 0xd7, 0xdc, 0xdc, 0xd4, + 0xc7, 0xbb, 0xb4, 0xb5, 0xbe, 0xc4, 0xc3, 0xbd, 0xba, 0xc2, 0xd0, 0xd7, 0xd0, 0xc6, 0xbd, 0xb5, 0xb7, 0xc2, 0xce, 0xd3, 0xc5, 0xb2, + 0xaa, 0xb5, 0xc0, 0xbf, 0xb8, 0xb0, 0xab, 0xa7, 0xa5, 0xae, 0xbc, 0xc7, 0xcf, 0xd3, 0xd2, 0xcb, 0xc9, 0xcb, 0xd0, 0xd4, 0xd3, 0xcf, + 0xcd, 0xd3, 0xd6, 0xd1, 0xcf, 0xcd, 0xd1, 0xda, 0xe1, 0xe8, 0xef, 0xf5, 0xf7, 0xf8, 0xfb, 0xfc, 0x01, 0x01, 0xf8, 0xea, 0xec, 0xf9, + 0x04, 0x07, 0x01, 0xf8, 0xf6, 0xfb, 0x06, 0x10, 0x15, 0x10, 0x0b, 0x12, 0x15, 0x16, 0x14, 0x0f, 0x08, 0x0a, 0x17, 0x1b, 0x19, 0x1c, + 0x28, 0x34, 0x32, 0x23, 0x19, 0x1b, 0x22, 0x21, 0x27, 0x29, 0x29, 0x2c, 0x35, 0x36, 0x2e, 0x2b, 0x2c, 0x35, 0x41, 0x41, 0x35, 0x28, + 0x26, 0x28, 0x32, 0x41, 0x43, 0x48, 0x4f, 0x50, 0x46, 0x3a, 0x32, 0x2a, 0x25, 0x2c, 0x3d, 0x44, 0x44, 0x3d, 0x36, 0x36, 0x3e, 0x47, + 0x45, 0x43, 0x3c, 0x2d, 0x2d, 0x2a, 0x25, 0x29, 0x32, 0x38, 0x3a, 0x35, 0x35, 0x31, 0x1f, 0x0e, 0x08, 0x11, 0x21, 0x2a, 0x26, 0x1d, + 0x24, 0x2b, 0x2a, 0x21, 0x16, 0x11, 0x15, 0x1d, 0x1e, 0x17, 0x0f, 0x0a, 0x10, 0x1d, 0x29, 0x28, 0x22, 0x1d, 0x17, 0x17, 0x1d, 0x24, + 0x17, 0x0e, 0x0d, 0x0a, 0x0b, 0x14, 0x1d, 0x17, 0x0e, 0x07, 0x04, 0x15, 0x1d, 0x18, 0x13, 0x0b, 0xfe, 0xf1, 0xf0, 0xff, 0x0e, 0x0d, + 0x01, 0xfc, 0xfc, 0xf3, 0xea, 0xe8, 0xee, 0xf2, 0xf8, 0xfa, 0xf0, 0xdf, 0xd0, 0xcb, 0xd4, 0xe9, 0xf8, 0xf5, 0xe8, 0xde, 0xda, 0xdb, + 0xd2, 0xcd, 0xd1, 0xd1, 0xcd, 0xcc, 0xcf, 0xcb, 0xca, 0xcd, 0xcf, 0xd8, 0xde, 0xdb, 0xd4, 0xcb, 0xbd, 0xae, 0xb7, 0xc3, 0xca, 0xcd, + 0xd1, 0xd1, 0xcb, 0xc8, 0xca, 0xcd, 0xcd, 0xc9, 0xc7, 0xca, 0xca, 0xc8, 0xc6, 0xc8, 0xcd, 0xca, 0xc8, 0xd0, 0xd8, 0xdb, 0xd9, 0xd8, + 0xd3, 0xce, 0xcc, 0xcb, 0xcd, 0xd2, 0xd7, 0xd6, 0xca, 0xbe, 0xc8, 0xd8, 0xe0, 0xdb, 0xd0, 0xcc, 0xd1, 0xd6, 0xd8, 0xd2, 0xca, 0xcd, + 0xd5, 0xe1, 0xef, 0xf9, 0xf7, 0xee, 0xe9, 0xec, 0xf3, 0xf6, 0xf1, 0xf0, 0xf0, 0xec, 0xe5, 0xe4, 0xea, 0xf2, 0xfc, 0x02, 0x01, 0xfb, + 0xf9, 0xf9, 0xf8, 0xfa, 0x04, 0x0d, 0x08, 0x01, 0xff, 0x03, 0x0e, 0x18, 0x1a, 0x15, 0x12, 0x13, 0x15, 0x13, 0x08, 0x06, 0x14, 0x1e, + 0x1e, 0x19, 0x15, 0x1a, 0x1c, 0x1a, 0x1c, 0x2b, 0x39, 0x39, 0x38, 0x37, 0x32, 0x2a, 0x29, 0x32, 0x3f, 0x42, 0x38, 0x32, 0x3b, 0x43, + 0x40, 0x33, 0x26, 0x2b, 0x3c, 0x4c, 0x51, 0x4f, 0x4a, 0x45, 0x42, 0x40, 0x3c, 0x39, 0x2a, 0x25, 0x30, 0x37, 0x36, 0x33, 0x3a, 0x35, + 0x38, 0x41, 0x42, 0x38, 0x2b, 0x25, 0x24, 0x28, 0x2d, 0x30, 0x2d, 0x1f, 0x10, 0x15, 0x21, 0x2b, 0x2e, 0x27, 0x1e, 0x18, 0x13, 0x05, + 0x01, 0x0d, 0x18, 0x1e, 0x1e, 0x18, 0x09, 0x05, 0x0a, 0x0a, 0x08, 0x01, 0xfa, 0xf4, 0xfc, 0x09, 0x0c, 0x08, 0x04, 0x04, 0x02, 0x01, + 0xfe, 0xf9, 0xf5, 0xfb, 0x08, 0x13, 0x15, 0x06, 0xf0, 0xe2, 0xe6, 0xf1, 0xf8, 0xf5, 0xf1, 0xef, 0xec, 0xef, 0xf1, 0xf1, 0xf5, 0x03, + 0x0c, 0x03, 0xf1, 0xe5, 0xe7, 0xee, 0xf1, 0xeb, 0xe4, 0xe6, 0xf0, 0xf3, 0xeb, 0xe9, 0xf0, 0xf9, 0xfa, 0xfc, 0xfc, 0xf3, 0xde, 0xd3, + 0xd6, 0xdf, 0xe3, 0xe4, 0xe6, 0xe9, 0xf4, 0xfa, 0xf5, 0xee, 0xeb, 0xec, 0xef, 0xf4, 0xf8, 0xf4, 0xe6, 0xdc, 0xdc, 0xe3, 0xeb, 0xee, + 0xe7, 0xd8, 0xd3, 0xd4, 0xd5, 0xd7, 0xd4, 0xd1, 0xcf, 0xd1, 0xd0, 0xd5, 0xe6, 0xe9, 0xdb, 0xca, 0xc9, 0xd0, 0xdd, 0xe7, 0xde, 0xcd, + 0xc3, 0xc7, 0xd0, 0xd9, 0xdf, 0xe2, 0xe2, 0xe2, 0xdf, 0xd4, 0xcf, 0xd6, 0xe5, 0xe6, 0xdc, 0xd5, 0xd7, 0xdc, 0xdc, 0xd5, 0xd4, 0xd5, + 0xd6, 0xdb, 0xe5, 0xf3, 0xff, 0x02, 0xfc, 0xf4, 0xf0, 0xef, 0xe8, 0xdf, 0xe3, 0xe1, 0xe0, 0xe5, 0xf4, 0x00, 0x01, 0xfa, 0x00, 0x05, + 0x02, 0xfc, 0xf7, 0xf3, 0xf2, 0x05, 0x11, 0x0e, 0x09, 0xfb, 0xf9, 0x09, 0x14, 0x0f, 0x08, 0x0d, 0x0e, 0x13, 0x1a, 0x18, 0x1a, 0x1a, + 0x13, 0x10, 0x15, 0x19, 0x15, 0x0c, 0x07, 0x0c, 0x16, 0x26, 0x32, 0x32, 0x29, 0x1e, 0x15, 0x13, 0x16, 0x1d, 0x22, 0x23, 0x20, 0x1b, + 0x18, 0x1c, 0x25, 0x2c, 0x2a, 0x27, 0x1f, 0x17, 0x15, 0x1a, 0x1d, 0x1f, 0x26, 0x2b, 0x2a, 0x27, 0x1b, 0x17, 0x21, 0x28, 0x23, 0x1d, + 0x20, 0x1e, 0x1b, 0x15, 0x0d, 0x05, 0x05, 0x0c, 0x10, 0x15, 0x1c, 0x24, 0x23, 0x1d, 0x16, 0x0e, 0x0e, 0x13, 0x16, 0x0d, 0x0c, 0x11, + 0x17, 0x1d, 0x28, 0x2f, 0x29, 0x1d, 0x18, 0x18, 0x13, 0x0b, 0x08, 0x0e, 0x1c, 0x1d, 0x13, 0x16, 0x13, 0x10, 0x0d, 0x0d, 0x06, 0x02, + 0x09, 0x0c, 0x11, 0x16, 0x16, 0x1a, 0x1e, 0x1c, 0x16, 0x10, 0x0c, 0x06, 0x07, 0x05, 0xff, 0x02, 0x03, 0x07, 0x0f, 0x18, 0x19, 0x13, + 0x0b, 0x05, 0xff, 0xfc, 0xff, 0x06, 0x08, 0x00, 0xf9, 0xfc, 0x08, 0x14, 0x0e, 0x01, 0xfb, 0xf7, 0xf4, 0xf3, 0xf6, 0xfb, 0xff, 0xfd, + 0xf7, 0xfa, 0xff, 0xfe, 0x00, 0xff, 0xfa, 0xf4, 0xf1, 0xef, 0xee, 0xef, 0xed, 0xe5, 0xdb, 0xe4, 0xf5, 0xfd, 0xf3, 0xe9, 0xe5, 0xe4, + 0xe1, 0xe1, 0xe1, 0xe2, 0xe8, 0xeb, 0xe6, 0xdc, 0xd8, 0xd2, 0xc8, 0xc7, 0xcd, 0xd6, 0xdb, 0xe0, 0xdf, 0xd9, 0xda, 0xd5, 0xd1, 0xd2, + 0xd2, 0xcf, 0xd0, 0xdb, 0xe2, 0xe2, 0xdd, 0xd5, 0xd6, 0xdc, 0xdf, 0xe3, 0xe4, 0xe1, 0xdc, 0xd9, 0xd9, 0xdf, 0xe5, 0xe9, 0xe8, 0xe6, + 0xe3, 0xe4, 0xe4, 0xdd, 0xda, 0xe2, 0xf2, 0xfe, 0xff, 0xf2, 0xdd, 0xd3, 0xda, 0xe9, 0xf5, 0xf8, 0xfb, 0xfd, 0xf0, 0xe6, 0xe6, 0xef, + 0xf7, 0xfa, 0xf8, 0xf6, 0xf9, 0xf9, 0xf5, 0x03, 0x05, 0x00, 0x05, 0x01, 0xfe, 0xfa, 0xee, 0xe3, 0xe2, 0xeb, 0xef, 0xf2, 0xf5, 0xf5, + 0xfb, 0x07, 0x14, 0x14, 0x12, 0x0e, 0x09, 0x08, 0x08, 0x08, 0x05, 0x04, 0x03, 0x02, 0x05, 0x0a, 0x0d, 0x0c, 0x0b, 0x10, 0x16, 0x18, + 0x16, 0x11, 0x0c, 0x09, 0x0a, 0x13, 0x23, 0x27, 0x22, 0x1d, 0x1d, 0x1b, 0x1a, 0x1d, 0x1a, 0x1e, 0x21, 0x1b, 0x17, 0x1b, 0x20, 0x17, + 0x14, 0x16, 0x1c, 0x29, 0x29, 0x1b, 0x0e, 0x16, 0x21, 0x26, 0x2d, 0x2a, 0x24, 0x23, 0x27, 0x28, 0x25, 0x27, 0x23, 0x1d, 0x17, 0x14, + 0x13, 0x16, 0x1c, 0x27, 0x2c, 0x26, 0x1a, 0x1b, 0x1e, 0x1b, 0x1b, 0x1b, 0x20, 0x27, 0x1d, 0x10, 0x12, 0x2c, 0x2f, 0x24, 0x1d, 0x18, + 0x0d, 0x07, 0x0f, 0x17, 0x16, 0x0f, 0x0e, 0x11, 0x1b, 0x24, 0x1d, 0x13, 0x0f, 0x10, 0x13, 0x10, 0x06, 0xff, 0xff, 0x08, 0x11, 0x0e, + 0x06, 0x04, 0x0e, 0x0e, 0x08, 0x02, 0xff, 0x00, 0x03, 0x06, 0x0a, 0x06, 0xf9, 0xf0, 0xee, 0xf2, 0xf8, 0xf7, 0xf6, 0xf8, 0xfe, 0x03, + 0x04, 0x02, 0xfe, 0xf5, 0xef, 0xf1, 0xef, 0xf0, 0xf3, 0xf4, 0xe8, 0xe1, 0xe3, 0xe6, 0xea, 0xec, 0xea, 0xe1, 0xdf, 0xe2, 0xe2, 0xda, + 0xd9, 0xe1, 0xe7, 0xe5, 0xe4, 0xec, 0xf0, 0xef, 0xed, 0xef, 0xee, 0xea, 0xe9, 0xed, 0xe8, 0xde, 0xd6, 0xd6, 0xd2, 0xd0, 0xde, 0xe6, + 0xea, 0xeb, 0xeb, 0xe8, 0xe8, 0xeb, 0xe3, 0xde, 0xe0, 0xe4, 0xe6, 0xe3, 0xda, 0xd0, 0xcf, 0xd7, 0xe0, 0xe4, 0xe3, 0xe2, 0xe0, 0xe0, + 0xdb, 0xd6, 0xd7, 0xdf, 0xe7, 0xe8, 0xe8, 0xea, 0xee, 0xf0, 0xea, 0xe1, 0xdc, 0xd7, 0xdc, 0xe6, 0xec, 0xe9, 0xe3, 0xdf, 0xdc, 0xd7, + 0xd6, 0xde, 0xe9, 0xee, 0xed, 0xed, 0xf5, 0xf7, 0xed, 0xe3, 0xda, 0xdc, 0xe9, 0xf1, 0xf7, 0xfc, 0xfc, 0xfa, 0xfd, 0x03, 0x00, 0xfc, + 0xf9, 0xf9, 0xfa, 0xfd, 0x01, 0x03, 0x07, 0x08, 0x07, 0x06, 0x05, 0x06, 0x0a, 0x0e, 0x13, 0x16, 0x14, 0x0f, 0x0f, 0x17, 0x1c, 0x1f, + 0x1d, 0x10, 0x00, 0xf9, 0xfe, 0x0e, 0x1d, 0x25, 0x27, 0x27, 0x25, 0x23, 0x1f, 0x24, 0x28, 0x23, 0x19, 0x0d, 0x05, 0x08, 0x14, 0x27, + 0x36, 0x38, 0x33, 0x2c, 0x24, 0x1e, 0x1d, 0x1f, 0x1f, 0x21, 0x1f, 0x1d, 0x20, 0x2a, 0x30, 0x2b, 0x24, 0x1f, 0x1c, 0x18, 0x1d, 0x21, + 0x20, 0x1e, 0x1c, 0x1f, 0x27, 0x2e, 0x29, 0x1f, 0x1b, 0x1a, 0x18, 0x15, 0x12, 0x17, 0x1b, 0x18, 0x13, 0x19, 0x1e, 0x13, 0x16, 0x1d, + 0x1d, 0x16, 0x12, 0x11, 0x0e, 0x0c, 0x09, 0x08, 0x0b, 0x0f, 0x10, 0x0c, 0x04, 0x03, 0x0b, 0x15, 0x18, 0x10, 0x07, 0x05, 0x09, 0x0f, + 0x15, 0x19, 0x16, 0x0d, 0x05, 0xfd, 0xf8, 0xf9, 0xfe, 0xf8, 0xf4, 0xfa, 0x03, 0x08, 0x08, 0x07, 0xfe, 0xf8, 0xf6, 0xf2, 0xf4, 0xf9, + 0xfb, 0xed, 0xea, 0xf4, 0xfa, 0xfa, 0xf5, 0xf1, 0xf0, 0xed, 0xea, 0xe9, 0xf1, 0xf1, 0xeb, 0xe5, 0xe2, 0xe1, 0xe2, 0xe8, 0xea, 0xe6, + 0xdf, 0xd7, 0xda, 0xe3, 0xe9, 0xe7, 0xe4, 0xe5, 0xe6, 0xe3, 0xe2, 0xe7, 0xef, 0xed, 0xe4, 0xdf, 0xdc, 0xda, 0xdc, 0xe6, 0xeb, 0xe8, + 0xdf, 0xda, 0xdb, 0xe1, 0xea, 0xe8, 0xe1, 0xde, 0xe5, 0xe4, 0xdd, 0xdb, 0xe1, 0xe3, 0xdf, 0xe2, 0xe4, 0xe6, 0xe7, 0xe4, 0xe2, 0xe2, + 0xe5, 0xe6, 0xe8, 0xed, 0xed, 0xea, 0xe6, 0xe4, 0xe1, 0xe0, 0xe5, 0xf1, 0xf7, 0xf5, 0xf0, 0xeb, 0xe3, 0xe0, 0xe5, 0xf3, 0xf9, 0xf6, + 0xf3, 0xf3, 0xf3, 0xf2, 0xf1, 0xf0, 0xf1, 0xf9, 0xfd, 0xfc, 0xf9, 0xf4, 0xf5, 0xfa, 0xfd, 0xfd, 0xfd, 0x01, 0x0a, 0x17, 0x1c, 0x18, + 0x13, 0x0a, 0x02, 0xfe, 0xf9, 0xfc, 0x08, 0x14, 0x16, 0x14, 0x12, 0x11, 0x10, 0x10, 0x10, 0x0c, 0x08, 0x08, 0x0d, 0x16, 0x20, 0x22, + 0x13, 0x0b, 0x0c, 0x0f, 0x14, 0x19, 0x1a, 0x10, 0x03, 0xfc, 0x03, 0x1b, 0x26, 0x20, 0x19, 0x14, 0x13, 0x15, 0x18, 0x1f, 0x23, 0x21, + 0x18, 0x17, 0x1c, 0x1a, 0x1a, 0x1d, 0x1d, 0x15, 0x10, 0x11, 0x17, 0x21, 0x22, 0x1d, 0x1f, 0x28, 0x2b, 0x23, 0x17, 0x13, 0x16, 0x1a, + 0x1d, 0x1c, 0x17, 0x12, 0x0d, 0x08, 0x09, 0x15, 0x26, 0x2a, 0x1e, 0x11, 0x12, 0x1b, 0x1b, 0x1c, 0x1a, 0x15, 0x0e, 0x04, 0xf9, 0xf3, + 0xfd, 0x0d, 0x17, 0x17, 0x0e, 0x04, 0x04, 0x0d, 0x0e, 0x08, 0x05, 0x01, 0xfa, 0xf3, 0xf4, 0xf8, 0xff, 0x06, 0x05, 0xfb, 0xf1, 0xf1, + 0xf3, 0xf7, 0xfa, 0xf9, 0xf7, 0xf8, 0xfe, 0xfb, 0xf8, 0xfb, 0xff, 0xfc, 0xfa, 0xfc, 0xf7, 0xf1, 0xef, 0xf5, 0xfc, 0x03, 0x04, 0xfb, + 0xf6, 0xf4, 0xf0, 0xe6, 0xe1, 0xe6, 0xf1, 0xf7, 0xf6, 0xf4, 0xfa, 0x02, 0x07, 0x05, 0xfd, 0xf5, 0xf2, 0xf5, 0xf3, 0xee, 0xe8, 0xe2, + 0xe0, 0xe4, 0xea, 0xec, 0xf2, 0xf9, 0xf8, 0xf0, 0xe9, 0xea, 0xf1, 0xf7, 0xf6, 0xf0, 0xe5, 0xdf, 0xde, 0xde, 0xe0, 0xea, 0xf6, 0xf7, + 0xf0, 0xe4, 0xdc, 0xd8, 0xde, 0xe7, 0xec, 0xef, 0xf2, 0xf7, 0xfa, 0xfe, 0xff, 0xfc, 0xf4, 0xee, 0xed, 0xf2, 0xf5, 0xf8, 0xfa, 0xf9, + 0xfa, 0xfa, 0xfb, 0xf7, 0xfa, 0x00, 0xfe, 0xf6, 0xed, 0xe5, 0xe7, 0xe8, 0xec, 0xfa, 0x03, 0xfd, 0xf1, 0xf2, 0xf2, 0xf5, 0xfd, 0xfe, + 0xfb, 0xf5, 0xf0, 0xf0, 0xf9, 0x04, 0x09, 0xfe, 0xeb, 0xe2, 0xe8, 0xf4, 0xfd, 0x03, 0x01, 0xfd, 0xfb, 0x04, 0x06, 0x00, 0xfc, 0xfe, + 0x01, 0xff, 0xfd, 0xfa, 0xf8, 0xf6, 0xf8, 0xf9, 0xfc, 0x03, 0x02, 0xff, 0xff, 0x04, 0x07, 0x0f, 0x1a, 0x1b, 0x0f, 0x02, 0xfe, 0x07, + 0x0e, 0x0e, 0x0f, 0x10, 0x0f, 0x0b, 0x11, 0x17, 0x1a, 0x1b, 0x17, 0x10, 0x09, 0x0a, 0x10, 0x18, 0x1c, 0x16, 0x0e, 0x07, 0x04, 0xfe, + 0xf9, 0xfa, 0x02, 0x0c, 0x18, 0x23, 0x25, 0x1f, 0x13, 0x06, 0x05, 0x0c, 0x11, 0x0f, 0x0c, 0x06, 0xfe, 0xfb, 0x01, 0x0d, 0x18, 0x18, + 0x11, 0x0a, 0x00, 0x00, 0x05, 0x05, 0x03, 0x0b, 0x1a, 0x21, 0x23, 0x1b, 0x0a, 0xfe, 0xfc, 0xfe, 0xfe, 0x03, 0x08, 0x08, 0x01, 0xfe, + 0x02, 0x0c, 0x19, 0x1c, 0x14, 0x09, 0x01, 0xfe, 0xfd, 0x01, 0x05, 0x0b, 0x12, 0x15, 0x12, 0x0f, 0x0e, 0x0b, 0x09, 0x0b, 0x06, 0x03, + 0xff, 0xf9, 0xff, 0x05, 0x09, 0x0f, 0x0f, 0x0b, 0x02, 0xf5, 0xef, 0xf3, 0xfc, 0x01, 0x05, 0x08, 0x03, 0x04, 0x07, 0x07, 0x00, 0xfe, + 0xff, 0xfa, 0xf8, 0xfc, 0x04, 0x05, 0x03, 0x03, 0x04, 0xfe, 0xf5, 0xef, 0xf2, 0xf5, 0xf8, 0xfd, 0x01, 0xfc, 0xf4, 0xf2, 0xf5, 0xfa, + 0xfc, 0xfa, 0xf4, 0xf5, 0xfb, 0x00, 0xfd, 0xf7, 0xf4, 0xf2, 0xf0, 0xf0, 0xf3, 0xfb, 0x00, 0xfc, 0xfb, 0xf5, 0xf0, 0xf2, 0xf9, 0xfc, + 0xf8, 0xf7, 0xf2, 0xef, 0xf0, 0xf0, 0xee, 0xed, 0xeb, 0xe4, 0xe0, 0xe1, 0xe6, 0xf0, 0xf9, 0xfd, 0xfb, 0xf5, 0xf0, 0xf2, 0xf8, 0xfa, + 0xf7, 0xf8, 0xf5, 0xf4, 0xf6, 0xf3, 0xed, 0xeb, 0xf5, 0xf3, 0xef, 0xf1, 0xf8, 0xf9, 0xf8, 0xfa, 0xfa, 0xfb, 0xfc, 0xfb, 0x00, 0x04, + 0x03, 0xfb, 0xf8, 0xfb, 0xfd, 0xfc, 0xfb, 0xfd, 0xfd, 0xff, 0x02, 0x04, 0x05, 0x06, 0x04, 0xfd, 0xfb, 0xfb, 0xf9, 0xf5, 0xfa, 0x02, + 0x02, 0xfe, 0xf9, 0xf3, 0xf0, 0xf8, 0x06, 0x0f, 0x12, 0x0c, 0x04, 0x01, 0xfe, 0xf9, 0xf6, 0xf6, 0xf6, 0xf6, 0xf4, 0xef, 0xf3, 0xfa, + 0xfd, 0x03, 0x07, 0x09, 0x04, 0x03, 0x00, 0xfa, 0xf9, 0xfe, 0x04, 0x04, 0x01, 0xfb, 0xf6, 0xf1, 0xf1, 0xf8, 0x02, 0x09, 0x09, 0x05, + 0x03, 0x03, 0x01, 0xff, 0x07, 0x0f, 0x0f, 0x08, 0x03, 0x04, 0x09, 0x0d, 0x06, 0xff, 0xff, 0x03, 0x03, 0x01, 0x02, 0x00, 0x04, 0x0d, + 0x14, 0x15, 0x12, 0x0e, 0x0a, 0x07, 0x08, 0x0a, 0x0f, 0x12, 0x11, 0x12, 0x11, 0x10, 0x0f, 0x0e, 0x0e, 0x0f, 0x0f, 0x0c, 0x0d, 0x11, + 0x15, 0x0f, 0x0b, 0x0f, 0x16, 0x14, 0x0b, 0x06, 0x09, 0x11, 0x16, 0x12, 0x0f, 0x0a, 0x02, 0x05, 0x0b, 0x11, 0x17, 0x1b, 0x17, 0x10, + 0x0f, 0x0b, 0x07, 0x05, 0x0c, 0x0d, 0x0a, 0x09, 0x07, 0x01, 0xfb, 0x00, 0x04, 0x09, 0x0e, 0x0a, 0x02, 0xfc, 0xfe, 0x04, 0x07, 0x00, + 0xf4, 0xf3, 0xf9, 0xfc, 0xfc, 0xfa, 0xf7, 0xf5, 0xf5, 0xf8, 0xfc, 0x01, 0xfe, 0xf9, 0xfb, 0xf5, 0xf3, 0xf6, 0xf8, 0xf3, 0xf1, 0xf5, + 0xf6, 0xf5, 0xf0, 0xe8, 0xeb, 0xf0, 0xf0, 0xed, 0xf0, 0xf9, 0x00, 0x03, 0xfe, 0xf7, 0xf7, 0xf5, 0xef, 0xeb, 0xf1, 0xf6, 0xf8, 0xfa, + 0xfd, 0xf9, 0xf2, 0xf1, 0xf2, 0xf6, 0xfb, 0xf8, 0xf4, 0xf5, 0xfb, 0x00, 0x06, 0x07, 0x00, 0xf8, 0xf4, 0xf6, 0x00, 0x03, 0xff, 0xf6, + 0xf2, 0xf3, 0xf8, 0x02, 0x04, 0x00, 0xfd, 0xfc, 0xf8, 0xf5, 0xf7, 0xfc, 0x00, 0xfd, 0xf7, 0xee, 0xed, 0xf4, 0xfa, 0xf8, 0xf4, 0xf7, + 0xf7, 0xf1, 0xeb, 0xf2, 0xfc, 0x02, 0xff, 0xf4, 0xef, 0xf1, 0xf5, 0xf9, 0xfd, 0x01, 0xff, 0xfb, 0xf6, 0xf0, 0xee, 0xee, 0xf3, 0xff, + 0x02, 0xff, 0xfa, 0xf2, 0xed, 0xef, 0xf7, 0xf9, 0xf9, 0xf8, 0xf5, 0xf6, 0xf8, 0xf8, 0xfa, 0xfc, 0x00, 0x02, 0x08, 0x06, 0xfd, 0xf8, + 0xf4, 0xf8, 0x00, 0x05, 0x02, 0xfc, 0xf9, 0xf4, 0xf9, 0x05, 0x09, 0x07, 0x08, 0x0e, 0x0d, 0x08, 0x02, 0xfd, 0x02, 0x07, 0x06, 0x06, + 0x06, 0x08, 0x0a, 0x0b, 0x08, 0x06, 0x0b, 0x0d, 0x10, 0x15, 0x14, 0x0d, 0x06, 0x05, 0x04, 0x08, 0x0c, 0x0a, 0x08, 0x09, 0x0c, 0x0e, + 0x12, 0x15, 0x11, 0x0a, 0x07, 0x0c, 0x15, 0x1a, 0x17, 0x0f, 0x0d, 0x0c, 0x09, 0x06, 0x05, 0x06, 0x09, 0x0e, 0x10, 0x0e, 0x0d, 0x0f, + 0x15, 0x1a, 0x1c, 0x12, 0x09, 0x07, 0x03, 0x07, 0x0f, 0x12, 0x09, 0x01, 0xff, 0x00, 0x06, 0x0e, 0x11, 0x10, 0x0f, 0x0f, 0x0d, 0x08, + 0x01, 0xfb, 0xfc, 0x02, 0x09, 0x0e, 0x0c, 0x08, 0x05, 0x04, 0xff, 0xf9, 0xf5, 0xf7, 0xfa, 0xff, 0x05, 0x07, 0xff, 0xf5, 0xf7, 0xf9, + 0xfc, 0xfc, 0xf8, 0xf1, 0xf1, 0xfb, 0xfd, 0xfc, 0xfa, 0xf9, 0xf9, 0xfa, 0xfb, 0xf9, 0xfa, 0xfc, 0xfa, 0xfa, 0xf7, 0xf1, 0xec, 0xee, + 0xf2, 0xf4, 0xf3, 0xf5, 0xf6, 0xf5, 0xfa, 0xfd, 0xfb, 0xf7, 0xf7, 0xf9, 0xfb, 0xfd, 0xfa, 0xf3, 0xef, 0xf2, 0xf9, 0xfb, 0xf7, 0xf2, + 0xf2, 0xf8, 0xfa, 0xf7, 0xf5, 0xf8, 0xfc, 0xfe, 0xfb, 0xf6, 0xf5, 0xf7, 0xf8, 0xf8, 0xf5, 0xf0, 0xf0, 0xf0, 0xf3, 0xf8, 0xfd, 0xfc, + 0xf4, 0xec, 0xee, 0xf9, 0x02, 0x02, 0x03, 0x03, 0x02, 0x01, 0x00, 0xfe, 0xfa, 0xf8, 0xf8, 0xf7, 0xf3, 0xef, 0xf0, 0xf5, 0xfb, 0xfd, + 0xfc, 0xfd, 0x02, 0x03, 0xfd, 0xf8, 0xf7, 0xfa, 0xff, 0x08, 0x08, 0x02, 0xfd, 0xfc, 0xfd, 0xff, 0xff, 0x00, 0x00, 0xfd, 0xfd, 0xfd, + 0xfd, 0xfe, 0xfd, 0xfc, 0xfd, 0xff, 0x03, 0x04, 0x02, 0x01, 0x01, 0xff, 0xf9, 0xf8, 0xfd, 0x04, 0x08, 0x07, 0x04, 0x02, 0x02, 0x03, + 0x02, 0xfd, 0xf8, 0xf6, 0xf8, 0xfc, 0x00, 0x02, 0x05, 0x0b, 0x0d, 0x08, 0x04, 0xfe, 0xfa, 0xfb, 0xfd, 0x01, 0x07, 0x0a, 0x08, 0x07, + 0x0a, 0x0c, 0x11, 0x12, 0x0a, 0x04, 0xff, 0xfd, 0xfe, 0x08, 0x0f, 0x0f, 0x0e, 0x0b, 0x0a, 0x0c, 0x0b, 0x07, 0x05, 0x06, 0x08, 0x0c, + 0x12, 0x10, 0x0f, 0x0c, 0x05, 0x01, 0x01, 0x04, 0x07, 0x07, 0x03, 0x01, 0x05, 0x0b, 0x0f, 0x0f, 0x0a, 0x08, 0x0a, 0x09, 0x07, 0x05, + 0x05, 0x03, 0x04, 0x04, 0x02, 0x05, 0x09, 0x08, 0x04, 0x04, 0x08, 0x0c, 0x0a, 0x07, 0x03, 0x00, 0xfd, 0xf9, 0xf7, 0xfb, 0xff, 0x00, + 0xff, 0xfd, 0xfb, 0xfb, 0x00, 0x04, 0x06, 0x07, 0x06, 0x04, 0x00, 0xfb, 0xf6, 0xf9, 0xfd, 0xfb, 0xf4, 0xed, 0xea, 0xed, 0xf4, 0xfc, + 0x04, 0x09, 0x04, 0xfc, 0xfa, 0xf6, 0xf3, 0xf4, 0xfc, 0xfd, 0xf8, 0xf4, 0xf3, 0xf7, 0xfd, 0xfe, 0xfc, 0xf8, 0xf6, 0xf8, 0xfd, 0x00, + 0xfe, 0xf9, 0xf5, 0xf2, 0xf3, 0xf3, 0xf5, 0xf9, 0xfb, 0xf9, 0xf8, 0xfc, 0xfb, 0xfd, 0x02, 0xff, 0xf6, 0xef, 0xf0, 0xf6, 0xfe, 0x04, + 0x05, 0x01, 0xfc, 0xfa, 0xfb, 0xf6, 0xf0, 0xf3, 0xfa, 0xff, 0x00, 0xfc, 0xfb, 0xfc, 0xfb, 0xfb, 0xfe, 0xff, 0xfc, 0xfa, 0xf8, 0xf7, + 0xfa, 0x00, 0x04, 0x02, 0xff, 0xfe, 0x00, 0x03, 0x06, 0x05, 0x02, 0xf9, 0xf6, 0xf7, 0xf7, 0xf7, 0xf7, 0xfc, 0x03, 0x06, 0x05, 0x00, + 0xfc, 0xfc, 0xff, 0x01, 0x01, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xfd, 0x01, 0x05, 0x05, 0x01, 0xfe, 0xff, 0x03, 0x06, 0x05, 0xfe, + 0xf9, 0xf7, 0xfb, 0x02, 0x07, 0x09, 0x08, 0x07, 0x03, 0xff, 0xfc, 0xff, 0x04, 0x08, 0x0a, 0x09, 0x04, 0x00, 0x01, 0x04, 0x06, 0x06, + 0x07, 0x04, 0x00, 0x00, 0x02, 0x05, 0x06, 0x02, 0x03, 0x08, 0x0c, 0x0b, 0x0a, 0x07, 0x01, 0x00, 0x01, 0x04, 0x0c, 0x10, 0x0d, 0x07, + 0x00, 0xfe, 0x01, 0x07, 0x03, 0xff, 0x00, 0x02, 0x04, 0x06, 0x08, 0x0a, 0x09, 0x06, 0x06, 0x04, 0x01, 0xfe, 0x00, 0x02, 0x05, 0x07, + 0x05, 0x01, 0xfc, 0xf6, 0xf4, 0xf7, 0xfd, 0x03, 0x05, 0x02, 0xfe, 0xfe, 0x03, 0x07, 0x06, 0x00, 0xfa, 0xf9, 0xfa, 0xf9, 0xf8, 0xf9, + 0xfe, 0x04, 0x06, 0x06, 0x04, 0x00, 0xfa, 0xf9, 0xfe, 0x04, 0x06, 0x06, 0x02, 0xf9, 0xf5, 0xf5, 0xf7, 0xfa, 0x00, 0x01, 0xfe, 0xfc, + 0xfb, 0xfc, 0x00, 0x04, 0x04, 0x01, 0x00, 0x00, 0x02, 0x03, 0x00, 0xfc, 0xfb, 0xfe, 0xfd, 0xfd, 0xfe, 0xfd, 0xfe, 0xfc, 0xfa, 0xfb, + 0xfd, 0xff, 0xff, 0x01, 0x04, 0x04, 0xff, 0xfe, 0xfe, 0xfb, 0xf6, 0xf8, 0xfe, 0x02, 0x04, 0x04, 0x02, 0xfb, 0xf6, 0xf5, 0xf7, 0xfa, + 0xfd, 0x00, 0x04, 0x03, 0xfd, 0xf6, 0xf3, 0xf4, 0xf7, 0xfa, 0xfd, 0xfd, 0xfa, 0xf7, 0xf7, 0xfd, 0x04, 0x04, 0x01, 0xfb, 0xf7, 0xf6, + 0xfa, 0xff, 0xff, 0x04, 0x07, 0x06, 0x02, 0xfe, 0xfb, 0xf8, 0xf8, 0xfb, 0xfd, 0xfb, 0xf8, 0xfd, 0x07, 0x07, 0x03, 0x02, 0x04, 0x00, + 0xfc, 0xfb, 0xfd, 0xfc, 0xfa, 0xfa, 0xfc, 0x00, 0x06, 0x0a, 0x06, 0xff, 0xfb, 0xfe, 0x02, 0x06, 0x07, 0x06, 0x03, 0x01, 0x03, 0x04, + 0x03, 0x02, 0x00, 0x02, 0x02, 0xff, 0x01, 0x05, 0x06, 0x05, 0x02, 0x02, 0x04, 0x03, 0x00, 0xff, 0x00, 0x00, 0x03, 0x08, 0x0a, 0x0b, + 0x09, 0x05, 0x00, 0x03, 0x05, 0x03, 0x01, 0x00, 0xff, 0xfe, 0xfc, 0xfb, 0xfd, 0x01, 0x03, 0x02, 0x01, 0xfd, 0xfd, 0x01, 0x05, 0x05, + 0x04, 0x04, 0x02, 0xfc, 0xf8, 0xfb, 0x01, 0x05, 0x04, 0xff, 0x00, 0x03, 0x01, 0xfd, 0xf9, 0xfa, 0xfe, 0x01, 0xff, 0xfc, 0xfd, 0xff, + 0x00, 0xfe, 0xfe, 0xfe, 0xfe, 0xff, 0xff, 0xfe, 0xfc, 0xfe, 0xfe, 0xfe, 0xfc, 0xfa, 0xf7, 0xf6, 0xfa, 0xff, 0x04, 0x05, 0x02, 0x00, + 0x02, 0x04, 0x01, 0x00, 0x01, 0xff, 0xfb, 0xf9, 0xfb, 0xff, 0x04, 0x06, 0x03, 0xff, 0x00, 0x03, 0xfd, 0xf7, 0xf6, 0xfa, 0xff, 0x00, + 0xfe, 0xfe, 0x01, 0x04, 0x06, 0x05, 0x04, 0x01, 0xfd, 0xf7, 0xf8, 0xfe, 0x02, 0x02, 0x02, 0x03, 0x01, 0xfd, 0xfc, 0xfe, 0xfd, 0xfb, + 0xfb, 0x01, 0x05, 0x04, 0x01, 0x03, 0x02, 0x00, 0xff, 0xfe, 0xfd, 0xfc, 0xff, 0x00, 0x04, 0x09, 0x05, 0xfe, 0xf9, 0xf9, 0xfa, 0xff, + 0x03, 0x01, 0xfd, 0xf9, 0xf6, 0xf9, 0x02, 0x07, 0x05, 0xff, 0xfb, 0xfa, 0xfa, 0xfc, 0xfd, 0xfe, 0xfe, 0xfc, 0xfc, 0xff, 0x00, 0x02, + 0x02, 0x01, 0xfd, 0xfc, 0x01, 0x02, 0x01, 0x00, 0xfe, 0x00, 0x02, 0x01, 0xfb, 0xf9, 0xfb, 0x00, 0x05, 0x08, 0x06, 0x03, 0xff, 0x01, + 0x07, 0x0a, 0x0b, 0x0a, 0x06, 0xfd, 0xf8, 0xf9, 0xfd, 0x01, 0x03, 0x00, 0xfe, 0xff, 0x05, 0x0c, 0x0c, 0x08, 0x02, 0xff, 0xff, 0x00, + 0x01, 0x02, 0x01, 0x03, 0x08, 0x0d, 0x0c, 0x05, 0x00, 0x00, 0x02, 0x02, 0x00, 0xfe, 0xff, 0x00, 0x03, 0x05, 0x03, 0x01, 0x04, 0x07, + 0x04, 0x02, 0xfc, 0xf6, 0xf5, 0xf8, 0xfc, 0x00, 0x06, 0x03, 0xfe, 0xfe, 0xff, 0xff, 0xff, 0xfe, 0xfc, 0xfc, 0xfd, 0xfa, 0xfa, 0xfc, + 0xfe, 0xfd, 0xfc, 0xfc, 0xfd, 0xfd, 0xfd, 0xfd, 0xfb, 0xfa, 0xf9, 0xfc, 0xfc, 0xfc, 0xfc, 0xfb, 0xf8, 0xf8, 0xfd, 0xfd, 0xfc, 0xfc, + 0xfd, 0xfd, 0xff, 0xff, 0xf9, 0xf7, 0xfb, 0x02, 0x00, 0xff, 0xff, 0xfd, 0xfc, 0xfb, 0xfb, 0xfd, 0x00, 0x03, 0x03, 0x01, 0xfe, 0xfb, + 0xf9, 0xfb, 0xff, 0x03, 0x05, 0x03, 0x00, 0xfd, 0xfe, 0x01, 0x04, 0x05, 0x03, 0xff, 0xfc, 0xfb, 0xfd, 0x00, 0x02, 0x00, 0xff, 0xff, + 0x00, 0xff, 0xff, 0xfe, 0xfe, 0xfd, 0xfd, 0xff, 0xff, 0x00, 0x01, 0xff, 0xff, 0x01, 0x03, 0x04, 0x02, 0xfd, 0xfa, 0xfa, 0xfe, 0x00, + 0xfe, 0xfb, 0xfc, 0x00, 0x01, 0x02, 0x02, 0x01, 0xff, 0xfb, 0xf8, 0xf9, 0xfd, 0x01, 0x02, 0x02, 0x00, 0xfc, 0xfd, 0x00, 0x04, 0x04, + 0x00, 0xf9, 0xf5, 0xf9, 0xfd, 0xfe, 0xff, 0x04, 0x05, 0x03, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x02, 0x05, 0x05, 0x04, + 0x01, 0x01, 0x00, 0xff, 0x02, 0x05, 0x06, 0x05, 0x04, 0x02, 0x00, 0x00, 0x01, 0x01, 0x02, 0x04, 0x06, 0x07, 0x09, 0x08, 0x04, 0x00, + 0x01, 0x04, 0x03, 0xfd, 0xfc, 0xff, 0x03, 0x06, 0x09, 0x0a, 0x06, 0x00, 0xfb, 0xfd, 0x03, 0x09, 0x09, 0x05, 0x01, 0x00, 0xff, 0xfa, + 0xfd, 0x01, 0x03, 0x03, 0x02, 0xff, 0xfd, 0x00, 0x02, 0x02, 0x00, 0x00, 0x01, 0x02, 0x02, 0x01, 0x00, 0xfe, 0xfe, 0x00, 0x01, 0x02, + 0xff, 0xfc, 0xfa, 0xfa, 0xfd, 0xff, 0x00, 0xfd, 0xfc, 0xfe, 0xff, 0x00, 0x00, 0x01, 0x02, 0xfe, 0xf8, 0xf3, 0xf6, 0xfb, 0xfe, 0xff, + 0xfd, 0xfc, 0xfd, 0xfd, 0x00, 0x03, 0x00, 0xfa, 0xf9, 0xfd, 0xff, 0x00, 0xfe, 0xfd, 0xfc, 0xfb, 0xfa, 0xf8, 0xf8, 0xfa, 0xfe, 0x00, + 0xfe, 0xfc, 0xfc, 0xfc, 0xfc, 0xfe, 0x00, 0xff, 0xff, 0x01, 0x03, 0x05, 0x04, 0x01, 0xfd, 0xfa, 0xf7, 0xf9, 0xfd, 0x00, 0x00, 0xff, + 0xfd, 0xfb, 0xfc, 0xfe, 0x01, 0x03, 0x02, 0x02, 0x01, 0x00, 0xfd, 0xfb, 0xfc, 0xfd, 0xfe, 0xfd, 0xfb, 0xfc, 0x00, 0x02, 0x01, 0x00, + 0xfd, 0xfb, 0xf9, 0xfc, 0xfe, 0x00, 0x02, 0x01, 0xfc, 0xf9, 0xfa, 0xfe, 0x01, 0x02, 0x00, 0xff, 0x01, 0x02, 0x01, 0x00, 0x02, 0x05, + 0x03, 0xfe, 0xfb, 0xfc, 0xfe, 0x00, 0xff, 0x00, 0x01, 0x01, 0x01, 0x00, 0x01, 0x01, 0x01, 0xff, 0xfd, 0xfe, 0x01, 0x04, 0x05, 0x03, + 0x01, 0x00, 0x01, 0x04, 0x06, 0x05, 0x02, 0xff, 0xfe, 0x00, 0x03, 0x05, 0x04, 0x03, 0x03, 0x03, 0x04, 0x03, 0x04, 0x05, 0x05, 0x05, + 0x04, 0x01, 0xff, 0x00, 0x02, 0x03, 0x03, 0x01, 0x00, 0x03, 0x05, 0x06, 0x05, 0x05, 0x04, 0x03, 0x02, 0x00, 0xfe, 0xfe, 0xfe, 0x00, + 0x02, 0x02, 0x01, 0x01, 0x02, 0x05, 0x04, 0x01, 0xfe, 0xfd, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0xfe, 0xfd, 0xfe, 0x00, 0x01, 0x00, + 0xfe, 0xff, 0x01, 0x01, 0xff, 0xfd, 0xfb, 0xfd, 0x00, 0x01, 0x00, 0xfe, 0xfc, 0xfd, 0xfe, 0xfe, 0xfd, 0xfe, 0x00, 0x02, 0x02, 0x00, + 0xfd, 0xfa, 0xf7, 0xf8, 0xfb, 0xff, 0x02, 0x01, 0xfe, 0xfa, 0xf8, 0xf9, 0xfb, 0xfe, 0x01, 0x01, 0x02, 0xff, 0xfa, 0xf8, 0xfb, 0xfd, + 0xfe, 0x00, 0x00, 0xff, 0xfe, 0xff, 0x01, 0x01, 0xfe, 0xfa, 0xfb, 0xfe, 0xfd, 0xfd, 0xfd, 0xff, 0x00, 0x01, 0x01, 0x00, 0xff, 0xff, + 0xff, 0xff, 0xfd, 0xfb, 0xfb, 0xfc, 0xff, 0x01, 0x00, 0x00, 0x00, 0xff, 0xfc, 0xfb, 0xfb, 0xfc, 0xff, 0x00, 0xff, 0xfe, 0xfd, 0xfe, + 0x00, 0x01, 0x02, 0x01, 0xfd, 0xfb, 0xfb, 0xfc, 0xfb, 0xfd, 0xff, 0x00, 0xfe, 0xfe, 0xfc, 0xfb, 0xfc, 0xff, 0x00, 0x00, 0xff, 0xff, + 0xff, 0x00, 0x01, 0x01, 0x00, 0xfe, 0xfe, 0xfe, 0xfe, 0xff, 0xff, 0xff, 0xff, 0x00, 0x01, 0x00, 0xff, 0x00, 0x02, 0x02, 0x02, 0x02, + 0x02, 0x03, 0x03, 0x02, 0x02, 0x03, 0x03, 0x01, 0x01, 0x04, 0x05, 0x05, 0x05, 0x04, 0x03, 0x03, 0x02, 0x00, 0x01, 0x04, 0x06, 0x07, + 0x06, 0x03, 0x02, 0x01, 0x00, 0x01, 0x04, 0x06, 0x05, 0x03, 0x03, 0x05, 0x08, 0x06, 0x01, 0xff, 0x00, 0x02, 0x03, 0x04, 0x07, 0x09, + 0x07, 0x01, 0xfc, 0xfb, 0xfb, 0xff, 0x01, 0x00, 0x01, 0x02, 0x03, 0x02, 0x01, 0xfe, 0xfd, 0xff, 0xff, 0xfd, 0xfc, 0xfb, 0xfd, 0xff, + 0xff, 0x00, 0x01, 0x02, 0x02, 0x01, 0xfd, 0xf8, 0xfa, 0xfe, 0x00, 0xff, 0xff, 0xff, 0xfe, 0xfe, 0xfe, 0xff, 0x01, 0x02, 0x01, 0xfd, + 0xfc, 0xfa, 0xfb, 0xfd, 0x00, 0x01, 0xff, 0xfd, 0xfd, 0xfd, 0xfc, 0xfc, 0xfd, 0xfe, 0xff, 0xfe, 0xff, 0x00, 0x00, 0x01, 0xff, 0xfd, + 0xfe, 0xfe, 0xfe, 0xff, 0x02, 0x02, 0x01, 0x00, 0xff, 0xfd, 0xfb, 0xf9, 0xfd, 0x01, 0x02, 0xff, 0xfe, 0xfe, 0xff, 0x01, 0x01, 0xff, + 0xfd, 0xfb, 0xfb, 0xfb, 0xfc, 0xff, 0x00, 0xfd, 0xfb, 0xfc, 0xfe, 0xfe, 0xff, 0xfe, 0xfc, 0xfc, 0xfe, 0xff, 0xfe, 0xfc, 0xfd, 0xfe, + 0x00, 0xff, 0xfd, 0xfc, 0xfd, 0xfd, 0xfc, 0xff, 0xfd, 0xfb, 0xfa, 0xfb, 0xfc, 0xfc, 0xfc, 0xfb, 0xfc, 0xfe, 0xff, 0xff, 0xfd, 0xfc, + 0xfc, 0xfd, 0xfd, 0xfe, 0xff, 0xff, 0xfe, 0xff, 0xff, 0x00, 0x01, 0x00, 0xfe, 0xfe, 0xff, 0x00, 0x01, 0x02, 0x01, 0x01, 0x02, 0x03, + 0x02, 0x02, 0x01, 0x00, 0x02, 0x03, 0x01, 0x01, 0x02, 0x03, 0x04, 0x03, 0x03, 0x03, 0x04, 0x03, 0x02, 0x02, 0x02, 0x03, 0x04, 0x04, + 0x05, 0x04, 0x04, 0x04, 0x04, 0x04, 0x05, 0x06, 0x06, 0x05, 0x03, 0x02, 0x02, 0x02, 0x03, 0x06, 0x07, 0x05, 0x02, 0xff, 0xff, 0x01, + 0x03, 0x04, 0x04, 0x02, 0x00, 0xff, 0x01, 0x00, 0xff, 0xff, 0xff, 0x01, 0x03, 0x03, 0x04, 0x03, 0x02, 0x01, 0x01, 0x00, 0xff, 0xff, + 0x00, 0x00, 0x00, 0xff, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfd, 0xfd, 0xfe, 0x00, 0xff, 0xff, 0x00, 0xff, 0xfe, 0xfc, 0xfa, + 0xfb, 0xfe, 0x00, 0x01, 0x02, 0x03, 0x00, 0x00, 0xfe, 0xfb, 0xfa, 0xfa, 0xfa, 0xfb, 0xfd, 0xff, 0x00, 0xff, 0x00, 0x01, 0x01, 0xff, + 0xfd, 0xfc, 0xfc, 0xfb, 0xfb, 0xfc, 0xfd, 0xfe, 0xfe, 0xfe, 0xfd, 0xfe, 0xff, 0x00, 0x01, 0x01, 0xff, 0xfd, 0xfc, 0xfc, 0xfe, 0x00, + 0xff, 0xff, 0x00, 0xff, 0xfd, 0xfc, 0xfb, 0xfd, 0xff, 0x00, 0x00, 0xfe, 0xfd, 0xfd, 0xfd, 0xfd, 0xfe, 0xff, 0xff, 0xfe, 0xfd, 0xfb, + 0xfa, 0xfb, 0xfe, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xfd, 0xfc, 0xfd, 0xfd, 0xfd, 0xfb, 0xfb, 0xfe, 0x00, 0x01, 0x01, 0xff, 0xfb, + 0xfa, 0xfc, 0xfe, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xfe, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xfe, 0xfe, 0xfe, + 0xff, 0x01, 0x02, 0x01, 0x01, 0x01, 0x00, 0x00, 0x01, 0x01, 0x02, 0x04, 0x04, 0x03, 0x03, 0x02, 0x01, 0x00, 0x02, 0x03, 0x03, 0x02, + 0x02, 0x04, 0x04, 0x05, 0x06, 0x06, 0x04, 0x02, 0x00, 0xfe, 0xff, 0x02, 0x04, 0x05, 0x06, 0x05, 0x03, 0x02, 0x03, 0x04, 0x06, 0x04, + 0x01, 0x00, 0x00, 0x01, 0x02, 0x01, 0x02, 0x02, 0x02, 0x02, 0x01, 0x00, 0x00, 0x01, 0x03, 0x05, 0x04, 0x02, 0x00, 0xfe, 0xfe, 0x01, + 0x02, 0x03, 0x02, 0x00, 0xff, 0xfe, 0xff, 0x00, 0x00, 0x00, 0xff, 0xfe, 0xfe, 0xfe, 0xfc, 0xfc, 0xff, 0x02, 0x03, 0x02, 0x00, 0xfe, + 0xfd, 0xff, 0x00, 0x00, 0xff, 0xfd, 0xfc, 0xfd, 0xfe, 0xfd, 0xff, 0x01, 0x00, 0xff, 0xff, 0xfd, 0xfb, 0xfc, 0xfe, 0xfe, 0xfc, 0xfd, + 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xff, 0x00, 0xff, 0xff, 0xfe, 0xfd, 0xfd, 0xfe, 0xfd, 0xfd, 0xfd, 0xff, + 0x01, 0x03, 0x01, 0xff, 0xfe, 0xfc, 0xfc, 0xfd, 0xfc, 0xfc, 0xfd, 0xff, 0xfe, 0x00, 0x01, 0xff, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfe, + 0xff, 0xfe, 0xfd, 0xfd, 0xff, 0xff, 0xff, 0xfe, 0xfc, 0xfc, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xfd, 0xfc, 0xfc, 0xfd, 0xff, 0x00, + 0x00, 0xff, 0xfe, 0xfe, 0xfe, 0xfd, 0xfc, 0xfd, 0xfd, 0xfe, 0xfe, 0xff, 0xfe, 0xff, 0x00, 0x01, 0x00, 0x00, 0xff, 0xfd, 0xfd, 0xff, + 0x02, 0x02, 0x03, 0x03, 0x02, 0x00, 0xff, 0xfe, 0xff, 0xff, 0xff, 0xff, 0x01, 0x03, 0x04, 0x03, 0x02, 0x02, 0x02, 0x03, 0x05, 0x05, + 0x02, 0x01, 0x00, 0x01, 0x03, 0x05, 0x05, 0x04, 0x04, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x05, 0x06, 0x06, 0x04, 0x03, 0x02, 0x02, + 0x01, 0x01, 0x01, 0x02, 0x03, 0x04, 0x03, 0x01, 0x00, 0x01, 0x02, 0x03, 0x04, 0x03, 0x02, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x01, + 0x00, 0x00, 0x00, 0x01, 0x02, 0x02, 0x01, 0xfe, 0xfc, 0xfd, 0x00, 0x01, 0x02, 0x02, 0x02, 0x00, 0xfe, 0xfd, 0xfd, 0xfb, 0xfb, 0xfd, + 0xff, 0x00, 0x01, 0x00, 0x00, 0xff, 0xfe, 0xfd, 0xfd, 0xfd, 0xfd, 0xfe, 0x00, 0x02, 0x02, 0xff, 0xfd, 0xfd, 0xff, 0xff, 0xfd, 0xfc, + 0xfa, 0xfa, 0xfc, 0xfe, 0x00, 0x02, 0x02, 0xfd, 0xfa, 0xfa, 0xfc, 0xff, 0xff, 0xfd, 0xfb, 0xfb, 0xfc, 0xfd, 0xfe, 0x00, 0x01, 0x01, + 0x01, 0xff, 0xfd, 0xfa, 0xfa, 0xfb, 0xfd, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xfd, 0xfc, 0xfc, 0xfd, 0xfd, 0xfc, 0xfc, 0xfe, 0x00, 0x00, + 0xfe, 0xfc, 0xfc, 0xfd, 0xfd, 0xfd, 0xfc, 0xfd, 0xfe, 0xfe, 0xfc, 0xfd, 0xfe, 0x00, 0x01, 0x00, 0xff, 0xff, 0xfe, 0xfb, 0xfa, 0xfd, + 0xff, 0x00, 0x00, 0xff, 0xfc, 0xfd, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xfe, 0xff, 0x00, 0x01, 0x01, 0x00, 0xff, 0xff, + 0x00, 0x01, 0x03, 0x02, 0x00, 0xfe, 0xfe, 0xff, 0x02, 0x04, 0x03, 0x02, 0x00, 0x00, 0x01, 0x02, 0x03, 0x03, 0x02, 0x00, 0xff, 0x01, + 0x02, 0x03, 0x03, 0x04, 0x04, 0x03, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x01, 0x02, 0x03, 0x03, 0x02, 0x01, 0x02, 0x04, 0x05, 0x04, + 0x02, 0x00, 0x01, 0x02, 0x03, 0x04, 0x03, 0x01, 0x00, 0x00, 0x01, 0x02, 0x03, 0x03, 0x00, 0xff, 0xff, 0x00, 0x00, 0x01, 0x01, 0x01, + 0x02, 0x03, 0x05, 0x04, 0x02, 0x02, 0x02, 0x02, 0x02, 0x01, 0x00, 0xff, 0xfe, 0xfe, 0xfd, 0xfe, 0x00, 0x02, 0x02, 0x03, 0x02, 0x00, + 0xfe, 0xfe, 0xff, 0x00, 0xff, 0xfe, 0xff, 0xff, 0x00, 0x01, 0x01, 0x00, 0xfe, 0xfc, 0xfc, 0xfe, 0x00, 0x02, 0x01, 0xff, 0xfd, 0xfc, + 0xfd, 0xff, 0x00, 0xfe, 0xfd, 0xfc, 0xfc, 0xfd, 0xfe, 0xfe, 0xfe, 0xfd, 0xfd, 0xfe, 0xfe, 0xff, 0x00, 0xff, 0xfd, 0xfc, 0xfc, 0xfd, + 0xfe, 0xfe, 0xfe, 0xfd, 0xfd, 0xfe, 0xfd, 0xfd, 0xfe, 0xfe, 0xfd, 0xfc, 0xfb, 0xfb, 0xfd, 0xfe, 0xff, 0xfe, 0xfe, 0xfe, 0xfd, 0xfa, + 0xf9, 0xfb, 0xfc, 0xfe, 0xfe, 0xfe, 0xfc, 0xfc, 0xfe, 0xff, 0xfd, 0xfd, 0xfd, 0xfe, 0xfd, 0xfd, 0xfe, 0xff, 0xff, 0xfe, 0xfc, 0xfd, + 0xff, 0x01, 0xff, 0xfd, 0xfd, 0xff, 0x00, 0xff, 0xfd, 0xfd, 0xfd, 0xfe, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x01, + 0x02, 0x03, 0x02, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x01, 0x02, 0x01, 0x01, 0x01, 0x03, 0x02, 0x01, 0x01, 0x03, 0x04, + 0x04, 0x03, 0x02, 0x01, 0x01, 0x01, 0x02, 0x02, 0x01, 0xff, 0x01, 0x04, 0x06, 0x07, 0x06, 0x04, 0x02, 0x02, 0x02, 0x02, 0x02, 0x01, + 0x01, 0x01, 0x00, 0x01, 0x01, 0x02, 0x02, 0x02, 0x01, 0x02, 0x02, 0x03, 0x02, 0x00, 0xff, 0xff, 0xff, 0x01, 0x03, 0x04, 0x05, 0x04, + 0x02, 0xff, 0xfe, 0xfe, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x01, 0x02, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, + 0x01, 0xff, 0xfe, 0xfe, 0xff, 0x00, 0x01, 0xff, 0xfe, 0xfe, 0xff, 0x00, 0x01, 0x01, 0x01, 0xff, 0xfd, 0xfd, 0xff, 0x00, 0xff, 0xfe, + 0xfd, 0xfd, 0xfe, 0xff, 0xff, 0xfe, 0xfe, 0xfe, 0xfe, 0xfd, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xfd, 0xfd, 0xfd, 0xfe, + 0xff, 0xff, 0xfe, 0xfd, 0xfc, 0xfc, 0xfc, 0xfc, 0xfd, 0xfe, 0xff, 0xff, 0xfe, 0xfd, 0xfd, 0xfc, 0xfb, 0xfc, 0xfd, 0xfd, 0xfd, 0xfd, + 0xfd, 0xfe, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfc, 0xfc, 0xfc, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfc, 0xfd, 0xfd, 0xfe, 0xff, + 0x00, 0x00, 0xff, 0xfe, 0xfd, 0xfd, 0xfd, 0xfd, 0xfe, 0xff, 0x00, 0x00, 0xff, 0xfd, 0xfd, 0xfc, 0xfe, 0x00, 0x01, 0x01, 0x01, 0x01, + 0x00, 0x00, 0x01, 0x02, 0x02, 0x01, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x00, 0xff, 0x00, 0x03, 0x04, 0x03, 0x02, 0x00, 0x01, 0x02, + 0x04, 0x03, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x03, 0x04, 0x05, 0x05, 0x03, 0x01, 0xff, 0xff, 0x00, 0x00, + 0x01, 0x02, 0x01, 0x00, 0x01, 0x02, 0x03, 0x03, 0x04, 0x03, 0x02, 0x00, 0x01, 0x02, 0x02, 0x01, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, + 0x01, 0x02, 0x02, 0x02, 0x02, 0x01, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x01, 0x02, 0x02, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0xff, + 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x01, 0x01, 0x00, 0xff, 0xfe, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, + 0xff, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfe, 0x00, 0x00, 0x00, 0xff, 0xfe, 0xfd, 0xfc, 0xfc, 0xfd, 0xff, 0x00, 0x00, 0xfe, 0xfe, 0xfe, + 0xff, 0xfe, 0xfd, 0xfc, 0xfd, 0xfe, 0xfd, 0xfd, 0xfc, 0xfc, 0xfc, 0xfc, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfc, 0xfc, 0xfd, + 0xff, 0xff, 0xfe, 0xfd, 0xfd, 0xfc, 0xfc, 0xfd, 0xfd, 0xfe, 0xfe, 0xfe, 0xfd, 0xfc, 0xfc, 0xfe, 0xfe, 0xfd, 0xfd, 0xfe, 0xff, 0xff, + 0xff, 0xff, 0xfe, 0xfd, 0xfd, 0xfc, 0xfc, 0xfe, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xfe, 0xff, 0xff, 0xff, 0x00, 0xff, + 0x01, 0x01, 0x00, 0xfe, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x02, 0x02, 0x02, 0x01, 0x00, 0xff, 0x01, 0x03, 0x03, 0x03, 0x02, 0x01, + 0x00, 0x01, 0x02, 0x02, 0x03, 0x04, 0x05, 0x04, 0x03, 0x01, 0x00, 0x00, 0x01, 0x03, 0x03, 0x04, 0x03, 0x02, 0x01, 0x01, 0x02, 0x03, + 0x02, 0x01, 0x02, 0x03, 0x03, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x03, 0x02, 0x02, 0x01, 0x00, 0x00, 0x00, 0x01, 0x02, + 0x02, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x01, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, + 0x02, 0x02, 0x01, 0xff, 0xfe, 0xfe, 0xff, 0x00, 0x00, 0x01, 0x01, 0x01, 0x00, 0xff, 0xff, 0xfe, 0xff, 0x00, 0x01, 0x01, 0x00, 0xff, + 0xff, 0xff, 0xff, 0xfe, 0xfe, 0xff, 0x00, 0x00, 0xff, 0xff, 0xfe, 0xfe, 0xfe, 0xff, 0x00, 0xff, 0xfe, 0xfc, 0xfc, 0xfd, 0xfe, 0xff, + 0x00, 0x00, 0xfe, 0xfd, 0xfc, 0xfb, 0xfb, 0xfb, 0xfc, 0xfd, 0xff, 0xff, 0xfe, 0xfd, 0xfd, 0xfd, 0xfd, 0xfe, 0xfe, 0xfd, 0xfc, 0xfc, + 0xfb, 0xfb, 0xfb, 0xfc, 0xfd, 0xfe, 0xfe, 0xfe, 0xff, 0xff, 0xfd, 0xfc, 0xfb, 0xfb, 0xfd, 0xfd, 0xfd, 0xfb, 0xfc, 0xfc, 0xfd, 0xfd, + 0xff, 0xff, 0xff, 0xfe, 0xfd, 0xfc, 0xfd, 0xfd, 0xfd, 0xfe, 0xff, 0x00, 0x00, 0x00, 0xfe, 0xfd, 0xfe, 0x00, 0x01, 0x01, 0xff, 0xfe, + 0xff, 0x00, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x01, + 0x01, 0x01, 0x01, 0x02, 0x03, 0x02, 0x02, 0x01, 0x00, 0x00, 0x02, 0x04, 0x04, 0x04, 0x03, 0x02, 0x02, 0x02, 0x02, 0x01, 0x01, 0x01, + 0x01, 0x01, 0x02, 0x03, 0x02, 0x02, 0x02, 0x02, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x01, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, + 0x02, 0x01, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x01, 0x02, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, + 0x00, 0xff, 0xfe, 0xfe, 0xff, 0x01, 0x02, 0x01, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x01, 0x01, + 0x00, 0xff, 0xff, 0xff, 0xfe, 0xfe, 0xfe, 0xfe, 0xff, 0x00, 0x00, 0x00, 0xff, 0xfe, 0xfe, 0xfe, 0x00, 0x00, 0x00, 0xff, 0xfd, 0xfd, + 0xfd, 0xfe, 0xfd, 0xfd, 0xfd, 0xfc, 0xfc, 0xfd, 0xfe, 0xfe, 0xfe, 0xfd, 0xfc, 0xfb, 0xfc, 0xfc, 0xfe, 0xfe, 0xfd, 0xfc, 0xfc, 0xfd, + 0xfe, 0xfe, 0xfd, 0xfc, 0xfb, 0xfb, 0xfc, 0xfc, 0xfd, 0xfc, 0xfd, 0xfe, 0xfe, 0xfe, 0xfd, 0xfd, 0xfc, 0xfc, 0xfc, 0xfc, 0xfd, 0xfe, + 0xff, 0xff, 0xff, 0xfe, 0xfe, 0xfd, 0xfd, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xfe, 0xff, 0xff, 0xff, 0xfe, 0xfe, 0xfe, 0xff, + 0x00, 0x01, 0x02, 0x02, 0x01, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x01, 0x01, 0x02, 0x02, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, + 0x01, 0x01, 0x02, 0x02, 0x01, 0x02, 0x01, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, + 0x02, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x01, 0x01, 0x01, 0x01, + 0x01, 0x01, 0x01, 0x01, 0x00, 0xff, 0xff, 0x01, 0x03, 0x03, 0x02, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x01, + 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x01, 0x01, 0x01, 0x00, 0xff, 0x00, 0x00, 0x00, + 0x00, 0xff, 0xff, 0xfe, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfe, 0xfd, 0xfd, 0xfe, 0xfe, 0xfe, 0xfe, 0xfd, 0xfc, 0xfd, 0xfd, 0xfe, 0xfe, 0xfd, 0xfc, 0xfc, 0xfd, 0xfe, 0xff, 0xff, 0xfe, + 0xfc, 0xfb, 0xfb, 0xfc, 0xfd, 0xfd, 0xfd, 0xfc, 0xfb, 0xfc, 0xfe, 0xfe, 0xfe, 0xfe, 0xfd, 0xfd, 0xfc, 0xfc, 0xfc, 0xfc, 0xfd, 0xfe, + 0xfd, 0xfd, 0xfe, 0xfd, 0xfd, 0xfe, 0xfe, 0xfd, 0xfd, 0xfe, 0xfe, 0xff, 0xff, 0xfe, 0xfe, 0xfe, 0xfe, 0xff, 0xff, 0xff, 0xfe, 0xff, + 0x00, 0x01, 0x01, 0xff, 0xfe, 0xfe, 0xfe, 0xfe, 0xff, 0x01, 0x01, 0x02, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x02, 0x01, + 0x01, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x01, 0x01, 0x02, 0x03, 0x03, 0x02, 0x02, 0x02, 0x02, 0x02, 0x01, 0x01, 0x01, 0x02, + 0x02, 0x02, 0x02, 0x02, 0x03, 0x02, 0x02, 0x02, 0x02, 0x01, 0x01, 0x01, 0x02, 0x02, 0x03, 0x03, 0x03, 0x02, 0x01, 0x01, 0x01, 0x01, + 0x01, 0x01, 0x02, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x01, 0x01, 0x01, 0x00, 0xff, 0x00, 0x01, 0x01, 0x02, 0x01, 0x00, 0x00, 0x00, + 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x01, 0x01, 0x01, 0x01, + 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xfe, 0xfe, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xfe, 0xfe, 0xff, + 0x00, 0xff, 0xfe, 0xfd, 0xfd, 0xfe, 0xfe, 0xfe, 0xfe, 0xff, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, + 0xfe, 0xfe, 0xfd, 0xfc, 0xfc, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfc, 0xfc, 0xfc, 0xfd, 0xfd, 0xfd, 0xfc, 0xfd, + 0xfd, 0xfe, 0xfe, 0xfd, 0xfd, 0xfc, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfe, 0xfe, 0xfe, 0xfe, 0xfd, 0xfe, 0xfe, 0xff, 0xff, 0xfe, 0xfd, + 0xfe, 0xff, 0x00, 0x01, 0x00, 0xfe, 0xfe, 0xff, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, + 0x01, 0x02, 0x02, 0x02, 0x02, 0x01, 0x00, 0x00, 0x01, 0x01, 0x02, 0x02, 0x01, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x01, 0x00, 0x00, + 0x01, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x01, 0x00, 0x00, 0x00, 0x02, 0x03, 0x03, 0x03, 0x02, 0x02, 0x01, 0x01, 0x01, 0x02, + 0x02, 0x02, 0x01, 0x01, 0x00, 0x00, 0x00, 0x01, 0x02, 0x02, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x01, 0x01, 0x02, 0x01, 0x01, + 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0xff, 0xff, 0x00, 0x01, 0x02, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, + 0x00, 0x01, 0x01, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xfe, 0xfe, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xff, 0xff, 0xff, 0xfe, 0xfe, 0xfd, 0xfd, 0xfd, 0xfe, 0xfe, 0xfe, 0xfd, 0xfe, + 0xfe, 0xfe, 0xfe, 0xfd, 0xfd, 0xfd, 0xfe, 0xfe, 0xfe, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfe, 0xfd, 0xfd, 0xfd, 0xfc, 0xfc, 0xfc, 0xfd, + 0xfd, 0xfe, 0xfe, 0xfe, 0xfe, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfe, 0xfe, 0xfe, 0xfe, 0xfd, 0xfd, 0xfd, 0xfe, 0xfe, 0xfe, 0xfe, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xfe, 0xfe, 0xff, 0xff, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, + 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x01, 0x01, + 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x02, 0x01, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, + 0x01, 0x01, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x01, 0x01, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x01, 0x01, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, + 0xfe, 0xfd, 0xfe, 0xfe, 0xfe, 0xfe, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfe, 0xfe, 0xfe, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfc, 0xfd, 0xfe, + 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfe, 0xfe, 0xfd, 0xfe, 0xfe, 0xfe, 0xff, 0xff, 0xfe, 0xfe, 0xfe, + 0xfe, 0xfe, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xff, 0xff, 0xff, 0x00, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x01, 0x02, 0x02, 0x01, + 0x01, 0x01, 0x00, 0x00, 0x01, 0x02, 0x02, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x01, 0x01, + 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, 0x01, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x01, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, + 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, + 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfe, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, + 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, + 0xfe, 0xfe, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, + 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, + 0x01, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x01, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x01, + 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x01, 0x01, 0x01, + 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x01, 0x01, + 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xfe, 0xfe, 0xff, 0xfe, + 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfd, 0xfd, 0xfd, 0xfd, 0xfe, 0xfe, 0xfd, 0xfd, 0xfd, + 0xfd, 0xfd, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfd, 0xfd, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfd, 0xfe, 0xfe, + 0xff, 0xff, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xfe, 0xff, 0xff, 0x00, 0x00, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, + 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x02, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, + 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, + 0x00, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xfe, 0xfe, + 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xff, 0xff, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, + 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfd, 0xfd, 0xfd, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xff, 0xfe, 0xfe, + 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, + 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, + 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, + 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, + 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xfe, 0xfe, 0xfd, 0xfd, 0xfd, 0xfe, + 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xff, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, + 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, + 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, + 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, + 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xff, 0xff, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, + 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, + 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, + 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, + 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, + 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, + 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xfe, 0xfe, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, + 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x01, 0x01, 0x01, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x01, + 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, + 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xff, 0xff, 0xff, 0xfe, 0xfe, 0xfe, + 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xff, 0xff, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xfe, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x01, + 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xfe, 0xfe, + 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xff, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, + 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xfe, 0xfe, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xfe, + 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xfe, 0xff, 0xfe, 0xfe, 0xfe, 0xfe, 0xff, 0xff, + 0xff, 0xff, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, +}; + +static const unsigned char TOM_2608[18562] = { + 0x52, 0x49, 0x46, 0x46, 0xd0, 0x90, 0x00, 0x00, 0x57, 0x41, 0x56, 0x45, 0x66, 0x6d, 0x74, 0x20, 0x10, 0x00, 0x00, 0x00, 0x01, 0x00, + 0x01, 0x00, 0x44, 0xac, 0x00, 0x00, 0x88, 0x58, 0x01, 0x00, 0x02, 0x00, 0x10, 0x00, 0x66, 0x61, 0x63, 0x74, 0x04, 0x00, 0x00, 0x00, + 0x48, 0x00, 0x61, 0x61, 0x90, 0x00, 0xff, 0x02, 0x07, 0x0c, 0x0d, 0x0d, 0x0e, 0x0e, 0x0c, 0x0b, 0x0b, 0x0b, 0x02, 0x01, 0x09, 0x0d, + 0x05, 0xf9, 0xf4, 0xf0, 0xf0, 0xef, 0xed, 0xeb, 0xe9, 0xe7, 0xe8, 0xe8, 0xed, 0xf7, 0xf8, 0xe0, 0xc7, 0xd7, 0xd8, 0xe2, 0xf3, 0xe3, + 0xc9, 0xc5, 0xe0, 0xe9, 0xf4, 0xf2, 0xcd, 0xda, 0x00, 0x0f, 0xfe, 0xeb, 0xf0, 0x0b, 0xfc, 0xed, 0xea, 0xdf, 0xd9, 0xed, 0x0e, 0x03, + 0xe7, 0xc9, 0xb2, 0xb5, 0xbf, 0xbe, 0xb9, 0xd4, 0x03, 0x21, 0x1d, 0x08, 0x08, 0x2b, 0x4f, 0x59, 0x3d, 0xff, 0xdc, 0xdc, 0xf5, 0x1d, + 0x3f, 0x35, 0xf3, 0xdb, 0xf3, 0x1c, 0x39, 0x30, 0x15, 0x03, 0x0a, 0x10, 0x26, 0x5b, 0x7f, 0x63, 0x22, 0x23, 0x4a, 0x67, 0x52, 0x3c, + 0x1f, 0x13, 0x2d, 0x52, 0x60, 0x50, 0x34, 0x2f, 0x3c, 0x43, 0x2e, 0x21, 0x28, 0x29, 0x38, 0x47, 0x48, 0x3d, 0x39, 0x3e, 0x44, 0x40, + 0x31, 0x29, 0x39, 0x40, 0x39, 0x32, 0x33, 0x40, 0x50, 0x58, 0x55, 0x49, 0x35, 0x1c, 0x09, 0x0f, 0x26, 0x21, 0x09, 0xff, 0x1c, 0x2c, + 0x29, 0x26, 0x38, 0x4b, 0x4c, 0x36, 0x25, 0x1b, 0x0d, 0xed, 0xd9, 0xd5, 0xdf, 0xf3, 0xfe, 0xff, 0x00, 0xe8, 0xcf, 0xc5, 0xc7, 0xd5, + 0xe0, 0xd9, 0xb2, 0xa3, 0xb8, 0xd6, 0xd8, 0xd2, 0xc9, 0xa6, 0x9d, 0xa7, 0xae, 0xbb, 0xc5, 0xd1, 0xdc, 0xcf, 0xb5, 0xa5, 0xab, 0xbe, + 0xc8, 0xbc, 0x9b, 0x95, 0xac, 0xc0, 0xbf, 0xba, 0xb7, 0x9f, 0x97, 0xa6, 0xbd, 0xaa, 0x98, 0x94, 0x93, 0x89, 0x8e, 0xa1, 0xa9, 0x94, + 0x81, 0x90, 0xa0, 0xa6, 0xa4, 0xaa, 0xa9, 0xae, 0xb6, 0xb7, 0xa4, 0x9b, 0xb8, 0xc2, 0xc4, 0xce, 0xe3, 0xd9, 0xc0, 0xb9, 0xd4, 0xe6, + 0xe2, 0xdc, 0xe5, 0xf6, 0x02, 0x02, 0x02, 0x09, 0x11, 0xe9, 0xe3, 0xff, 0x04, 0xf4, 0xeb, 0xf8, 0x04, 0x0f, 0x0d, 0x01, 0xf7, 0xfb, + 0x04, 0x07, 0x05, 0x05, 0x00, 0xe1, 0xd7, 0xee, 0x11, 0x06, 0xf8, 0xff, 0x0e, 0x0f, 0x15, 0x25, 0x1b, 0x0c, 0x05, 0x05, 0x01, 0x03, + 0x0e, 0x15, 0x22, 0x24, 0x18, 0x0e, 0x16, 0x20, 0x1b, 0x17, 0x28, 0x45, 0x4e, 0x45, 0x39, 0x34, 0x2e, 0x2d, 0x35, 0x41, 0x4f, 0x51, + 0x49, 0x40, 0x43, 0x48, 0x45, 0x2a, 0x25, 0x39, 0x47, 0x4c, 0x4b, 0x4b, 0x54, 0x5d, 0x5d, 0x54, 0x4c, 0x49, 0x4c, 0x50, 0x5a, 0x5e, + 0x57, 0x5c, 0x5e, 0x64, 0x73, 0x79, 0x6d, 0x5b, 0x5a, 0x62, 0x69, 0x68, 0x64, 0x63, 0x63, 0x5e, 0x51, 0x48, 0x46, 0x43, 0x41, 0x45, + 0x4f, 0x57, 0x55, 0x4f, 0x4f, 0x42, 0x39, 0x3d, 0x44, 0x4b, 0x44, 0x31, 0x2b, 0x2f, 0x32, 0x2a, 0x24, 0x22, 0x24, 0x21, 0x19, 0x0d, + 0x03, 0x0b, 0x1a, 0x1c, 0x09, 0xf2, 0xe7, 0xed, 0xff, 0x04, 0xf9, 0xed, 0xe8, 0xed, 0xf4, 0xf0, 0xeb, 0xe4, 0xda, 0xd0, 0xce, 0xcf, + 0xcf, 0xd8, 0xea, 0xf7, 0xed, 0xe0, 0xda, 0xdc, 0xd6, 0xd2, 0xcf, 0xc9, 0xc8, 0xd2, 0xde, 0xdb, 0xd4, 0xd0, 0xd5, 0xe5, 0xe6, 0xd3, + 0xbd, 0xb0, 0xb1, 0xbd, 0xcd, 0xcf, 0xc3, 0xb7, 0xbe, 0xc8, 0xc9, 0xc0, 0xb7, 0xaf, 0xac, 0xb8, 0xc1, 0xbd, 0xb4, 0xb0, 0xb4, 0xb9, + 0xb6, 0xa7, 0x9a, 0x99, 0x9e, 0x9c, 0x97, 0x99, 0x98, 0xa3, 0xb5, 0xb7, 0xb4, 0xb2, 0xb5, 0xb6, 0xbd, 0xc6, 0xc2, 0xb3, 0xa0, 0x9a, + 0xb0, 0xcb, 0xd7, 0xcb, 0xb0, 0xa3, 0xaf, 0xc8, 0xdc, 0xdf, 0xd5, 0xcb, 0xc7, 0xc6, 0xc2, 0xc5, 0xc6, 0xc0, 0xb8, 0xb7, 0xc1, 0xcf, + 0xdb, 0xde, 0xe1, 0xe9, 0xed, 0xeb, 0xe5, 0xe6, 0xee, 0xf8, 0xfc, 0xf9, 0xf7, 0x00, 0x0e, 0x0d, 0xff, 0xf1, 0xf3, 0xfe, 0x07, 0x07, + 0x0c, 0x0f, 0x0e, 0x09, 0x03, 0xfe, 0xfd, 0x07, 0x11, 0x14, 0x10, 0x0c, 0x0b, 0x0e, 0x10, 0x11, 0x0f, 0x0d, 0x0e, 0x18, 0x23, 0x26, + 0x16, 0x19, 0x2d, 0x32, 0x35, 0x38, 0x35, 0x21, 0x1c, 0x23, 0x28, 0x31, 0x35, 0x33, 0x31, 0x2a, 0x26, 0x2b, 0x2f, 0x32, 0x35, 0x3b, + 0x39, 0x3d, 0x47, 0x4a, 0x48, 0x47, 0x49, 0x4e, 0x4d, 0x46, 0x43, 0x41, 0x43, 0x46, 0x44, 0x3c, 0x38, 0x3b, 0x36, 0x33, 0x34, 0x33, + 0x30, 0x2e, 0x30, 0x36, 0x3d, 0x3e, 0x35, 0x2c, 0x27, 0x27, 0x26, 0x23, 0x16, 0x09, 0x0a, 0x16, 0x1c, 0x13, 0x18, 0x24, 0x28, 0x19, + 0x17, 0x1d, 0x20, 0x24, 0x23, 0x22, 0x27, 0x25, 0x21, 0x1c, 0x16, 0x0e, 0x0d, 0x14, 0x25, 0x23, 0x19, 0x1a, 0x1b, 0x19, 0x15, 0x15, + 0x09, 0xf6, 0xe8, 0xef, 0xf3, 0xf4, 0xfc, 0x05, 0x01, 0xf6, 0xf6, 0xf4, 0xef, 0xe9, 0xea, 0xeb, 0xea, 0xe9, 0xe2, 0xdc, 0xda, 0xd9, + 0xd4, 0xcf, 0xd1, 0xd7, 0xdb, 0xd6, 0xc8, 0xc0, 0xc1, 0xcb, 0xd5, 0xd8, 0xd0, 0xc4, 0xbd, 0xbd, 0xbf, 0xbf, 0xba, 0xb9, 0xbc, 0xbc, + 0xb2, 0xa6, 0xa1, 0x9f, 0x9b, 0x96, 0x98, 0x9e, 0xa1, 0xa1, 0xa7, 0xa8, 0xa5, 0xa2, 0xa6, 0xaa, 0xaa, 0xaa, 0xa8, 0xa7, 0xaa, 0xb0, + 0xb2, 0xb0, 0xac, 0xac, 0xaf, 0xb2, 0xaf, 0xab, 0xa9, 0xac, 0xb2, 0xb6, 0xb6, 0xb2, 0xb2, 0xb8, 0xc0, 0xc5, 0xc8, 0xc7, 0xc2, 0xbc, + 0xba, 0xbd, 0xc5, 0xce, 0xd3, 0xd4, 0xd1, 0xd1, 0xd6, 0xe1, 0xe8, 0xe8, 0xe5, 0xe3, 0xe3, 0xe7, 0xed, 0xf3, 0xf9, 0xff, 0x05, 0x09, + 0x07, 0xff, 0xf9, 0xfe, 0x09, 0x10, 0x0b, 0x05, 0x06, 0x10, 0x16, 0x1a, 0x20, 0x1e, 0x1c, 0x1d, 0x21, 0x27, 0x2e, 0x33, 0x35, 0x33, + 0x31, 0x31, 0x31, 0x33, 0x36, 0x36, 0x38, 0x38, 0x36, 0x34, 0x33, 0x36, 0x3b, 0x3d, 0x39, 0x37, 0x39, 0x3b, 0x3c, 0x3e, 0x41, 0x41, + 0x40, 0x3e, 0x40, 0x43, 0x46, 0x46, 0x43, 0x3e, 0x3b, 0x3a, 0x3b, 0x3a, 0x36, 0x31, 0x2b, 0x27, 0x25, 0x28, 0x2b, 0x2d, 0x30, 0x30, + 0x30, 0x31, 0x32, 0x32, 0x35, 0x38, 0x3a, 0x37, 0x32, 0x31, 0x35, 0x3a, 0x3c, 0x3f, 0x3c, 0x35, 0x31, 0x33, 0x39, 0x3b, 0x3a, 0x37, + 0x35, 0x35, 0x33, 0x2f, 0x2b, 0x28, 0x29, 0x2c, 0x2d, 0x2b, 0x29, 0x29, 0x2a, 0x29, 0x27, 0x28, 0x2c, 0x32, 0x33, 0x30, 0x2c, 0x28, + 0x25, 0x22, 0x23, 0x24, 0x24, 0x20, 0x20, 0x21, 0x21, 0x1e, 0x17, 0x0f, 0x0c, 0x0d, 0x10, 0x12, 0x10, 0x0c, 0x08, 0x06, 0x06, 0x08, + 0x09, 0x07, 0x06, 0x02, 0xfb, 0xf5, 0xf8, 0x01, 0x05, 0x00, 0xf9, 0xf7, 0xf8, 0xf8, 0xf6, 0xf6, 0xf8, 0xf9, 0xf5, 0xee, 0xeb, 0xec, + 0xec, 0xed, 0xee, 0xf0, 0xf0, 0xee, 0xe9, 0xe4, 0xe0, 0xdf, 0xdf, 0xdd, 0xdb, 0xda, 0xdd, 0xe0, 0xe1, 0xdb, 0xd5, 0xd5, 0xdc, 0xdf, + 0xdc, 0xd9, 0xd7, 0xd5, 0xd5, 0xd2, 0xce, 0xca, 0xc8, 0xc7, 0xc9, 0xcc, 0xcd, 0xcb, 0xc9, 0xc8, 0xc5, 0xc2, 0xbe, 0xbc, 0xb8, 0xb5, + 0xb5, 0xb5, 0xb7, 0xba, 0xba, 0xb7, 0xb2, 0xb1, 0xb4, 0xb5, 0xb5, 0xb4, 0xb9, 0xba, 0xb9, 0xbb, 0xc0, 0xc1, 0xba, 0xb4, 0xae, 0xab, + 0xab, 0xae, 0xb2, 0xb6, 0xbb, 0xbe, 0xc0, 0xc2, 0xc5, 0xc9, 0xcb, 0xc9, 0xc9, 0xc9, 0xc9, 0xca, 0xce, 0xcf, 0xcf, 0xd2, 0xd6, 0xd8, + 0xd9, 0xd9, 0xd8, 0xd8, 0xdc, 0xde, 0xde, 0xdf, 0xe3, 0xe7, 0xe8, 0xe6, 0xe3, 0xe3, 0xe8, 0xec, 0xef, 0xf1, 0xf2, 0xf7, 0xfa, 0xfa, + 0xf9, 0xf7, 0xf4, 0xf3, 0xf9, 0x01, 0x0a, 0x11, 0x12, 0x10, 0x11, 0x15, 0x16, 0x16, 0x15, 0x16, 0x1a, 0x1e, 0x1e, 0x1a, 0x19, 0x1c, + 0x1f, 0x1f, 0x1a, 0x17, 0x18, 0x1b, 0x1c, 0x1a, 0x19, 0x19, 0x1a, 0x1e, 0x23, 0x28, 0x2a, 0x2e, 0x34, 0x3a, 0x3d, 0x39, 0x33, 0x2f, + 0x31, 0x35, 0x37, 0x37, 0x37, 0x39, 0x3b, 0x3e, 0x3f, 0x3e, 0x3e, 0x40, 0x42, 0x41, 0x3d, 0x39, 0x3b, 0x41, 0x45, 0x48, 0x49, 0x48, + 0x45, 0x43, 0x44, 0x47, 0x4a, 0x4b, 0x4a, 0x48, 0x47, 0x48, 0x4b, 0x4e, 0x4f, 0x4c, 0x48, 0x45, 0x44, 0x43, 0x43, 0x43, 0x43, 0x43, + 0x42, 0x40, 0x3f, 0x40, 0x41, 0x43, 0x42, 0x3e, 0x39, 0x35, 0x33, 0x32, 0x34, 0x36, 0x34, 0x2e, 0x27, 0x26, 0x29, 0x2e, 0x2f, 0x2c, + 0x25, 0x20, 0x21, 0x26, 0x27, 0x22, 0x1c, 0x1a, 0x19, 0x16, 0x11, 0x0e, 0x0b, 0x0a, 0x08, 0x06, 0x04, 0x03, 0x01, 0xfd, 0xfa, 0xf8, + 0xf5, 0xf4, 0xf7, 0xfc, 0xfd, 0xfc, 0xf9, 0xf3, 0xee, 0xea, 0xe8, 0xea, 0xed, 0xee, 0xec, 0xea, 0xe8, 0xe6, 0xe6, 0xe7, 0xe6, 0xe1, + 0xdc, 0xd9, 0xda, 0xdd, 0xdd, 0xd8, 0xd0, 0xcc, 0xce, 0xd3, 0xd4, 0xd0, 0xcc, 0xcd, 0xd1, 0xd6, 0xd7, 0xd6, 0xd5, 0xd8, 0xdd, 0xe0, + 0xdd, 0xd8, 0xd3, 0xd3, 0xd4, 0xd4, 0xd1, 0xcc, 0xc8, 0xc7, 0xc8, 0xc8, 0xc6, 0xc6, 0xc6, 0xc4, 0xc1, 0xc2, 0xc4, 0xc6, 0xc6, 0xc7, + 0xc7, 0xc9, 0xcb, 0xc9, 0xc7, 0xc5, 0xc6, 0xc8, 0xc9, 0xc7, 0xc7, 0xc4, 0xc3, 0xc4, 0xc6, 0xc6, 0xc4, 0xc3, 0xc2, 0xc2, 0xc2, 0xc4, + 0xc7, 0xca, 0xcc, 0xcc, 0xca, 0xc8, 0xc6, 0xc5, 0xc4, 0xc4, 0xc5, 0xc9, 0xcb, 0xcc, 0xcd, 0xce, 0xd0, 0xd2, 0xd5, 0xd8, 0xda, 0xd9, + 0xd8, 0xd7, 0xd8, 0xdc, 0xe2, 0xe5, 0xe4, 0xe2, 0xe5, 0xea, 0xee, 0xed, 0xea, 0xe7, 0xea, 0xf1, 0xf5, 0xf5, 0xf1, 0xf1, 0xf5, 0xf9, + 0xfd, 0xff, 0xff, 0xfd, 0xfb, 0xfb, 0x00, 0x05, 0x08, 0x08, 0x07, 0x09, 0x0c, 0x0e, 0x0f, 0x0f, 0x0f, 0x12, 0x15, 0x17, 0x17, 0x17, + 0x19, 0x1e, 0x22, 0x22, 0x21, 0x23, 0x25, 0x25, 0x25, 0x26, 0x2b, 0x2f, 0x31, 0x2f, 0x2c, 0x2c, 0x2f, 0x36, 0x3a, 0x3a, 0x39, 0x37, + 0x36, 0x36, 0x36, 0x36, 0x36, 0x37, 0x36, 0x35, 0x35, 0x37, 0x37, 0x35, 0x33, 0x34, 0x39, 0x3e, 0x40, 0x3e, 0x3b, 0x3a, 0x39, 0x3a, + 0x3a, 0x3a, 0x3c, 0x3d, 0x3d, 0x3c, 0x3c, 0x3b, 0x39, 0x37, 0x35, 0x35, 0x36, 0x37, 0x36, 0x34, 0x35, 0x38, 0x38, 0x34, 0x30, 0x2b, + 0x29, 0x2b, 0x2c, 0x29, 0x26, 0x24, 0x26, 0x28, 0x29, 0x28, 0x25, 0x20, 0x1e, 0x1d, 0x1f, 0x21, 0x22, 0x22, 0x20, 0x20, 0x22, 0x23, + 0x23, 0x22, 0x24, 0x27, 0x26, 0x24, 0x20, 0x1d, 0x1c, 0x1d, 0x1b, 0x19, 0x18, 0x17, 0x17, 0x16, 0x15, 0x14, 0x14, 0x14, 0x10, 0x0c, + 0x0b, 0x0e, 0x0f, 0x0f, 0x0c, 0x0a, 0x0a, 0x0a, 0x0c, 0x0c, 0x0b, 0x08, 0x06, 0x04, 0x03, 0x03, 0x04, 0x03, 0x00, 0xfe, 0xff, 0xfd, + 0xfa, 0xf9, 0xfb, 0xfc, 0xfc, 0xfb, 0xf8, 0xf4, 0xf3, 0xf2, 0xf2, 0xf1, 0xee, 0xec, 0xec, 0xed, 0xec, 0xea, 0xe7, 0xe5, 0xe4, 0xe4, + 0xe3, 0xe2, 0xe2, 0xe3, 0xe4, 0xe5, 0xe4, 0xe3, 0xe3, 0xe1, 0xde, 0xdc, 0xdc, 0xdb, 0xdc, 0xdd, 0xde, 0xdf, 0xe0, 0xde, 0xda, 0xd6, + 0xd3, 0xd5, 0xd7, 0xd7, 0xd6, 0xd4, 0xd0, 0xcb, 0xc7, 0xc8, 0xca, 0xcb, 0xca, 0xcc, 0xcf, 0xcf, 0xcd, 0xcc, 0xcb, 0xca, 0xca, 0xc9, + 0xc8, 0xc8, 0xc8, 0xc8, 0xc8, 0xc7, 0xc3, 0xc0, 0xbe, 0xbe, 0xbe, 0xbd, 0xb9, 0xb9, 0xbc, 0xbf, 0xc0, 0xbf, 0xbf, 0xbf, 0xc0, 0xc2, + 0xc5, 0xc5, 0xc6, 0xc7, 0xc9, 0xcb, 0xcc, 0xcb, 0xc8, 0xca, 0xcd, 0xce, 0xce, 0xcd, 0xce, 0xd0, 0xd3, 0xd6, 0xd8, 0xd8, 0xd8, 0xd9, + 0xdc, 0xe1, 0xe4, 0xe3, 0xe3, 0xe4, 0xe8, 0xeb, 0xec, 0xeb, 0xec, 0xef, 0xf1, 0xf3, 0xf3, 0xf4, 0xf4, 0xf6, 0xfa, 0xfc, 0xfe, 0xff, + 0x00, 0x02, 0x03, 0x04, 0x05, 0x03, 0x03, 0x05, 0x06, 0x08, 0x0c, 0x10, 0x12, 0x11, 0x10, 0x12, 0x15, 0x17, 0x17, 0x19, 0x1b, 0x1e, + 0x21, 0x21, 0x20, 0x21, 0x24, 0x27, 0x29, 0x29, 0x28, 0x28, 0x29, 0x2b, 0x2d, 0x2e, 0x2e, 0x2d, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, + 0x2d, 0x2d, 0x2e, 0x30, 0x31, 0x33, 0x34, 0x36, 0x38, 0x3a, 0x3b, 0x3b, 0x3c, 0x3f, 0x42, 0x43, 0x43, 0x40, 0x3e, 0x3f, 0x40, 0x41, + 0x41, 0x40, 0x40, 0x41, 0x42, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x45, 0x46, 0x46, 0x43, 0x41, 0x40, 0x3f, 0x3e, 0x3d, 0x3c, 0x3b, + 0x3b, 0x3b, 0x3c, 0x3b, 0x39, 0x36, 0x34, 0x34, 0x35, 0x36, 0x35, 0x35, 0x34, 0x35, 0x35, 0x33, 0x30, 0x2d, 0x2b, 0x2b, 0x2b, 0x29, + 0x26, 0x23, 0x22, 0x23, 0x20, 0x1c, 0x19, 0x19, 0x1b, 0x1c, 0x1a, 0x17, 0x13, 0x10, 0x0d, 0x0d, 0x0d, 0x0c, 0x0a, 0x07, 0x06, 0x07, + 0x08, 0x05, 0xff, 0xfc, 0xfb, 0xfb, 0xfa, 0xf9, 0xf7, 0xf5, 0xf3, 0xf3, 0xf4, 0xf4, 0xf2, 0xf0, 0xef, 0xef, 0xed, 0xeb, 0xea, 0xe9, + 0xe8, 0xe6, 0xe4, 0xe5, 0xe6, 0xe7, 0xe6, 0xe5, 0xe6, 0xe6, 0xe6, 0xe6, 0xe5, 0xe4, 0xe1, 0xdf, 0xdd, 0xdb, 0xd9, 0xd7, 0xd6, 0xd7, + 0xd7, 0xd7, 0xd7, 0xd6, 0xd6, 0xd5, 0xd4, 0xd4, 0xd4, 0xd5, 0xd7, 0xd8, 0xd9, 0xda, 0xda, 0xd9, 0xd8, 0xd8, 0xd7, 0xd7, 0xd8, 0xd9, + 0xd7, 0xd7, 0xd8, 0xd9, 0xda, 0xd8, 0xd5, 0xd4, 0xd2, 0xd2, 0xd3, 0xd3, 0xd2, 0xd1, 0xcf, 0xcf, 0xcf, 0xd0, 0xcf, 0xce, 0xce, 0xce, + 0xce, 0xcf, 0xce, 0xcd, 0xcd, 0xcd, 0xce, 0xd0, 0xd2, 0xd3, 0xd2, 0xd0, 0xcf, 0xce, 0xd0, 0xd2, 0xd2, 0xd1, 0xcf, 0xce, 0xcd, 0xce, + 0xcf, 0xd1, 0xd2, 0xd2, 0xd1, 0xd0, 0xcf, 0xcf, 0xd0, 0xd0, 0xd1, 0xd2, 0xd2, 0xd1, 0xd1, 0xd1, 0xd3, 0xd5, 0xd6, 0xd7, 0xd7, 0xd8, + 0xda, 0xda, 0xdb, 0xdb, 0xdb, 0xdb, 0xdc, 0xdd, 0xdf, 0xdf, 0xdf, 0xe1, 0xe5, 0xe8, 0xe9, 0xe9, 0xeb, 0xee, 0xf0, 0xf2, 0xf5, 0xf8, + 0xfb, 0xfc, 0xfd, 0xfe, 0x01, 0x03, 0x04, 0x03, 0x04, 0x07, 0x0c, 0x0f, 0x10, 0x0f, 0x0f, 0x10, 0x12, 0x14, 0x15, 0x16, 0x18, 0x1c, + 0x20, 0x23, 0x23, 0x23, 0x24, 0x29, 0x2d, 0x30, 0x31, 0x30, 0x2f, 0x2f, 0x30, 0x33, 0x34, 0x34, 0x33, 0x32, 0x32, 0x34, 0x35, 0x37, + 0x36, 0x35, 0x35, 0x35, 0x35, 0x35, 0x34, 0x34, 0x34, 0x33, 0x33, 0x34, 0x35, 0x35, 0x36, 0x37, 0x39, 0x38, 0x37, 0x36, 0x37, 0x37, + 0x37, 0x36, 0x36, 0x37, 0x37, 0x39, 0x3b, 0x3c, 0x3c, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x38, 0x35, 0x33, 0x33, 0x33, 0x32, 0x30, 0x2f, + 0x2f, 0x30, 0x31, 0x32, 0x32, 0x31, 0x2f, 0x2e, 0x2d, 0x2c, 0x2c, 0x2a, 0x28, 0x26, 0x25, 0x25, 0x26, 0x27, 0x25, 0x24, 0x25, 0x26, + 0x27, 0x27, 0x27, 0x26, 0x25, 0x24, 0x22, 0x20, 0x20, 0x21, 0x22, 0x21, 0x20, 0x1f, 0x1d, 0x1d, 0x1d, 0x1c, 0x1a, 0x17, 0x15, 0x13, + 0x13, 0x14, 0x14, 0x12, 0x0f, 0x0c, 0x0b, 0x0b, 0x0b, 0x0b, 0x0a, 0x09, 0x08, 0x08, 0x07, 0x05, 0x02, 0x00, 0x00, 0x00, 0x01, 0xff, + 0xfd, 0xfc, 0xfb, 0xfa, 0xf9, 0xf8, 0xf7, 0xf6, 0xf6, 0xf6, 0xf6, 0xf5, 0xf3, 0xf1, 0xef, 0xed, 0xec, 0xea, 0xe9, 0xe9, 0xe9, 0xe8, + 0xe7, 0xe6, 0xe4, 0xe2, 0xe0, 0xdf, 0xdd, 0xdb, 0xd8, 0xd8, 0xd8, 0xd9, 0xd8, 0xd6, 0xd5, 0xd3, 0xd3, 0xd3, 0xd4, 0xd3, 0xd2, 0xd3, + 0xd4, 0xd3, 0xd1, 0xcf, 0xce, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcc, 0xc9, 0xc6, 0xc4, 0xc2, 0xc1, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, + 0xbd, 0xbd, 0xbe, 0xc0, 0xc0, 0xc0, 0xc0, 0xc1, 0xc3, 0xc4, 0xc5, 0xc4, 0xc2, 0xc0, 0xc0, 0xc2, 0xc2, 0xc3, 0xc3, 0xc3, 0xc3, 0xc5, + 0xc6, 0xc5, 0xc4, 0xc3, 0xc4, 0xc4, 0xc5, 0xc5, 0xc4, 0xc4, 0xc5, 0xc5, 0xc4, 0xc5, 0xc7, 0xca, 0xcd, 0xd0, 0xd1, 0xd2, 0xd2, 0xd2, + 0xd3, 0xd4, 0xd4, 0xd3, 0xd3, 0xd3, 0xd5, 0xd7, 0xd9, 0xda, 0xdc, 0xde, 0xe1, 0xe3, 0xe5, 0xe8, 0xea, 0xeb, 0xeb, 0xec, 0xee, 0xf0, + 0xf3, 0xf5, 0xf7, 0xf7, 0xf7, 0xf8, 0xf9, 0xfb, 0xfc, 0xff, 0x01, 0x03, 0x03, 0x05, 0x07, 0x0a, 0x0c, 0x0e, 0x10, 0x11, 0x12, 0x14, + 0x16, 0x19, 0x1b, 0x1c, 0x1f, 0x20, 0x22, 0x23, 0x24, 0x25, 0x25, 0x26, 0x26, 0x26, 0x27, 0x28, 0x2a, 0x2d, 0x2e, 0x2e, 0x2e, 0x2f, + 0x30, 0x32, 0x33, 0x34, 0x35, 0x36, 0x36, 0x37, 0x39, 0x3b, 0x3c, 0x3d, 0x3d, 0x3d, 0x3e, 0x3f, 0x40, 0x40, 0x40, 0x41, 0x41, 0x42, + 0x44, 0x44, 0x44, 0x43, 0x43, 0x43, 0x43, 0x43, 0x42, 0x42, 0x42, 0x40, 0x40, 0x41, 0x43, 0x42, 0x43, 0x43, 0x42, 0x40, 0x3f, 0x3f, + 0x41, 0x42, 0x42, 0x42, 0x40, 0x3e, 0x3e, 0x3f, 0x40, 0x42, 0x42, 0x42, 0x41, 0x40, 0x3f, 0x3d, 0x3c, 0x3a, 0x38, 0x36, 0x35, 0x34, + 0x34, 0x33, 0x31, 0x2f, 0x2e, 0x2e, 0x2c, 0x2b, 0x2b, 0x2a, 0x29, 0x28, 0x26, 0x25, 0x25, 0x25, 0x25, 0x23, 0x21, 0x1f, 0x1e, 0x1f, + 0x1e, 0x1c, 0x19, 0x16, 0x13, 0x11, 0x10, 0x0e, 0x0d, 0x0b, 0x0a, 0x08, 0x06, 0x04, 0x03, 0x01, 0x00, 0xfe, 0xfd, 0xfc, 0xfb, 0xfa, + 0xf9, 0xf7, 0xf6, 0xf5, 0xf5, 0xf6, 0xf7, 0xf6, 0xf5, 0xf4, 0xf3, 0xf1, 0xef, 0xed, 0xec, 0xe9, 0xe6, 0xe3, 0xe1, 0xe0, 0xde, 0xdd, + 0xdc, 0xdd, 0xde, 0xde, 0xdd, 0xdb, 0xd9, 0xd8, 0xd8, 0xd9, 0xd8, 0xd7, 0xd5, 0xd4, 0xd2, 0xd1, 0xd1, 0xd1, 0xd1, 0xd0, 0xd1, 0xd2, + 0xd3, 0xd2, 0xd1, 0xd0, 0xd0, 0xd0, 0xce, 0xce, 0xcd, 0xcd, 0xcc, 0xcb, 0xc9, 0xc7, 0xc7, 0xc7, 0xc7, 0xc6, 0xc5, 0xc4, 0xc3, 0xc2, + 0xc3, 0xc3, 0xc3, 0xc2, 0xc1, 0xc2, 0xc3, 0xc3, 0xc2, 0xc1, 0xc1, 0xc2, 0xc2, 0xc2, 0xc2, 0xc2, 0xc1, 0xc2, 0xc2, 0xc2, 0xc1, 0xc1, + 0xc1, 0xc2, 0xc3, 0xc3, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc8, 0xc9, 0xc9, 0xca, 0xca, 0xca, 0xca, 0xcb, 0xcd, 0xce, 0xce, 0xce, + 0xcf, 0xd1, 0xd2, 0xd4, 0xd5, 0xd5, 0xd6, 0xd6, 0xd6, 0xd7, 0xd8, 0xd9, 0xdb, 0xdc, 0xdd, 0xdf, 0xe1, 0xe3, 0xe5, 0xe6, 0xe8, 0xe8, + 0xe9, 0xea, 0xeb, 0xed, 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf7, 0xf8, 0xfa, 0xfb, 0xfd, 0xff, 0x01, 0x03, 0x05, 0x06, 0x07, 0x08, 0x0a, + 0x0c, 0x0d, 0x0e, 0x10, 0x10, 0x11, 0x12, 0x13, 0x14, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1d, 0x20, 0x22, 0x24, 0x25, 0x25, 0x25, 0x26, + 0x27, 0x29, 0x2b, 0x2c, 0x2d, 0x2d, 0x2e, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x30, 0x31, 0x31, 0x31, 0x32, 0x34, 0x36, 0x38, 0x39, 0x39, + 0x39, 0x3a, 0x3b, 0x3d, 0x3d, 0x3e, 0x3f, 0x3f, 0x40, 0x41, 0x40, 0x3f, 0x3e, 0x3d, 0x3c, 0x3c, 0x3b, 0x3a, 0x39, 0x37, 0x37, 0x37, + 0x37, 0x38, 0x39, 0x3a, 0x3a, 0x39, 0x39, 0x39, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x39, 0x39, 0x39, 0x39, 0x3a, 0x3b, 0x3b, 0x3b, 0x3a, + 0x39, 0x38, 0x37, 0x38, 0x39, 0x3a, 0x3a, 0x39, 0x39, 0x38, 0x37, 0x36, 0x36, 0x35, 0x34, 0x32, 0x31, 0x2f, 0x2e, 0x2e, 0x2f, 0x2f, + 0x30, 0x2f, 0x2e, 0x2d, 0x2d, 0x2c, 0x2b, 0x29, 0x28, 0x26, 0x24, 0x22, 0x20, 0x1e, 0x1d, 0x1c, 0x1b, 0x1a, 0x19, 0x17, 0x16, 0x14, + 0x13, 0x12, 0x10, 0x0e, 0x0c, 0x0a, 0x08, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0xfe, 0xfc, 0xfa, 0xf7, 0xf5, 0xf4, 0xf2, 0xf1, + 0xef, 0xee, 0xec, 0xeb, 0xeb, 0xeb, 0xea, 0xe8, 0xe6, 0xe5, 0xe3, 0xe2, 0xe1, 0xde, 0xdc, 0xd9, 0xd7, 0xd4, 0xd2, 0xd0, 0xce, 0xcc, + 0xcb, 0xca, 0xc9, 0xc9, 0xc8, 0xc8, 0xc8, 0xc8, 0xc7, 0xc6, 0xc6, 0xc5, 0xc4, 0xc3, 0xc2, 0xc1, 0xc1, 0xc0, 0xc1, 0xc1, 0xc0, 0xbf, + 0xbe, 0xbe, 0xbf, 0xc0, 0xbf, 0xbe, 0xbd, 0xbd, 0xbe, 0xbe, 0xbf, 0xc0, 0xc1, 0xc0, 0xc0, 0xbf, 0xbe, 0xbc, 0xbb, 0xbb, 0xbb, 0xba, + 0xb9, 0xb8, 0xb7, 0xb7, 0xb7, 0xb7, 0xb8, 0xba, 0xbb, 0xbc, 0xbc, 0xbd, 0xbe, 0xbe, 0xc0, 0xc1, 0xc1, 0xc1, 0xc1, 0xc2, 0xc3, 0xc4, + 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xcc, 0xcd, 0xce, 0xcf, 0xd0, 0xd2, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd9, 0xd9, 0xda, 0xdb, + 0xdd, 0xde, 0xe0, 0xe1, 0xe3, 0xe4, 0xe5, 0xe7, 0xe9, 0xeb, 0xed, 0xef, 0xf1, 0xf3, 0xf5, 0xf8, 0xfb, 0xfd, 0xff, 0x00, 0x02, 0x03, + 0x06, 0x07, 0x09, 0x0a, 0x0b, 0x0d, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x16, 0x16, 0x17, 0x17, 0x18, 0x19, 0x1b, 0x1d, 0x1f, 0x21, + 0x23, 0x25, 0x27, 0x28, 0x29, 0x29, 0x2a, 0x2a, 0x2b, 0x2c, 0x2e, 0x2f, 0x2f, 0x30, 0x31, 0x31, 0x31, 0x31, 0x31, 0x32, 0x33, 0x34, + 0x36, 0x37, 0x37, 0x37, 0x37, 0x38, 0x39, 0x3b, 0x3c, 0x3d, 0x3d, 0x3d, 0x3e, 0x3e, 0x3e, 0x3e, 0x3f, 0x3f, 0x40, 0x41, 0x41, 0x41, + 0x41, 0x41, 0x41, 0x41, 0x40, 0x40, 0x3f, 0x40, 0x40, 0x3f, 0x3e, 0x3e, 0x3e, 0x3e, 0x3d, 0x3d, 0x3d, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, + 0x3d, 0x3c, 0x3c, 0x3c, 0x3b, 0x3a, 0x39, 0x38, 0x37, 0x37, 0x36, 0x35, 0x34, 0x34, 0x34, 0x33, 0x32, 0x31, 0x30, 0x30, 0x30, 0x30, + 0x2f, 0x2e, 0x2c, 0x2a, 0x29, 0x27, 0x26, 0x24, 0x22, 0x22, 0x21, 0x20, 0x1e, 0x1c, 0x1c, 0x1b, 0x1a, 0x18, 0x17, 0x15, 0x13, 0x12, + 0x10, 0x0e, 0x0c, 0x0a, 0x09, 0x07, 0x06, 0x05, 0x03, 0x02, 0x00, 0xfe, 0xfc, 0xfa, 0xf9, 0xf8, 0xf6, 0xf5, 0xf4, 0xf3, 0xf3, 0xf3, + 0xf2, 0xf1, 0xef, 0xee, 0xec, 0xeb, 0xe9, 0xe7, 0xe6, 0xe5, 0xe4, 0xe3, 0xe2, 0xe0, 0xdf, 0xdd, 0xdc, 0xdb, 0xda, 0xda, 0xd9, 0xd7, + 0xd7, 0xd6, 0xd5, 0xd4, 0xd3, 0xd1, 0xd1, 0xd0, 0xd0, 0xd0, 0xd0, 0xd0, 0xd0, 0xd0, 0xd0, 0xcf, 0xce, 0xcd, 0xcd, 0xcd, 0xcc, 0xca, + 0xc9, 0xc9, 0xc9, 0xc9, 0xca, 0xca, 0xca, 0xca, 0xcb, 0xcc, 0xcc, 0xcd, 0xcd, 0xce, 0xcf, 0xcf, 0xd0, 0xd1, 0xd1, 0xd1, 0xd2, 0xd3, + 0xd4, 0xd4, 0xd4, 0xd3, 0xd3, 0xd3, 0xd3, 0xd3, 0xd2, 0xd1, 0xd1, 0xd1, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd5, 0xd5, 0xd4, 0xd4, + 0xd4, 0xd5, 0xd5, 0xd5, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xdf, 0xdf, 0xe0, 0xe0, 0xe1, 0xe1, 0xe1, 0xe1, 0xe1, + 0xe1, 0xe1, 0xe1, 0xe1, 0xe1, 0xe1, 0xe1, 0xe2, 0xe2, 0xe4, 0xe4, 0xe6, 0xe7, 0xe8, 0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, + 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf8, 0xf9, 0xfb, 0xfd, 0xfe, 0x00, 0x01, 0x01, 0x02, 0x04, 0x06, 0x07, 0x08, 0x09, 0x0a, + 0x0b, 0x0d, 0x0e, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x18, 0x19, 0x1a, 0x1b, 0x1d, 0x1d, 0x1e, 0x1e, 0x1f, 0x20, + 0x21, 0x22, 0x23, 0x24, 0x26, 0x27, 0x28, 0x28, 0x28, 0x28, 0x29, 0x2a, 0x2a, 0x2b, 0x2b, 0x2b, 0x2c, 0x2c, 0x2c, 0x2c, 0x2b, 0x2b, + 0x2b, 0x2c, 0x2b, 0x2b, 0x2b, 0x2c, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2f, 0x2f, 0x2f, 0x2f, + 0x2e, 0x2e, 0x2e, 0x2e, 0x2d, 0x2d, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2b, 0x2b, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, + 0x2b, 0x2b, 0x2a, 0x29, 0x2a, 0x2b, 0x2b, 0x2b, 0x2b, 0x2a, 0x2a, 0x29, 0x28, 0x27, 0x26, 0x26, 0x25, 0x25, 0x24, 0x23, 0x21, 0x20, + 0x20, 0x20, 0x20, 0x1f, 0x1e, 0x1c, 0x1b, 0x1a, 0x19, 0x18, 0x18, 0x18, 0x17, 0x17, 0x15, 0x14, 0x13, 0x12, 0x11, 0x10, 0x0e, 0x0b, + 0x09, 0x08, 0x07, 0x07, 0x06, 0x05, 0x04, 0x02, 0x01, 0x00, 0xff, 0xfe, 0xfd, 0xfc, 0xfb, 0xfa, 0xf9, 0xf9, 0xf8, 0xf8, 0xf7, 0xf7, + 0xf5, 0xf3, 0xf2, 0xf1, 0xf0, 0xee, 0xec, 0xeb, 0xe9, 0xe8, 0xe7, 0xe5, 0xe4, 0xe3, 0xe2, 0xe1, 0xe0, 0xdf, 0xdf, 0xdf, 0xdf, 0xde, + 0xde, 0xdd, 0xdc, 0xdb, 0xda, 0xda, 0xd9, 0xd8, 0xd8, 0xd8, 0xd7, 0xd6, 0xd6, 0xd4, 0xd4, 0xd4, 0xd3, 0xd2, 0xd1, 0xd1, 0xd0, 0xcf, + 0xcf, 0xce, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xce, 0xce, 0xce, 0xcf, 0xd0, 0xd1, 0xd1, 0xd1, 0xd1, 0xd1, 0xd2, 0xd2, 0xd3, + 0xd3, 0xd4, 0xd4, 0xd4, 0xd3, 0xd3, 0xd3, 0xd3, 0xd3, 0xd3, 0xd3, 0xd3, 0xd3, 0xd2, 0xd2, 0xd2, 0xd2, 0xd3, 0xd4, 0xd5, 0xd7, 0xd8, + 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf, 0xe0, 0xe1, 0xe2, 0xe4, 0xe5, 0xe5, 0xe6, 0xe6, 0xe7, 0xe8, 0xe8, 0xe9, 0xe9, 0xea, 0xeb, 0xec, + 0xed, 0xee, 0xee, 0xee, 0xef, 0xf0, 0xf1, 0xf1, 0xf1, 0xf1, 0xf2, 0xf3, 0xf3, 0xf4, 0xf5, 0xf6, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfc, + 0xfd, 0xfe, 0xff, 0xff, 0xff, 0x00, 0x01, 0x02, 0x03, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x09, 0x09, 0x09, 0x0a, 0x0b, 0x0c, + 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1c, 0x1d, 0x1d, 0x1d, 0x1e, 0x1f, + 0x1f, 0x20, 0x20, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x26, 0x26, 0x26, 0x26, 0x26, 0x25, 0x26, 0x26, + 0x27, 0x28, 0x29, 0x2a, 0x2a, 0x29, 0x28, 0x27, 0x26, 0x26, 0x26, 0x26, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x26, 0x26, 0x26, 0x26, + 0x26, 0x26, 0x27, 0x27, 0x26, 0x25, 0x25, 0x24, 0x24, 0x23, 0x22, 0x21, 0x21, 0x21, 0x20, 0x20, 0x20, 0x1f, 0x1e, 0x1e, 0x1e, 0x1e, + 0x1d, 0x1c, 0x1b, 0x1a, 0x19, 0x19, 0x18, 0x18, 0x17, 0x17, 0x17, 0x16, 0x15, 0x14, 0x13, 0x13, 0x13, 0x14, 0x14, 0x13, 0x13, 0x13, + 0x13, 0x12, 0x12, 0x12, 0x12, 0x12, 0x11, 0x10, 0x10, 0x0f, 0x0e, 0x0d, 0x0c, 0x0b, 0x0a, 0x0a, 0x09, 0x08, 0x08, 0x07, 0x06, 0x05, + 0x04, 0x03, 0x03, 0x02, 0x02, 0x01, 0x01, 0x00, 0x00, 0x00, 0xff, 0xff, 0xfe, 0xfd, 0xfc, 0xfc, 0xfb, 0xfa, 0xf9, 0xf7, 0xf7, 0xf6, + 0xf6, 0xf5, 0xf4, 0xf3, 0xf1, 0xf1, 0xf0, 0xef, 0xed, 0xec, 0xeb, 0xeb, 0xeb, 0xeb, 0xea, 0xea, 0xea, 0xea, 0xea, 0xea, 0xe9, 0xe8, + 0xe8, 0xe7, 0xe6, 0xe5, 0xe5, 0xe4, 0xe4, 0xe4, 0xe4, 0xe4, 0xe3, 0xe3, 0xe3, 0xe3, 0xe3, 0xe2, 0xe2, 0xe2, 0xe2, 0xe2, 0xe2, 0xe2, + 0xe3, 0xe4, 0xe5, 0xe5, 0xe5, 0xe6, 0xe6, 0xe6, 0xe6, 0xe5, 0xe6, 0xe6, 0xe6, 0xe5, 0xe4, 0xe4, 0xe4, 0xe4, 0xe3, 0xe3, 0xe3, 0xe3, + 0xe3, 0xe3, 0xe3, 0xe3, 0xe3, 0xe4, 0xe4, 0xe5, 0xe5, 0xe5, 0xe5, 0xe5, 0xe5, 0xe4, 0xe4, 0xe4, 0xe4, 0xe4, 0xe5, 0xe5, 0xe5, 0xe5, + 0xe5, 0xe5, 0xe5, 0xe6, 0xe6, 0xe5, 0xe5, 0xe4, 0xe4, 0xe4, 0xe5, 0xe5, 0xe5, 0xe4, 0xe4, 0xe4, 0xe4, 0xe4, 0xe4, 0xe4, 0xe4, 0xe4, + 0xe4, 0xe5, 0xe6, 0xe7, 0xe7, 0xe7, 0xe7, 0xe8, 0xe9, 0xe9, 0xea, 0xea, 0xea, 0xea, 0xeb, 0xeb, 0xec, 0xed, 0xef, 0xf1, 0xf2, 0xf2, + 0xf3, 0xf4, 0xf4, 0xf3, 0xf3, 0xf3, 0xf3, 0xf3, 0xf3, 0xf3, 0xf3, 0xf4, 0xf5, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfc, + 0xfd, 0xff, 0x00, 0x01, 0x01, 0x02, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x0a, 0x0a, 0x0b, 0x0c, 0x0d, 0x0d, 0x0e, 0x0f, 0x0f, + 0x10, 0x11, 0x11, 0x12, 0x12, 0x13, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x19, 0x19, 0x19, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, + 0x1e, 0x1f, 0x20, 0x21, 0x21, 0x22, 0x22, 0x22, 0x23, 0x23, 0x23, 0x24, 0x25, 0x25, 0x26, 0x27, 0x27, 0x28, 0x28, 0x28, 0x29, 0x29, + 0x29, 0x29, 0x29, 0x29, 0x28, 0x28, 0x28, 0x28, 0x28, 0x27, 0x27, 0x27, 0x27, 0x26, 0x26, 0x25, 0x25, 0x26, 0x27, 0x27, 0x27, 0x26, + 0x26, 0x26, 0x27, 0x27, 0x28, 0x28, 0x27, 0x26, 0x25, 0x25, 0x25, 0x25, 0x26, 0x26, 0x26, 0x26, 0x26, 0x25, 0x24, 0x24, 0x23, 0x23, + 0x22, 0x20, 0x1f, 0x1d, 0x1c, 0x1b, 0x1c, 0x1c, 0x1c, 0x1b, 0x1a, 0x1a, 0x19, 0x18, 0x18, 0x17, 0x16, 0x15, 0x14, 0x13, 0x13, 0x12, + 0x11, 0x10, 0x0f, 0x0e, 0x0d, 0x0c, 0x0b, 0x0a, 0x09, 0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x01, 0x00, 0xff, 0xfd, 0xfc, 0xfa, 0xf9, + 0xf8, 0xf7, 0xf5, 0xf4, 0xf3, 0xf3, 0xf2, 0xf2, 0xf1, 0xf0, 0xf0, 0xef, 0xef, 0xee, 0xed, 0xec, 0xec, 0xeb, 0xeb, 0xea, 0xe9, 0xe8, + 0xe7, 0xe6, 0xe6, 0xe5, 0xe5, 0xe4, 0xe4, 0xe3, 0xe2, 0xe1, 0xe1, 0xe0, 0xe0, 0xdf, 0xdf, 0xdf, 0xde, 0xde, 0xde, 0xdf, 0xdf, 0xdf, + 0xdf, 0xdf, 0xdf, 0xdf, 0xde, 0xde, 0xde, 0xde, 0xde, 0xde, 0xde, 0xde, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, + 0xdd, 0xdc, 0xdc, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdc, 0xdc, 0xdc, 0xdb, 0xda, 0xda, 0xd9, 0xd9, 0xd9, 0xda, 0xdb, + 0xdc, 0xdc, 0xdd, 0xdd, 0xde, 0xde, 0xde, 0xde, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xe0, 0xe0, 0xe0, 0xe0, 0xe0, 0xe1, 0xe1, 0xe1, + 0xe1, 0xe1, 0xe2, 0xe2, 0xe3, 0xe3, 0xe4, 0xe4, 0xe5, 0xe6, 0xe7, 0xe7, 0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xec, 0xed, 0xee, 0xef, 0xf0, + 0xf0, 0xf1, 0xf2, 0xf2, 0xf3, 0xf4, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xf9, 0xfa, 0xfa, 0xfb, 0xfd, 0xfe, 0xff, 0x00, 0x01, 0x02, + 0x03, 0x03, 0x04, 0x05, 0x06, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0b, 0x0c, 0x0c, 0x0d, 0x0e, 0x0f, 0x0f, 0x10, 0x11, 0x11, 0x12, + 0x13, 0x14, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1d, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, + 0x1e, 0x1e, 0x1e, 0x1f, 0x1f, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x21, 0x21, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, + 0x22, 0x22, 0x22, 0x22, 0x22, 0x21, 0x21, 0x21, 0x21, 0x22, 0x22, 0x21, 0x22, 0x22, 0x22, 0x22, 0x23, 0x23, 0x22, 0x22, 0x22, 0x22, + 0x21, 0x21, 0x21, 0x21, 0x21, 0x20, 0x20, 0x20, 0x20, 0x20, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1e, 0x1e, 0x1d, 0x1d, + 0x1d, 0x1d, 0x1d, 0x1d, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1a, + 0x19, 0x19, 0x18, 0x17, 0x16, 0x15, 0x15, 0x14, 0x13, 0x12, 0x12, 0x11, 0x10, 0x10, 0x0f, 0x0e, 0x0d, 0x0c, 0x0b, 0x0b, 0x0a, 0x09, + 0x08, 0x07, 0x07, 0x06, 0x06, 0x05, 0x04, 0x03, 0x03, 0x02, 0x01, 0x00, 0xff, 0xfe, 0xfc, 0xfb, 0xfa, 0xf8, 0xf6, 0xf5, 0xf3, 0xf2, + 0xf0, 0xef, 0xee, 0xed, 0xec, 0xeb, 0xeb, 0xea, 0xe9, 0xe8, 0xe8, 0xe7, 0xe6, 0xe5, 0xe4, 0xe4, 0xe3, 0xe3, 0xe2, 0xe1, 0xe1, 0xe0, + 0xdf, 0xde, 0xde, 0xde, 0xde, 0xdd, 0xdd, 0xdd, 0xdc, 0xdb, 0xdb, 0xda, 0xda, 0xd9, 0xd8, 0xd8, 0xd7, 0xd7, 0xd6, 0xd6, 0xd6, 0xd6, + 0xd6, 0xd6, 0xd6, 0xd6, 0xd5, 0xd5, 0xd5, 0xd5, 0xd5, 0xd4, 0xd4, 0xd4, 0xd4, 0xd3, 0xd3, 0xd3, 0xd4, 0xd4, 0xd4, 0xd4, 0xd4, 0xd4, + 0xd5, 0xd5, 0xd5, 0xd5, 0xd5, 0xd5, 0xd5, 0xd5, 0xd5, 0xd5, 0xd6, 0xd7, 0xd7, 0xd8, 0xd8, 0xd8, 0xd8, 0xd8, 0xd8, 0xd8, 0xd7, 0xd7, + 0xd7, 0xd7, 0xd7, 0xd7, 0xd8, 0xd8, 0xd9, 0xda, 0xda, 0xda, 0xdb, 0xdb, 0xdc, 0xdd, 0xdd, 0xde, 0xde, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, + 0xe0, 0xe1, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xef, 0xf0, 0xf1, 0xf2, 0xf4, 0xf5, + 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff, 0x00, 0x01, 0x02, 0x03, 0x05, 0x07, 0x08, 0x0a, 0x0c, 0x0d, 0x0f, 0x10, 0x12, + 0x13, 0x14, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1e, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x24, 0x25, 0x26, 0x27, 0x28, + 0x29, 0x2a, 0x2b, 0x2c, 0x2c, 0x2d, 0x2e, 0x2f, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x37, 0x37, 0x38, 0x38, 0x38, + 0x38, 0x38, 0x38, 0x39, 0x39, 0x39, 0x39, 0x39, 0x38, 0x38, 0x38, 0x38, 0x38, 0x37, 0x37, 0x37, 0x37, 0x37, 0x37, 0x37, 0x37, 0x37, + 0x37, 0x37, 0x37, 0x37, 0x37, 0x37, 0x37, 0x36, 0x36, 0x35, 0x35, 0x34, 0x33, 0x32, 0x31, 0x30, 0x2f, 0x2e, 0x2d, 0x2c, 0x2b, 0x2a, + 0x29, 0x28, 0x28, 0x27, 0x27, 0x27, 0x26, 0x25, 0x24, 0x23, 0x22, 0x21, 0x20, 0x1f, 0x1e, 0x1d, 0x1c, 0x1b, 0x1a, 0x19, 0x18, 0x17, + 0x16, 0x15, 0x14, 0x12, 0x11, 0x10, 0x0e, 0x0d, 0x0b, 0x0a, 0x08, 0x07, 0x05, 0x04, 0x03, 0x02, 0x00, 0xff, 0xfe, 0xfd, 0xfc, 0xfc, + 0xfb, 0xfa, 0xf9, 0xf8, 0xf7, 0xf5, 0xf4, 0xf2, 0xf1, 0xf0, 0xef, 0xed, 0xec, 0xeb, 0xea, 0xe9, 0xe8, 0xe6, 0xe5, 0xe4, 0xe3, 0xe2, + 0xe1, 0xe0, 0xe0, 0xdf, 0xdf, 0xde, 0xde, 0xde, 0xdd, 0xdc, 0xdc, 0xdb, 0xdb, 0xda, 0xda, 0xda, 0xd9, 0xd8, 0xd8, 0xd8, 0xd7, 0xd7, + 0xd6, 0xd5, 0xd5, 0xd4, 0xd3, 0xd3, 0xd2, 0xd2, 0xd1, 0xd1, 0xd1, 0xd0, 0xd0, 0xd0, 0xcf, 0xcf, 0xcf, 0xcf, 0xce, 0xce, 0xce, 0xce, + 0xce, 0xce, 0xce, 0xce, 0xce, 0xcf, 0xcf, 0xcf, 0xd0, 0xd0, 0xd0, 0xd0, 0xd0, 0xd0, 0xd0, 0xd1, 0xd2, 0xd2, 0xd2, 0xd3, 0xd3, 0xd3, + 0xd3, 0xd4, 0xd4, 0xd4, 0xd4, 0xd4, 0xd4, 0xd4, 0xd3, 0xd3, 0xd3, 0xd3, 0xd4, 0xd4, 0xd5, 0xd5, 0xd6, 0xd7, 0xd7, 0xd8, 0xd8, 0xd9, + 0xd9, 0xda, 0xda, 0xdb, 0xdc, 0xdc, 0xdd, 0xdd, 0xde, 0xde, 0xdf, 0xe0, 0xe0, 0xe1, 0xe2, 0xe2, 0xe3, 0xe3, 0xe4, 0xe4, 0xe5, 0xe5, + 0xe6, 0xe7, 0xe7, 0xe8, 0xe9, 0xea, 0xeb, 0xed, 0xee, 0xef, 0xf1, 0xf3, 0xf4, 0xf6, 0xf7, 0xf8, 0xfa, 0xfb, 0xfd, 0xfe, 0xff, 0x00, + 0x02, 0x03, 0x04, 0x06, 0x07, 0x08, 0x08, 0x09, 0x0b, 0x0c, 0x0d, 0x0e, 0x10, 0x11, 0x12, 0x13, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, + 0x1b, 0x1c, 0x1d, 0x1e, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2a, 0x2b, 0x2c, 0x2c, 0x2d, 0x2d, 0x2d, + 0x2e, 0x2e, 0x2f, 0x2f, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x32, 0x32, 0x32, + 0x32, 0x32, 0x32, 0x32, 0x32, 0x31, 0x31, 0x30, 0x30, 0x2f, 0x2f, 0x2e, 0x2e, 0x2d, 0x2d, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, + 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2a, 0x2a, 0x2a, 0x2a, 0x29, 0x29, 0x28, 0x28, 0x27, 0x26, 0x26, 0x25, 0x24, 0x23, 0x23, 0x22, + 0x22, 0x22, 0x21, 0x21, 0x20, 0x20, 0x1f, 0x1f, 0x1e, 0x1d, 0x1c, 0x1c, 0x1b, 0x1a, 0x1a, 0x19, 0x19, 0x18, 0x17, 0x17, 0x16, 0x15, + 0x14, 0x13, 0x12, 0x11, 0x10, 0x0f, 0x0e, 0x0d, 0x0c, 0x0c, 0x0b, 0x0a, 0x09, 0x08, 0x07, 0x06, 0x05, 0x05, 0x03, 0x02, 0x01, 0x00, + 0xff, 0xfe, 0xfd, 0xfc, 0xfc, 0xfb, 0xfa, 0xfa, 0xf9, 0xf8, 0xf7, 0xf5, 0xf4, 0xf3, 0xf2, 0xf1, 0xef, 0xee, 0xed, 0xec, 0xeb, 0xea, + 0xe9, 0xe8, 0xe6, 0xe5, 0xe5, 0xe4, 0xe3, 0xe2, 0xe1, 0xe0, 0xe0, 0xdf, 0xde, 0xde, 0xdd, 0xdd, 0xdc, 0xdc, 0xdb, 0xda, 0xda, 0xd9, + 0xd8, 0xd8, 0xd7, 0xd6, 0xd5, 0xd4, 0xd3, 0xd2, 0xd2, 0xd1, 0xd0, 0xd0, 0xcf, 0xce, 0xce, 0xce, 0xcd, 0xcd, 0xcd, 0xcc, 0xcd, 0xcd, + 0xcd, 0xcd, 0xcd, 0xce, 0xce, 0xce, 0xcf, 0xcf, 0xcf, 0xcf, 0xcf, 0xcf, 0xce, 0xcf, 0xce, 0xce, 0xce, 0xce, 0xce, 0xce, 0xce, 0xce, + 0xce, 0xce, 0xce, 0xce, 0xcf, 0xcf, 0xcf, 0xd0, 0xd1, 0xd2, 0xd2, 0xd3, 0xd4, 0xd4, 0xd5, 0xd6, 0xd6, 0xd7, 0xd7, 0xd8, 0xd8, 0xd9, + 0xd9, 0xda, 0xdb, 0xdb, 0xdc, 0xdd, 0xdd, 0xde, 0xdf, 0xe0, 0xe0, 0xe1, 0xe2, 0xe3, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, + 0xeb, 0xec, 0xed, 0xee, 0xf0, 0xf1, 0xf2, 0xf3, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfc, 0xfd, 0xfe, 0xff, 0x00, 0x01, 0x02, 0x03, + 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x11, 0x12, 0x13, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, + 0x19, 0x1a, 0x1b, 0x1c, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x25, 0x26, 0x26, 0x27, 0x27, 0x28, 0x29, 0x29, 0x2a, 0x2b, + 0x2b, 0x2c, 0x2c, 0x2d, 0x2d, 0x2e, 0x2e, 0x2e, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2f, 0x2f, 0x2f, + 0x30, 0x30, 0x30, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x30, 0x30, 0x30, 0x2f, 0x2f, 0x2e, 0x2e, 0x2d, 0x2d, + 0x2c, 0x2c, 0x2c, 0x2b, 0x2b, 0x2a, 0x2a, 0x29, 0x29, 0x29, 0x28, 0x28, 0x27, 0x27, 0x26, 0x26, 0x26, 0x25, 0x24, 0x24, 0x24, 0x23, + 0x22, 0x22, 0x21, 0x20, 0x1f, 0x1e, 0x1d, 0x1c, 0x1b, 0x1a, 0x19, 0x18, 0x17, 0x16, 0x15, 0x14, 0x13, 0x12, 0x12, 0x11, 0x10, 0x10, + 0x0f, 0x0e, 0x0d, 0x0c, 0x0c, 0x0b, 0x0a, 0x09, 0x08, 0x07, 0x06, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0xff, 0xfe, 0xfd, 0xfb, + 0xfa, 0xf9, 0xf8, 0xf7, 0xf6, 0xf4, 0xf3, 0xf2, 0xf1, 0xf0, 0xef, 0xee, 0xee, 0xed, 0xec, 0xeb, 0xea, 0xe9, 0xe8, 0xe7, 0xe6, 0xe5, + 0xe4, 0xe3, 0xe3, 0xe2, 0xe1, 0xe0, 0xdf, 0xde, 0xde, 0xdd, 0xdc, 0xdb, 0xdb, 0xda, 0xda, 0xd9, 0xd9, 0xd8, 0xd8, 0xd8, 0xd8, 0xd8, + 0xd8, 0xd7, 0xd7, 0xd7, 0xd7, 0xd7, 0xd7, 0xd7, 0xd6, 0xd6, 0xd6, 0xd5, 0xd5, 0xd5, 0xd5, 0xd5, 0xd5, 0xd5, 0xd5, 0xd5, 0xd5, 0xd5, + 0xd5, 0xd5, 0xd5, 0xd5, 0xd6, 0xd6, 0xd6, 0xd6, 0xd6, 0xd7, 0xd7, 0xd7, 0xd8, 0xd8, 0xd9, 0xd9, 0xda, 0xda, 0xda, 0xda, 0xdb, 0xdb, + 0xdb, 0xdc, 0xdc, 0xdc, 0xdd, 0xdd, 0xde, 0xde, 0xdf, 0xdf, 0xe0, 0xe0, 0xe1, 0xe2, 0xe2, 0xe3, 0xe3, 0xe4, 0xe4, 0xe5, 0xe6, 0xe6, + 0xe7, 0xe8, 0xe8, 0xe9, 0xea, 0xea, 0xeb, 0xec, 0xec, 0xed, 0xed, 0xee, 0xef, 0xef, 0xf0, 0xf0, 0xf1, 0xf1, 0xf2, 0xf2, 0xf3, 0xf4, + 0xf4, 0xf5, 0xf6, 0xf7, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfb, 0xfc, 0xfd, 0xfd, 0xfe, 0xff, 0x00, 0x00, 0x01, 0x02, 0x02, 0x03, 0x04, + 0x04, 0x05, 0x06, 0x06, 0x07, 0x08, 0x09, 0x09, 0x0a, 0x0a, 0x0b, 0x0c, 0x0d, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x13, 0x14, + 0x15, 0x16, 0x16, 0x17, 0x17, 0x18, 0x18, 0x19, 0x19, 0x19, 0x19, 0x1a, 0x1a, 0x1a, 0x1a, 0x1b, 0x1b, 0x1b, 0x1c, 0x1c, 0x1d, 0x1d, + 0x1e, 0x1e, 0x1f, 0x20, 0x20, 0x20, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x20, 0x20, 0x20, 0x20, 0x20, 0x1f, 0x1f, 0x1f, + 0x1f, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1d, 0x1d, 0x1d, 0x1d, 0x1c, 0x1c, 0x1c, 0x1b, 0x1b, 0x1a, 0x1a, 0x1a, 0x19, 0x19, 0x19, + 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x17, 0x17, 0x16, 0x16, 0x15, 0x15, 0x14, 0x14, 0x13, 0x13, 0x12, 0x12, 0x12, 0x12, 0x11, 0x11, + 0x11, 0x11, 0x11, 0x10, 0x10, 0x10, 0x10, 0x0f, 0x0f, 0x0f, 0x0f, 0x0e, 0x0e, 0x0e, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, + 0x0d, 0x0c, 0x0c, 0x0c, 0x0c, 0x0b, 0x0b, 0x0b, 0x0b, 0x0a, 0x0a, 0x0a, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x08, 0x08, 0x08, 0x07, 0x07, + 0x06, 0x06, 0x05, 0x05, 0x04, 0x03, 0x03, 0x02, 0x02, 0x01, 0x01, 0x01, 0x00, 0x00, 0xff, 0xff, 0xff, 0xfe, 0xfe, 0xfd, 0xfc, 0xfc, + 0xfb, 0xfb, 0xfb, 0xfa, 0xfa, 0xf9, 0xf9, 0xf8, 0xf7, 0xf7, 0xf6, 0xf5, 0xf5, 0xf4, 0xf4, 0xf3, 0xf3, 0xf3, 0xf2, 0xf2, 0xf1, 0xf1, + 0xf1, 0xf0, 0xf0, 0xef, 0xef, 0xee, 0xee, 0xed, 0xed, 0xec, 0xec, 0xeb, 0xeb, 0xea, 0xea, 0xea, 0xe9, 0xe8, 0xe8, 0xe7, 0xe7, 0xe6, + 0xe6, 0xe5, 0xe5, 0xe5, 0xe5, 0xe5, 0xe4, 0xe4, 0xe4, 0xe4, 0xe4, 0xe4, 0xe4, 0xe4, 0xe4, 0xe4, 0xe4, 0xe4, 0xe4, 0xe3, 0xe3, 0xe3, + 0xe3, 0xe4, 0xe4, 0xe4, 0xe4, 0xe4, 0xe4, 0xe4, 0xe4, 0xe4, 0xe4, 0xe4, 0xe4, 0xe4, 0xe4, 0xe4, 0xe4, 0xe4, 0xe4, 0xe4, 0xe5, 0xe5, + 0xe5, 0xe6, 0xe6, 0xe6, 0xe7, 0xe7, 0xe7, 0xe7, 0xe8, 0xe8, 0xe8, 0xe9, 0xe9, 0xe9, 0xe9, 0xea, 0xea, 0xea, 0xea, 0xea, 0xea, 0xea, + 0xea, 0xea, 0xeb, 0xeb, 0xeb, 0xeb, 0xec, 0xec, 0xed, 0xed, 0xee, 0xef, 0xef, 0xf0, 0xf1, 0xf1, 0xf2, 0xf3, 0xf3, 0xf3, 0xf4, 0xf4, + 0xf4, 0xf5, 0xf5, 0xf6, 0xf6, 0xf7, 0xf7, 0xf7, 0xf8, 0xf8, 0xf9, 0xfa, 0xfa, 0xfb, 0xfc, 0xfc, 0xfd, 0xfe, 0xff, 0xff, 0x00, 0x01, + 0x02, 0x02, 0x03, 0x03, 0x04, 0x04, 0x05, 0x05, 0x06, 0x06, 0x06, 0x07, 0x07, 0x08, 0x08, 0x09, 0x09, 0x0a, 0x0b, 0x0b, 0x0c, 0x0c, + 0x0d, 0x0d, 0x0e, 0x0e, 0x0e, 0x0f, 0x0f, 0x10, 0x10, 0x10, 0x11, 0x11, 0x12, 0x12, 0x13, 0x13, 0x14, 0x14, 0x15, 0x15, 0x15, 0x15, + 0x15, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x17, 0x17, 0x17, 0x17, 0x18, 0x18, 0x18, 0x19, 0x19, + 0x19, 0x19, 0x19, 0x1a, 0x1a, 0x1a, 0x19, 0x19, 0x19, 0x19, 0x19, 0x18, 0x18, 0x18, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, + 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x18, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x16, 0x16, 0x16, 0x15, + 0x15, 0x15, 0x14, 0x14, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x12, 0x13, 0x12, 0x12, 0x12, 0x11, 0x11, 0x11, 0x11, 0x11, 0x10, + 0x10, 0x10, 0x0f, 0x0f, 0x0f, 0x0e, 0x0e, 0x0d, 0x0d, 0x0c, 0x0c, 0x0b, 0x0a, 0x0a, 0x09, 0x09, 0x08, 0x08, 0x08, 0x07, 0x07, 0x07, + 0x06, 0x06, 0x06, 0x05, 0x05, 0x05, 0x05, 0x04, 0x04, 0x04, 0x03, 0x03, 0x02, 0x02, 0x01, 0x01, 0x00, 0xff, 0xff, 0xfe, 0xfd, 0xfd, + 0xfc, 0xfb, 0xfa, 0xfa, 0xf9, 0xf9, 0xf8, 0xf7, 0xf7, 0xf6, 0xf5, 0xf5, 0xf4, 0xf4, 0xf3, 0xf3, 0xf3, 0xf2, 0xf2, 0xf2, 0xf1, 0xf1, + 0xf1, 0xf0, 0xf0, 0xf0, 0xef, 0xef, 0xef, 0xee, 0xee, 0xed, 0xed, 0xed, 0xec, 0xec, 0xec, 0xec, 0xec, 0xeb, 0xeb, 0xeb, 0xeb, 0xeb, + 0xeb, 0xea, 0xea, 0xea, 0xea, 0xe9, 0xe9, 0xe9, 0xe9, 0xe8, 0xe8, 0xe8, 0xe8, 0xe8, 0xe7, 0xe7, 0xe7, 0xe7, 0xe6, 0xe6, 0xe6, 0xe5, + 0xe5, 0xe5, 0xe5, 0xe5, 0xe5, 0xe5, 0xe5, 0xe5, 0xe4, 0xe4, 0xe4, 0xe4, 0xe4, 0xe4, 0xe4, 0xe4, 0xe4, 0xe4, 0xe4, 0xe4, 0xe4, 0xe4, + 0xe4, 0xe4, 0xe4, 0xe5, 0xe5, 0xe5, 0xe5, 0xe5, 0xe5, 0xe5, 0xe6, 0xe6, 0xe6, 0xe6, 0xe6, 0xe6, 0xe7, 0xe7, 0xe8, 0xe8, 0xe8, 0xe8, + 0xe9, 0xe9, 0xea, 0xea, 0xea, 0xeb, 0xeb, 0xec, 0xec, 0xec, 0xed, 0xed, 0xed, 0xee, 0xee, 0xef, 0xef, 0xf0, 0xf0, 0xf0, 0xf1, 0xf1, + 0xf2, 0xf2, 0xf2, 0xf3, 0xf3, 0xf4, 0xf4, 0xf5, 0xf6, 0xf6, 0xf7, 0xf8, 0xf8, 0xf9, 0xfa, 0xfb, 0xfb, 0xfc, 0xfd, 0xfd, 0xfe, 0xfe, + 0xff, 0xff, 0x00, 0x00, 0x01, 0x01, 0x02, 0x02, 0x03, 0x03, 0x04, 0x05, 0x05, 0x06, 0x06, 0x07, 0x07, 0x07, 0x08, 0x08, 0x08, 0x09, + 0x09, 0x09, 0x0a, 0x0a, 0x0a, 0x0b, 0x0b, 0x0b, 0x0c, 0x0c, 0x0c, 0x0d, 0x0d, 0x0e, 0x0e, 0x0e, 0x0f, 0x0f, 0x10, 0x10, 0x10, 0x11, + 0x11, 0x11, 0x12, 0x12, 0x12, 0x12, 0x12, 0x13, 0x13, 0x13, 0x13, 0x13, 0x14, 0x14, 0x14, 0x15, 0x15, 0x15, 0x15, 0x16, 0x16, 0x16, + 0x16, 0x17, 0x17, 0x17, 0x18, 0x18, 0x18, 0x18, 0x19, 0x19, 0x19, 0x1a, 0x1a, 0x1a, 0x1a, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, + 0x1b, 0x1b, 0x1b, 0x1b, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1d, 0x1d, 0x1d, 0x1d, 0x1e, 0x1e, 0x1e, 0x1e, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, + 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1d, 0x1d, 0x1d, 0x1c, + 0x1c, 0x1b, 0x1b, 0x1a, 0x1a, 0x1a, 0x19, 0x19, 0x18, 0x18, 0x17, 0x17, 0x17, 0x16, 0x16, 0x15, 0x15, 0x14, 0x14, 0x13, 0x12, 0x12, + 0x11, 0x10, 0x0f, 0x0f, 0x0e, 0x0d, 0x0c, 0x0b, 0x0a, 0x09, 0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0xff, 0xfe, 0xfe, + 0xfd, 0xfc, 0xfb, 0xfa, 0xf9, 0xf9, 0xf8, 0xf7, 0xf6, 0xf5, 0xf4, 0xf4, 0xf3, 0xf2, 0xf1, 0xf1, 0xf0, 0xef, 0xef, 0xee, 0xed, 0xec, + 0xeb, 0xeb, 0xea, 0xe9, 0xe8, 0xe8, 0xe7, 0xe6, 0xe5, 0xe4, 0xe4, 0xe3, 0xe2, 0xe1, 0xe1, 0xe0, 0xdf, 0xdf, 0xde, 0xdd, 0xdd, 0xdc, + 0xdc, 0xdb, 0xdb, 0xdb, 0xda, 0xda, 0xda, 0xd9, 0xd9, 0xd9, 0xd9, 0xd8, 0xd8, 0xd8, 0xd8, 0xd8, 0xd7, 0xd7, 0xd7, 0xd7, 0xd7, 0xd7, + 0xd7, 0xd7, 0xd7, 0xd7, 0xd7, 0xd7, 0xd7, 0xd7, 0xd7, 0xd7, 0xd7, 0xd8, 0xd8, 0xd8, 0xd9, 0xd9, 0xd9, 0xd9, 0xda, 0xda, 0xda, 0xda, + 0xda, 0xdb, 0xdb, 0xdb, 0xdb, 0xdb, 0xdc, 0xdc, 0xdc, 0xdc, 0xdd, 0xdd, 0xde, 0xde, 0xde, 0xdf, 0xdf, 0xe0, 0xe0, 0xe1, 0xe1, 0xe2, + 0xe3, 0xe3, 0xe4, 0xe4, 0xe5, 0xe6, 0xe6, 0xe7, 0xe8, 0xe8, 0xe9, 0xea, 0xea, 0xeb, 0xec, 0xec, 0xed, 0xee, 0xee, 0xef, 0xf0, 0xf0, + 0xf1, 0xf2, 0xf2, 0xf3, 0xf4, 0xf4, 0xf5, 0xf6, 0xf7, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfb, 0xfc, 0xfd, 0xfe, 0xff, 0xff, 0x00, 0x01, + 0x02, 0x02, 0x03, 0x04, 0x04, 0x05, 0x06, 0x07, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0b, 0x0c, 0x0d, 0x0e, 0x0e, 0x0f, 0x10, 0x11, 0x12, + 0x12, 0x13, 0x14, 0x15, 0x16, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1a, 0x1b, 0x1c, 0x1d, 0x1d, 0x1e, 0x1e, 0x1f, 0x1f, 0x20, 0x20, 0x21, + 0x21, 0x22, 0x23, 0x23, 0x24, 0x24, 0x25, 0x26, 0x26, 0x27, 0x27, 0x28, 0x28, 0x29, 0x29, 0x29, 0x2a, 0x2a, 0x2a, 0x2a, 0x2b, 0x2b, + 0x2b, 0x2b, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, + 0x2b, 0x2b, 0x2b, 0x2a, 0x2a, 0x2a, 0x29, 0x29, 0x29, 0x28, 0x28, 0x28, 0x27, 0x27, 0x26, 0x26, 0x25, 0x25, 0x24, 0x24, 0x23, 0x23, + 0x22, 0x22, 0x21, 0x20, 0x20, 0x1f, 0x1e, 0x1e, 0x1d, 0x1c, 0x1b, 0x1a, 0x1a, 0x19, 0x18, 0x17, 0x16, 0x15, 0x14, 0x13, 0x12, 0x11, + 0x10, 0x0f, 0x0e, 0x0d, 0x0c, 0x0b, 0x0b, 0x0a, 0x09, 0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01, 0x01, 0x00, 0xff, 0xfe, 0xfd, + 0xfc, 0xfb, 0xfa, 0xf9, 0xf8, 0xf7, 0xf6, 0xf5, 0xf4, 0xf3, 0xf2, 0xf2, 0xf1, 0xf0, 0xef, 0xef, 0xee, 0xee, 0xed, 0xec, 0xeb, 0xeb, + 0xea, 0xe9, 0xe8, 0xe8, 0xe7, 0xe6, 0xe6, 0xe5, 0xe4, 0xe4, 0xe3, 0xe2, 0xe2, 0xe1, 0xe1, 0xe0, 0xdf, 0xdf, 0xde, 0xde, 0xde, 0xdd, + 0xdd, 0xdc, 0xdc, 0xdb, 0xdb, 0xdb, 0xda, 0xda, 0xda, 0xd9, 0xd9, 0xd9, 0xd9, 0xd9, 0xd8, 0xd8, 0xd8, 0xd8, 0xd8, 0xd8, 0xd7, 0xd7, + 0xd7, 0xd7, 0xd7, 0xd6, 0xd6, 0xd6, 0xd6, 0xd6, 0xd6, 0xd6, 0xd5, 0xd5, 0xd5, 0xd5, 0xd5, 0xd5, 0xd5, 0xd5, 0xd5, 0xd5, 0xd6, 0xd6, + 0xd6, 0xd6, 0xd6, 0xd6, 0xd6, 0xd7, 0xd7, 0xd7, 0xd7, 0xd7, 0xd8, 0xd8, 0xd8, 0xd9, 0xd9, 0xd9, 0xda, 0xda, 0xda, 0xdb, 0xdb, 0xdc, + 0xdc, 0xdd, 0xdd, 0xde, 0xde, 0xdf, 0xe0, 0xe0, 0xe1, 0xe1, 0xe2, 0xe3, 0xe3, 0xe4, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe8, 0xe9, 0xea, + 0xeb, 0xec, 0xed, 0xed, 0xee, 0xef, 0xf0, 0xf1, 0xf2, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, + 0xfe, 0xff, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0e, 0x0f, 0x10, 0x11, 0x12, + 0x13, 0x13, 0x14, 0x15, 0x16, 0x17, 0x17, 0x18, 0x19, 0x1a, 0x1a, 0x1b, 0x1c, 0x1d, 0x1d, 0x1e, 0x1e, 0x1f, 0x20, 0x20, 0x21, 0x21, + 0x22, 0x22, 0x23, 0x23, 0x24, 0x24, 0x25, 0x25, 0x26, 0x26, 0x27, 0x27, 0x28, 0x28, 0x28, 0x29, 0x29, 0x29, 0x29, 0x2a, 0x2a, 0x2a, + 0x2a, 0x2a, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2a, 0x2a, 0x2a, 0x2a, + 0x2a, 0x2a, 0x29, 0x29, 0x29, 0x28, 0x28, 0x28, 0x27, 0x27, 0x26, 0x26, 0x25, 0x25, 0x25, 0x24, 0x24, 0x23, 0x23, 0x23, 0x22, 0x22, + 0x21, 0x21, 0x20, 0x20, 0x1f, 0x1e, 0x1e, 0x1d, 0x1d, 0x1c, 0x1b, 0x1a, 0x1a, 0x19, 0x19, 0x18, 0x17, 0x17, 0x16, 0x15, 0x15, 0x14, + 0x13, 0x13, 0x12, 0x12, 0x11, 0x10, 0x10, 0x0f, 0x0f, 0x0e, 0x0d, 0x0d, 0x0c, 0x0b, 0x0b, 0x0a, 0x09, 0x09, 0x08, 0x07, 0x06, 0x06, + 0x05, 0x04, 0x04, 0x03, 0x02, 0x01, 0x00, 0x00, 0xff, 0xfe, 0xfd, 0xfc, 0xfc, 0xfb, 0xfa, 0xf9, 0xf8, 0xf7, 0xf7, 0xf6, 0xf5, 0xf4, + 0xf3, 0xf2, 0xf1, 0xf0, 0xf0, 0xef, 0xee, 0xed, 0xec, 0xeb, 0xea, 0xe9, 0xe9, 0xe8, 0xe7, 0xe6, 0xe5, 0xe4, 0xe4, 0xe3, 0xe2, 0xe1, + 0xe1, 0xe0, 0xdf, 0xdf, 0xde, 0xde, 0xdd, 0xdd, 0xdd, 0xdc, 0xdc, 0xdb, 0xdb, 0xda, 0xda, 0xd9, 0xd9, 0xd8, 0xd8, 0xd7, 0xd7, 0xd7, + 0xd6, 0xd6, 0xd6, 0xd5, 0xd5, 0xd5, 0xd5, 0xd4, 0xd4, 0xd4, 0xd4, 0xd4, 0xd3, 0xd3, 0xd3, 0xd3, 0xd3, 0xd3, 0xd2, 0xd2, 0xd2, 0xd2, + 0xd2, 0xd2, 0xd2, 0xd2, 0xd2, 0xd2, 0xd2, 0xd3, 0xd3, 0xd3, 0xd4, 0xd4, 0xd4, 0xd5, 0xd5, 0xd6, 0xd6, 0xd7, 0xd7, 0xd8, 0xd9, 0xd9, + 0xda, 0xda, 0xdb, 0xdb, 0xdc, 0xdc, 0xdd, 0xdd, 0xde, 0xde, 0xdf, 0xe0, 0xe0, 0xe1, 0xe1, 0xe2, 0xe2, 0xe3, 0xe4, 0xe5, 0xe5, 0xe6, + 0xe7, 0xe8, 0xe9, 0xea, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, + 0xfc, 0xfd, 0xfe, 0xff, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, + 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x16, 0x17, 0x18, 0x19, 0x19, 0x1a, 0x1a, 0x1b, 0x1c, 0x1c, 0x1d, 0x1d, 0x1e, 0x1e, 0x1f, + 0x1f, 0x20, 0x20, 0x20, 0x21, 0x21, 0x22, 0x22, 0x23, 0x23, 0x24, 0x24, 0x24, 0x25, 0x25, 0x25, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, + 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, + 0x27, 0x27, 0x27, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x25, 0x25, 0x25, 0x24, 0x24, 0x24, 0x23, 0x23, 0x22, 0x22, 0x21, 0x21, 0x21, + 0x20, 0x1f, 0x1f, 0x1e, 0x1e, 0x1d, 0x1c, 0x1c, 0x1b, 0x1b, 0x1a, 0x19, 0x19, 0x18, 0x18, 0x17, 0x17, 0x16, 0x15, 0x15, 0x14, 0x13, + 0x13, 0x12, 0x11, 0x11, 0x10, 0x0f, 0x0f, 0x0e, 0x0d, 0x0c, 0x0c, 0x0b, 0x0a, 0x09, 0x09, 0x08, 0x07, 0x06, 0x05, 0x04, 0x04, 0x03, + 0x02, 0x01, 0x00, 0x00, 0xff, 0xfe, 0xfd, 0xfd, 0xfc, 0xfb, 0xfb, 0xfa, 0xf9, 0xf9, 0xf8, 0xf7, 0xf7, 0xf6, 0xf6, 0xf5, 0xf4, 0xf4, + 0xf3, 0xf3, 0xf2, 0xf1, 0xf1, 0xf0, 0xf0, 0xef, 0xee, 0xee, 0xed, 0xed, 0xec, 0xec, 0xeb, 0xea, 0xea, 0xe9, 0xe9, 0xe9, 0xe8, 0xe8, + 0xe7, 0xe7, 0xe6, 0xe6, 0xe6, 0xe5, 0xe5, 0xe5, 0xe5, 0xe4, 0xe4, 0xe4, 0xe4, 0xe4, 0xe4, 0xe4, 0xe4, 0xe3, 0xe3, 0xe3, 0xe3, 0xe3, + 0xe3, 0xe2, 0xe2, 0xe2, 0xe2, 0xe1, 0xe1, 0xe1, 0xe1, 0xe1, 0xe1, 0xe0, 0xe0, 0xe0, 0xe0, 0xe0, 0xe0, 0xe0, 0xe0, 0xe0, 0xe0, 0xe1, + 0xe1, 0xe1, 0xe1, 0xe1, 0xe1, 0xe1, 0xe1, 0xe1, 0xe1, 0xe2, 0xe2, 0xe2, 0xe2, 0xe2, 0xe2, 0xe2, 0xe2, 0xe3, 0xe3, 0xe3, 0xe3, 0xe3, + 0xe4, 0xe4, 0xe4, 0xe5, 0xe5, 0xe5, 0xe5, 0xe6, 0xe6, 0xe6, 0xe7, 0xe7, 0xe8, 0xe8, 0xe8, 0xe9, 0xe9, 0xea, 0xea, 0xeb, 0xeb, 0xeb, + 0xec, 0xec, 0xed, 0xed, 0xee, 0xee, 0xef, 0xf0, 0xf0, 0xf1, 0xf1, 0xf2, 0xf3, 0xf3, 0xf4, 0xf4, 0xf5, 0xf6, 0xf6, 0xf7, 0xf7, 0xf8, + 0xf8, 0xf9, 0xf9, 0xfa, 0xfa, 0xfb, 0xfc, 0xfc, 0xfd, 0xfd, 0xfe, 0xfe, 0xff, 0xff, 0x00, 0x00, 0x01, 0x02, 0x02, 0x03, 0x03, 0x04, + 0x04, 0x05, 0x05, 0x06, 0x07, 0x07, 0x08, 0x08, 0x09, 0x09, 0x0a, 0x0a, 0x0a, 0x0b, 0x0b, 0x0c, 0x0c, 0x0c, 0x0d, 0x0d, 0x0e, 0x0e, + 0x0e, 0x0f, 0x0f, 0x0f, 0x10, 0x10, 0x10, 0x11, 0x11, 0x11, 0x12, 0x12, 0x12, 0x13, 0x13, 0x13, 0x14, 0x14, 0x14, 0x15, 0x15, 0x15, + 0x16, 0x16, 0x16, 0x16, 0x17, 0x17, 0x17, 0x17, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, + 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, + 0x18, 0x18, 0x18, 0x18, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x16, 0x16, 0x16, 0x15, 0x15, 0x15, 0x15, 0x14, 0x14, 0x14, 0x13, 0x13, + 0x13, 0x13, 0x12, 0x12, 0x12, 0x11, 0x11, 0x11, 0x11, 0x10, 0x10, 0x10, 0x10, 0x0f, 0x0f, 0x0f, 0x0f, 0x0e, 0x0e, 0x0e, 0x0d, 0x0d, + 0x0d, 0x0c, 0x0c, 0x0c, 0x0b, 0x0b, 0x0b, 0x0a, 0x0a, 0x09, 0x09, 0x08, 0x08, 0x08, 0x07, 0x07, 0x06, 0x06, 0x05, 0x05, 0x04, 0x04, + 0x04, 0x03, 0x03, 0x03, 0x02, 0x02, 0x02, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0xff, 0xff, 0xfe, 0xfe, 0xfe, 0xfd, 0xfd, 0xfc, 0xfb, + 0xfb, 0xfa, 0xfa, 0xf9, 0xf9, 0xf8, 0xf7, 0xf7, 0xf6, 0xf6, 0xf5, 0xf5, 0xf4, 0xf4, 0xf4, 0xf3, 0xf3, 0xf3, 0xf2, 0xf2, 0xf2, 0xf1, + 0xf1, 0xf1, 0xf1, 0xf0, 0xf0, 0xf0, 0xef, 0xef, 0xee, 0xee, 0xee, 0xed, 0xed, 0xed, 0xec, 0xec, 0xec, 0xeb, 0xeb, 0xeb, 0xea, 0xea, + 0xea, 0xea, 0xe9, 0xe9, 0xe9, 0xe9, 0xe8, 0xe8, 0xe8, 0xe8, 0xe8, 0xe8, 0xe8, 0xe7, 0xe7, 0xe7, 0xe7, 0xe7, 0xe7, 0xe7, 0xe7, 0xe7, + 0xe7, 0xe7, 0xe7, 0xe7, 0xe7, 0xe7, 0xe7, 0xe7, 0xe7, 0xe7, 0xe7, 0xe7, 0xe7, 0xe8, 0xe8, 0xe8, 0xe8, 0xe8, 0xe8, 0xe8, 0xe9, 0xe9, + 0xe9, 0xe9, 0xe9, 0xe9, 0xe9, 0xe9, 0xe9, 0xea, 0xea, 0xea, 0xea, 0xea, 0xeb, 0xeb, 0xeb, 0xeb, 0xec, 0xec, 0xec, 0xec, 0xed, 0xed, + 0xed, 0xee, 0xee, 0xee, 0xef, 0xef, 0xef, 0xf0, 0xf0, 0xf0, 0xf1, 0xf1, 0xf1, 0xf2, 0xf2, 0xf2, 0xf2, 0xf3, 0xf3, 0xf3, 0xf3, 0xf4, + 0xf4, 0xf4, 0xf4, 0xf5, 0xf5, 0xf6, 0xf6, 0xf6, 0xf7, 0xf7, 0xf8, 0xf8, 0xf9, 0xf9, 0xfa, 0xfb, 0xfb, 0xfc, 0xfc, 0xfd, 0xfd, 0xfe, + 0xff, 0xff, 0x00, 0x00, 0x01, 0x01, 0x02, 0x02, 0x02, 0x03, 0x03, 0x04, 0x04, 0x04, 0x05, 0x05, 0x06, 0x06, 0x06, 0x07, 0x07, 0x08, + 0x08, 0x09, 0x09, 0x0a, 0x0a, 0x0b, 0x0b, 0x0c, 0x0c, 0x0d, 0x0d, 0x0e, 0x0e, 0x0f, 0x0f, 0x0f, 0x10, 0x10, 0x11, 0x11, 0x11, 0x12, + 0x12, 0x12, 0x13, 0x13, 0x13, 0x14, 0x14, 0x14, 0x14, 0x15, 0x15, 0x15, 0x15, 0x16, 0x16, 0x16, 0x16, 0x16, 0x17, 0x17, 0x17, 0x17, + 0x17, 0x17, 0x17, 0x17, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, + 0x18, 0x18, 0x18, 0x18, 0x18, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x16, 0x16, 0x16, 0x16, 0x16, 0x15, 0x15, 0x15, 0x15, 0x15, 0x14, + 0x14, 0x14, 0x13, 0x13, 0x13, 0x13, 0x12, 0x12, 0x12, 0x11, 0x11, 0x11, 0x10, 0x10, 0x10, 0x0f, 0x0f, 0x0f, 0x0e, 0x0e, 0x0e, 0x0d, + 0x0d, 0x0d, 0x0c, 0x0c, 0x0c, 0x0b, 0x0b, 0x0a, 0x0a, 0x0a, 0x09, 0x09, 0x09, 0x08, 0x08, 0x07, 0x07, 0x07, 0x06, 0x06, 0x05, 0x05, + 0x04, 0x04, 0x04, 0x03, 0x03, 0x03, 0x02, 0x02, 0x01, 0x01, 0x01, 0x00, 0x00, 0xff, 0xff, 0xff, 0xfe, 0xfe, 0xfd, 0xfd, 0xfd, 0xfc, + 0xfc, 0xfb, 0xfb, 0xfb, 0xfa, 0xfa, 0xf9, 0xf9, 0xf9, 0xf8, 0xf8, 0xf8, 0xf7, 0xf7, 0xf7, 0xf6, 0xf6, 0xf6, 0xf5, 0xf5, 0xf5, 0xf4, + 0xf4, 0xf4, 0xf3, 0xf3, 0xf3, 0xf2, 0xf2, 0xf2, 0xf1, 0xf1, 0xf1, 0xf0, 0xf0, 0xf0, 0xf0, 0xef, 0xef, 0xef, 0xef, 0xef, 0xee, 0xee, + 0xee, 0xee, 0xed, 0xed, 0xed, 0xed, 0xed, 0xec, 0xec, 0xec, 0xec, 0xec, 0xeb, 0xeb, 0xeb, 0xeb, 0xeb, 0xea, 0xea, 0xea, 0xea, 0xea, + 0xea, 0xea, 0xe9, 0xe9, 0xe9, 0xe9, 0xe9, 0xe9, 0xe9, 0xe9, 0xe9, 0xe9, 0xe9, 0xe9, 0xe9, 0xe9, 0xe9, 0xe9, 0xe9, 0xe9, 0xe9, 0xe9, + 0xe9, 0xe9, 0xe9, 0xe9, 0xe9, 0xe9, 0xe9, 0xe9, 0xe9, 0xe9, 0xe9, 0xe9, 0xe9, 0xe9, 0xea, 0xea, 0xea, 0xea, 0xea, 0xeb, 0xeb, 0xeb, + 0xeb, 0xec, 0xec, 0xec, 0xec, 0xed, 0xed, 0xed, 0xed, 0xee, 0xee, 0xee, 0xee, 0xee, 0xef, 0xef, 0xef, 0xef, 0xf0, 0xf0, 0xf0, 0xf1, + 0xf1, 0xf2, 0xf2, 0xf2, 0xf3, 0xf3, 0xf4, 0xf4, 0xf5, 0xf5, 0xf6, 0xf6, 0xf6, 0xf7, 0xf7, 0xf8, 0xf8, 0xf9, 0xf9, 0xf9, 0xfa, 0xfa, + 0xfb, 0xfb, 0xfc, 0xfc, 0xfc, 0xfd, 0xfd, 0xfe, 0xfe, 0xff, 0xff, 0x00, 0x00, 0x01, 0x01, 0x02, 0x02, 0x03, 0x03, 0x04, 0x04, 0x05, + 0x05, 0x06, 0x06, 0x07, 0x07, 0x08, 0x08, 0x08, 0x09, 0x09, 0x0a, 0x0a, 0x0a, 0x0b, 0x0b, 0x0c, 0x0c, 0x0c, 0x0d, 0x0d, 0x0e, 0x0e, + 0x0f, 0x0f, 0x10, 0x10, 0x11, 0x11, 0x11, 0x12, 0x12, 0x13, 0x13, 0x14, 0x14, 0x14, 0x15, 0x15, 0x16, 0x16, 0x16, 0x17, 0x17, 0x17, + 0x17, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x1a, 0x1a, 0x1a, + 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x18, 0x18, 0x18, 0x18, 0x18, + 0x18, 0x18, 0x18, 0x18, 0x18, 0x17, 0x17, 0x17, 0x17, 0x17, 0x16, 0x16, 0x16, 0x16, 0x16, 0x15, 0x15, 0x15, 0x15, 0x15, 0x14, 0x14, + 0x14, 0x14, 0x13, 0x13, 0x13, 0x13, 0x12, 0x12, 0x12, 0x11, 0x11, 0x11, 0x11, 0x10, 0x10, 0x10, 0x0f, 0x0f, 0x0e, 0x0e, 0x0e, 0x0d, + 0x0d, 0x0c, 0x0c, 0x0b, 0x0b, 0x0a, 0x0a, 0x0a, 0x09, 0x09, 0x08, 0x08, 0x07, 0x07, 0x06, 0x06, 0x05, 0x04, 0x04, 0x03, 0x02, 0x02, + 0x01, 0x01, 0x00, 0xff, 0xfe, 0xfe, 0xfd, 0xfc, 0xfc, 0xfb, 0xfa, 0xfa, 0xf9, 0xf8, 0xf8, 0xf7, 0xf6, 0xf5, 0xf5, 0xf4, 0xf3, 0xf3, + 0xf2, 0xf2, 0xf1, 0xf0, 0xf0, 0xef, 0xef, 0xee, 0xee, 0xed, 0xed, 0xec, 0xec, 0xeb, 0xea, 0xea, 0xe9, 0xe9, 0xe8, 0xe8, 0xe7, 0xe7, + 0xe6, 0xe6, 0xe5, 0xe5, 0xe4, 0xe4, 0xe3, 0xe3, 0xe3, 0xe2, 0xe2, 0xe2, 0xe1, 0xe1, 0xe1, 0xe0, 0xe0, 0xe0, 0xe0, 0xe0, 0xe0, 0xdf, + 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, + 0xdf, 0xdf, 0xdf, 0xdf, 0xe0, 0xe0, 0xe0, 0xe0, 0xe0, 0xe1, 0xe1, 0xe1, 0xe1, 0xe2, 0xe2, 0xe2, 0xe3, 0xe3, 0xe3, 0xe4, 0xe4, 0xe5, + 0xe5, 0xe5, 0xe6, 0xe6, 0xe6, 0xe7, 0xe7, 0xe7, 0xe8, 0xe8, 0xe9, 0xe9, 0xea, 0xea, 0xeb, 0xeb, 0xec, 0xed, 0xed, 0xee, 0xee, 0xef, + 0xef, 0xf0, 0xf1, 0xf1, 0xf2, 0xf3, 0xf3, 0xf4, 0xf4, 0xf5, 0xf6, 0xf6, 0xf7, 0xf8, 0xf8, 0xf9, 0xf9, 0xfa, 0xfb, 0xfb, 0xfc, 0xfd, + 0xfe, 0xfe, 0xff, 0x00, 0x01, 0x01, 0x02, 0x03, 0x03, 0x04, 0x05, 0x06, 0x06, 0x07, 0x08, 0x08, 0x09, 0x0a, 0x0a, 0x0b, 0x0b, 0x0c, + 0x0d, 0x0d, 0x0e, 0x0e, 0x0f, 0x10, 0x10, 0x11, 0x12, 0x12, 0x13, 0x13, 0x14, 0x15, 0x15, 0x16, 0x16, 0x17, 0x18, 0x18, 0x19, 0x19, + 0x1a, 0x1a, 0x1a, 0x1b, 0x1b, 0x1c, 0x1c, 0x1c, 0x1d, 0x1d, 0x1e, 0x1e, 0x1e, 0x1e, 0x1f, 0x1f, 0x1f, 0x20, 0x20, 0x20, 0x21, 0x21, + 0x21, 0x21, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x22, 0x22, + 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x21, 0x21, 0x21, 0x21, 0x20, 0x20, 0x20, 0x20, 0x1f, 0x1f, 0x1f, 0x1e, 0x1e, 0x1d, 0x1d, 0x1d, + 0x1c, 0x1c, 0x1b, 0x1b, 0x1a, 0x1a, 0x19, 0x19, 0x18, 0x18, 0x17, 0x17, 0x16, 0x15, 0x15, 0x14, 0x14, 0x13, 0x13, 0x12, 0x12, 0x11, + 0x10, 0x10, 0x0f, 0x0e, 0x0e, 0x0d, 0x0c, 0x0c, 0x0b, 0x0a, 0x0a, 0x09, 0x08, 0x07, 0x07, 0x06, 0x05, 0x05, 0x04, 0x03, 0x03, 0x02, + 0x01, 0x01, 0x00, 0xff, 0xff, 0xfe, 0xfe, 0xfd, 0xfc, 0xfc, 0xfb, 0xfa, 0xfa, 0xf9, 0xf8, 0xf8, 0xf7, 0xf6, 0xf6, 0xf5, 0xf4, 0xf4, + 0xf3, 0xf2, 0xf2, 0xf1, 0xf1, 0xf0, 0xef, 0xef, 0xee, 0xee, 0xed, 0xed, 0xed, 0xec, 0xec, 0xeb, 0xeb, 0xea, 0xea, 0xe9, 0xe9, 0xe8, + 0xe8, 0xe7, 0xe7, 0xe6, 0xe6, 0xe6, 0xe5, 0xe5, 0xe4, 0xe4, 0xe4, 0xe3, 0xe3, 0xe2, 0xe2, 0xe2, 0xe1, 0xe1, 0xe1, 0xe1, 0xe0, 0xe0, + 0xe0, 0xe0, 0xe0, 0xe0, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, + 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xe0, 0xe0, 0xe0, 0xe0, 0xe0, 0xe1, 0xe1, 0xe1, 0xe1, 0xe2, 0xe2, 0xe2, 0xe3, 0xe3, 0xe3, 0xe4, + 0xe4, 0xe4, 0xe5, 0xe5, 0xe5, 0xe6, 0xe6, 0xe7, 0xe7, 0xe7, 0xe8, 0xe8, 0xe8, 0xe9, 0xe9, 0xea, 0xea, 0xeb, 0xeb, 0xec, 0xec, 0xed, + 0xee, 0xee, 0xef, 0xef, 0xf0, 0xf0, 0xf1, 0xf2, 0xf2, 0xf3, 0xf3, 0xf4, 0xf4, 0xf5, 0xf5, 0xf6, 0xf6, 0xf7, 0xf8, 0xf8, 0xf9, 0xfa, + 0xfa, 0xfb, 0xfb, 0xfc, 0xfd, 0xfd, 0xfe, 0xfe, 0xff, 0x00, 0x00, 0x01, 0x01, 0x02, 0x03, 0x03, 0x04, 0x04, 0x05, 0x06, 0x06, 0x07, + 0x08, 0x08, 0x09, 0x09, 0x0a, 0x0b, 0x0b, 0x0c, 0x0c, 0x0d, 0x0d, 0x0e, 0x0e, 0x0f, 0x10, 0x10, 0x11, 0x11, 0x12, 0x12, 0x12, 0x13, + 0x13, 0x14, 0x14, 0x15, 0x15, 0x15, 0x16, 0x16, 0x16, 0x17, 0x17, 0x17, 0x18, 0x18, 0x18, 0x19, 0x19, 0x19, 0x1a, 0x1a, 0x1a, 0x1b, + 0x1b, 0x1b, 0x1b, 0x1c, 0x1c, 0x1c, 0x1c, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, + 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, + 0x1a, 0x1a, 0x1a, 0x1a, 0x19, 0x19, 0x19, 0x19, 0x18, 0x18, 0x18, 0x17, 0x17, 0x17, 0x16, 0x16, 0x16, 0x15, 0x15, 0x14, 0x14, 0x14, + 0x13, 0x13, 0x12, 0x12, 0x12, 0x11, 0x11, 0x10, 0x10, 0x10, 0x0f, 0x0f, 0x0e, 0x0e, 0x0d, 0x0d, 0x0c, 0x0c, 0x0c, 0x0b, 0x0b, 0x0a, + 0x0a, 0x09, 0x09, 0x08, 0x08, 0x07, 0x07, 0x06, 0x06, 0x05, 0x04, 0x04, 0x03, 0x03, 0x02, 0x02, 0x01, 0x00, 0x00, 0xff, 0xff, 0xfe, + 0xfd, 0xfd, 0xfc, 0xfc, 0xfb, 0xfa, 0xfa, 0xf9, 0xf9, 0xf8, 0xf8, 0xf7, 0xf7, 0xf6, 0xf5, 0xf5, 0xf4, 0xf4, 0xf3, 0xf3, 0xf2, 0xf2, + 0xf1, 0xf1, 0xf0, 0xf0, 0xef, 0xef, 0xee, 0xee, 0xed, 0xed, 0xec, 0xec, 0xeb, 0xeb, 0xea, 0xea, 0xe9, 0xe9, 0xe8, 0xe8, 0xe7, 0xe7, + 0xe6, 0xe6, 0xe6, 0xe5, 0xe5, 0xe5, 0xe4, 0xe4, 0xe4, 0xe4, 0xe3, 0xe3, 0xe3, 0xe3, 0xe3, 0xe3, 0xe3, 0xe3, 0xe2, 0xe2, 0xe2, 0xe2, + 0xe2, 0xe2, 0xe2, 0xe2, 0xe2, 0xe2, 0xe2, 0xe2, 0xe2, 0xe2, 0xe2, 0xe2, 0xe2, 0xe2, 0xe2, 0xe2, 0xe2, 0xe2, 0xe2, 0xe3, 0xe3, 0xe3, + 0xe3, 0xe3, 0xe4, 0xe4, 0xe4, 0xe4, 0xe4, 0xe5, 0xe5, 0xe5, 0xe6, 0xe6, 0xe6, 0xe6, 0xe7, 0xe7, 0xe8, 0xe8, 0xe8, 0xe9, 0xe9, 0xe9, + 0xea, 0xea, 0xea, 0xeb, 0xeb, 0xec, 0xec, 0xec, 0xed, 0xed, 0xee, 0xee, 0xef, 0xef, 0xef, 0xf0, 0xf0, 0xf1, 0xf1, 0xf2, 0xf2, 0xf3, + 0xf3, 0xf4, 0xf4, 0xf5, 0xf5, 0xf6, 0xf6, 0xf7, 0xf8, 0xf8, 0xf9, 0xf9, 0xfa, 0xfa, 0xfb, 0xfb, 0xfc, 0xfd, 0xfd, 0xfe, 0xfe, 0xff, + 0x00, 0x00, 0x01, 0x01, 0x02, 0x02, 0x03, 0x04, 0x04, 0x05, 0x05, 0x06, 0x06, 0x07, 0x07, 0x08, 0x08, 0x09, 0x09, 0x0a, 0x0a, 0x0b, + 0x0b, 0x0c, 0x0c, 0x0d, 0x0d, 0x0e, 0x0e, 0x0e, 0x0f, 0x0f, 0x10, 0x10, 0x10, 0x11, 0x11, 0x11, 0x12, 0x12, 0x12, 0x13, 0x13, 0x13, + 0x14, 0x14, 0x14, 0x14, 0x15, 0x15, 0x15, 0x16, 0x16, 0x16, 0x16, 0x16, 0x17, 0x17, 0x17, 0x17, 0x17, 0x18, 0x18, 0x18, 0x18, 0x18, + 0x18, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, + 0x1a, 0x1a, 0x1a, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x18, 0x18, 0x18, 0x18, 0x18, 0x17, 0x17, 0x17, 0x17, 0x17, 0x16, 0x16, + 0x16, 0x16, 0x15, 0x15, 0x15, 0x14, 0x14, 0x14, 0x13, 0x13, 0x12, 0x12, 0x12, 0x11, 0x11, 0x10, 0x10, 0x0f, 0x0f, 0x0f, 0x0e, 0x0e, + 0x0d, 0x0d, 0x0c, 0x0c, 0x0b, 0x0b, 0x0a, 0x0a, 0x09, 0x09, 0x08, 0x08, 0x07, 0x07, 0x07, 0x06, 0x06, 0x05, 0x05, 0x04, 0x04, 0x03, + 0x03, 0x02, 0x02, 0x01, 0x01, 0x00, 0x00, 0xff, 0xff, 0xfe, 0xfe, 0xfe, 0xfd, 0xfd, 0xfc, 0xfc, 0xfb, 0xfb, 0xfa, 0xfa, 0xf9, 0xf9, + 0xf8, 0xf8, 0xf7, 0xf7, 0xf6, 0xf6, 0xf5, 0xf5, 0xf4, 0xf4, 0xf3, 0xf3, 0xf3, 0xf2, 0xf2, 0xf1, 0xf1, 0xf1, 0xf0, 0xf0, 0xf0, 0xef, + 0xef, 0xef, 0xef, 0xee, 0xee, 0xee, 0xed, 0xed, 0xed, 0xed, 0xec, 0xec, 0xec, 0xec, 0xec, 0xec, 0xeb, 0xeb, 0xeb, 0xeb, 0xeb, 0xeb, + 0xeb, 0xeb, 0xea, 0xea, 0xea, 0xea, 0xea, 0xea, 0xea, 0xea, 0xea, 0xea, 0xea, 0xea, 0xea, 0xea, 0xea, 0xea, 0xea, 0xea, 0xea, 0xea, + 0xea, 0xea, 0xea, 0xea, 0xea, 0xea, 0xea, 0xea, 0xea, 0xea, 0xea, 0xea, 0xea, 0xea, 0xea, 0xeb, 0xeb, 0xeb, 0xeb, 0xeb, 0xeb, 0xec, + 0xec, 0xec, 0xec, 0xec, 0xec, 0xed, 0xed, 0xed, 0xed, 0xed, 0xee, 0xee, 0xee, 0xee, 0xef, 0xef, 0xef, 0xef, 0xf0, 0xf0, 0xf0, 0xf0, + 0xf1, 0xf1, 0xf2, 0xf2, 0xf2, 0xf3, 0xf3, 0xf3, 0xf4, 0xf4, 0xf5, 0xf5, 0xf5, 0xf6, 0xf6, 0xf7, 0xf7, 0xf7, 0xf8, 0xf8, 0xf8, 0xf9, + 0xf9, 0xf9, 0xfa, 0xfa, 0xfb, 0xfb, 0xfb, 0xfc, 0xfc, 0xfc, 0xfd, 0xfd, 0xfe, 0xfe, 0xfe, 0xff, 0xff, 0x00, 0x00, 0x01, 0x01, 0x02, + 0x02, 0x02, 0x03, 0x03, 0x04, 0x04, 0x05, 0x05, 0x05, 0x06, 0x06, 0x06, 0x07, 0x07, 0x07, 0x08, 0x08, 0x08, 0x09, 0x09, 0x09, 0x09, + 0x0a, 0x0a, 0x0a, 0x0a, 0x0b, 0x0b, 0x0b, 0x0b, 0x0c, 0x0c, 0x0c, 0x0c, 0x0d, 0x0d, 0x0d, 0x0d, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, + 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, + 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, + 0x0f, 0x0f, 0x0f, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, + 0x0d, 0x0d, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, + 0x0a, 0x0a, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x08, 0x08, 0x08, 0x08, 0x08, 0x07, 0x07, 0x07, 0x07, 0x07, 0x06, 0x06, + 0x06, 0x06, 0x06, 0x06, 0x05, 0x05, 0x05, 0x05, 0x05, 0x04, 0x04, 0x04, 0x04, 0x03, 0x03, 0x03, 0x02, 0x02, 0x02, 0x02, 0x01, 0x01, + 0x01, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xfe, 0xfe, 0xfe, 0xfd, 0xfd, 0xfd, 0xfc, 0xfc, 0xfc, 0xfb, 0xfb, 0xfb, 0xfb, 0xfa, 0xfa, + 0xfa, 0xf9, 0xf9, 0xf8, 0xf8, 0xf8, 0xf7, 0xf7, 0xf7, 0xf6, 0xf6, 0xf6, 0xf5, 0xf5, 0xf5, 0xf4, 0xf4, 0xf4, 0xf3, 0xf3, 0xf3, 0xf3, + 0xf2, 0xf2, 0xf2, 0xf1, 0xf1, 0xf1, 0xf1, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xef, 0xef, 0xef, 0xef, 0xef, 0xee, 0xee, 0xee, 0xee, 0xee, + 0xee, 0xee, 0xee, 0xee, 0xee, 0xee, 0xed, 0xed, 0xed, 0xed, 0xed, 0xed, 0xed, 0xed, 0xed, 0xed, 0xed, 0xed, 0xed, 0xed, 0xed, 0xed, + 0xed, 0xed, 0xed, 0xed, 0xed, 0xed, 0xed, 0xed, 0xed, 0xee, 0xee, 0xee, 0xee, 0xee, 0xee, 0xee, 0xee, 0xee, 0xef, 0xef, 0xef, 0xef, + 0xef, 0xef, 0xef, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf2, 0xf2, 0xf2, 0xf2, 0xf3, 0xf3, 0xf3, 0xf3, 0xf4, + 0xf4, 0xf4, 0xf4, 0xf5, 0xf5, 0xf5, 0xf5, 0xf6, 0xf6, 0xf6, 0xf7, 0xf7, 0xf7, 0xf7, 0xf8, 0xf8, 0xf8, 0xf9, 0xf9, 0xf9, 0xfa, 0xfa, + 0xfa, 0xfb, 0xfb, 0xfc, 0xfc, 0xfc, 0xfd, 0xfd, 0xfd, 0xfe, 0xfe, 0xfe, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x01, 0x01, 0x02, 0x02, + 0x02, 0x02, 0x03, 0x03, 0x04, 0x04, 0x04, 0x04, 0x05, 0x05, 0x05, 0x06, 0x06, 0x06, 0x07, 0x07, 0x07, 0x08, 0x08, 0x08, 0x09, 0x09, + 0x09, 0x0a, 0x0a, 0x0a, 0x0b, 0x0b, 0x0b, 0x0c, 0x0c, 0x0c, 0x0c, 0x0d, 0x0d, 0x0d, 0x0d, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0f, 0x0f, + 0x0f, 0x0f, 0x0f, 0x10, 0x10, 0x10, 0x10, 0x10, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x13, + 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x14, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, + 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x11, 0x11, 0x11, 0x11, 0x11, 0x10, 0x10, 0x10, + 0x10, 0x0f, 0x0f, 0x0f, 0x0f, 0x0e, 0x0e, 0x0e, 0x0e, 0x0d, 0x0d, 0x0d, 0x0c, 0x0c, 0x0c, 0x0b, 0x0b, 0x0b, 0x0a, 0x0a, 0x0a, 0x09, + 0x09, 0x09, 0x08, 0x08, 0x07, 0x07, 0x07, 0x06, 0x06, 0x06, 0x05, 0x05, 0x04, 0x04, 0x04, 0x03, 0x03, 0x02, 0x02, 0x02, 0x01, 0x01, + 0x00, 0x00, 0x00, 0xff, 0xff, 0xfe, 0xfe, 0xfe, 0xfd, 0xfd, 0xfd, 0xfc, 0xfc, 0xfb, 0xfb, 0xfb, 0xfa, 0xfa, 0xfa, 0xf9, 0xf9, 0xf8, + 0xf8, 0xf8, 0xf8, 0xf7, 0xf7, 0xf7, 0xf6, 0xf6, 0xf6, 0xf5, 0xf5, 0xf5, 0xf4, 0xf4, 0xf4, 0xf4, 0xf3, 0xf3, 0xf3, 0xf3, 0xf2, 0xf2, + 0xf2, 0xf1, 0xf1, 0xf1, 0xf1, 0xf1, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xef, 0xef, 0xef, 0xef, 0xef, 0xee, 0xee, 0xee, 0xee, 0xee, 0xee, + 0xed, 0xed, 0xed, 0xed, 0xed, 0xed, 0xed, 0xed, 0xec, 0xec, 0xec, 0xec, 0xec, 0xec, 0xec, 0xec, 0xec, 0xec, 0xec, 0xec, 0xec, 0xec, + 0xec, 0xec, 0xec, 0xec, 0xec, 0xec, 0xec, 0xec, 0xec, 0xec, 0xec, 0xec, 0xec, 0xec, 0xec, 0xec, 0xec, 0xec, 0xec, 0xed, 0xed, 0xed, + 0xed, 0xed, 0xed, 0xed, 0xed, 0xee, 0xee, 0xee, 0xee, 0xee, 0xee, 0xef, 0xef, 0xef, 0xef, 0xef, 0xf0, 0xf0, 0xf0, 0xf0, 0xf1, 0xf1, + 0xf1, 0xf2, 0xf2, 0xf2, 0xf2, 0xf3, 0xf3, 0xf3, 0xf4, 0xf4, 0xf4, 0xf5, 0xf5, 0xf5, 0xf6, 0xf6, 0xf7, 0xf7, 0xf7, 0xf8, 0xf8, 0xf9, + 0xf9, 0xf9, 0xfa, 0xfa, 0xfb, 0xfb, 0xfc, 0xfc, 0xfd, 0xfd, 0xfd, 0xfe, 0xfe, 0xff, 0xff, 0x00, 0x00, 0x01, 0x01, 0x01, 0x02, 0x02, + 0x03, 0x03, 0x03, 0x04, 0x04, 0x05, 0x05, 0x05, 0x06, 0x06, 0x07, 0x07, 0x07, 0x08, 0x08, 0x08, 0x09, 0x09, 0x0a, 0x0a, 0x0a, 0x0b, + 0x0b, 0x0b, 0x0c, 0x0c, 0x0c, 0x0c, 0x0d, 0x0d, 0x0d, 0x0e, 0x0e, 0x0e, 0x0e, 0x0f, 0x0f, 0x0f, 0x0f, 0x10, 0x10, 0x10, 0x10, 0x10, + 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, + 0x13, 0x13, 0x13, 0x13, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x13, 0x13, 0x13, 0x13, + 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x10, 0x10, + 0x10, 0x10, 0x10, 0x10, 0x0f, 0x0f, 0x0f, 0x0f, 0x0e, 0x0e, 0x0e, 0x0e, 0x0d, 0x0d, 0x0d, 0x0c, 0x0c, 0x0c, 0x0c, 0x0b, 0x0b, 0x0b, + 0x0b, 0x0a, 0x0a, 0x0a, 0x09, 0x09, 0x09, 0x08, 0x08, 0x08, 0x08, 0x07, 0x07, 0x06, 0x06, 0x06, 0x05, 0x05, 0x05, 0x04, 0x04, 0x03, + 0x03, 0x02, 0x02, 0x02, 0x01, 0x01, 0x00, 0x00, 0xff, 0xff, 0xfe, 0xfe, 0xfe, 0xfd, 0xfd, 0xfc, 0xfc, 0xfb, 0xfb, 0xfb, 0xfa, 0xfa, + 0xfa, 0xf9, 0xf9, 0xf8, 0xf8, 0xf8, 0xf7, 0xf7, 0xf6, 0xf6, 0xf5, 0xf5, 0xf5, 0xf4, 0xf4, 0xf3, 0xf3, 0xf3, 0xf2, 0xf2, 0xf1, 0xf1, + 0xf1, 0xf0, 0xf0, 0xf0, 0xef, 0xef, 0xef, 0xee, 0xee, 0xee, 0xee, 0xed, 0xed, 0xed, 0xec, 0xec, 0xec, 0xec, 0xeb, 0xeb, 0xeb, 0xeb, + 0xea, 0xea, 0xea, 0xea, 0xea, 0xe9, 0xe9, 0xe9, 0xe9, 0xe9, 0xe8, 0xe8, 0xe8, 0xe8, 0xe8, 0xe8, 0xe7, 0xe7, 0xe7, 0xe7, 0xe7, 0xe7, + 0xe7, 0xe7, 0xe7, 0xe7, 0xe7, 0xe7, 0xe7, 0xe7, 0xe7, 0xe7, 0xe7, 0xe7, 0xe8, 0xe8, 0xe8, 0xe8, 0xe8, 0xe8, 0xe9, 0xe9, 0xe9, 0xe9, + 0xea, 0xea, 0xea, 0xea, 0xea, 0xeb, 0xeb, 0xeb, 0xeb, 0xec, 0xec, 0xec, 0xed, 0xed, 0xed, 0xee, 0xee, 0xee, 0xef, 0xef, 0xef, 0xf0, + 0xf0, 0xf1, 0xf1, 0xf1, 0xf2, 0xf2, 0xf3, 0xf3, 0xf3, 0xf4, 0xf4, 0xf5, 0xf5, 0xf5, 0xf6, 0xf6, 0xf7, 0xf7, 0xf8, 0xf8, 0xf9, 0xf9, + 0xfa, 0xfa, 0xfb, 0xfb, 0xfc, 0xfc, 0xfd, 0xfd, 0xfe, 0xfe, 0xff, 0xff, 0x00, 0x00, 0x01, 0x01, 0x02, 0x02, 0x03, 0x03, 0x04, 0x04, + 0x05, 0x05, 0x06, 0x06, 0x07, 0x07, 0x08, 0x08, 0x09, 0x09, 0x09, 0x0a, 0x0a, 0x0b, 0x0b, 0x0c, 0x0c, 0x0c, 0x0d, 0x0d, 0x0d, 0x0e, + 0x0e, 0x0e, 0x0f, 0x0f, 0x0f, 0x10, 0x10, 0x10, 0x11, 0x11, 0x11, 0x11, 0x12, 0x12, 0x12, 0x12, 0x13, 0x13, 0x13, 0x14, 0x14, 0x14, + 0x14, 0x15, 0x15, 0x15, 0x15, 0x15, 0x16, 0x16, 0x16, 0x16, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x18, 0x18, + 0x18, 0x18, 0x18, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x16, + 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x15, 0x15, 0x15, 0x15, 0x14, 0x14, 0x14, 0x13, 0x13, 0x13, 0x12, 0x12, 0x12, 0x11, 0x11, 0x11, + 0x10, 0x10, 0x0f, 0x0f, 0x0f, 0x0e, 0x0e, 0x0d, 0x0d, 0x0d, 0x0c, 0x0c, 0x0b, 0x0b, 0x0a, 0x0a, 0x0a, 0x09, 0x09, 0x08, 0x08, 0x08, + 0x07, 0x07, 0x06, 0x06, 0x05, 0x05, 0x04, 0x04, 0x04, 0x03, 0x03, 0x02, 0x02, 0x01, 0x01, 0x00, 0x00, 0xff, 0xff, 0xfe, 0xfe, 0xfd, + 0xfd, 0xfc, 0xfc, 0xfb, 0xfb, 0xfa, 0xfa, 0xfa, 0xf9, 0xf9, 0xf8, 0xf8, 0xf8, 0xf7, 0xf7, 0xf6, 0xf6, 0xf6, 0xf5, 0xf5, 0xf4, 0xf4, + 0xf4, 0xf3, 0xf3, 0xf2, 0xf2, 0xf2, 0xf1, 0xf1, 0xf1, 0xf0, 0xf0, 0xf0, 0xef, 0xef, 0xef, 0xee, 0xee, 0xee, 0xee, 0xed, 0xed, 0xed, + 0xed, 0xec, 0xec, 0xec, 0xec, 0xec, 0xeb, 0xeb, 0xeb, 0xeb, 0xeb, 0xeb, 0xea, 0xea, 0xea, 0xea, 0xea, 0xea, 0xea, 0xe9, 0xe9, 0xe9, + 0xe9, 0xe9, 0xe9, 0xe9, 0xe9, 0xe9, 0xe9, 0xe9, 0xe9, 0xe9, 0xe9, 0xe9, 0xe9, 0xe9, 0xe9, 0xe9, 0xe9, 0xe9, 0xe9, 0xe9, 0xe9, 0xe9, + 0xe9, 0xea, 0xea, 0xea, 0xea, 0xea, 0xea, 0xea, 0xeb, 0xeb, 0xeb, 0xeb, 0xeb, 0xec, 0xec, 0xec, 0xec, 0xec, 0xed, 0xed, 0xed, 0xee, + 0xee, 0xee, 0xee, 0xef, 0xef, 0xef, 0xf0, 0xf0, 0xf0, 0xf1, 0xf1, 0xf2, 0xf2, 0xf2, 0xf3, 0xf3, 0xf3, 0xf4, 0xf4, 0xf5, 0xf5, 0xf6, + 0xf6, 0xf6, 0xf7, 0xf7, 0xf8, 0xf8, 0xf9, 0xf9, 0xf9, 0xfa, 0xfa, 0xfb, 0xfb, 0xfc, 0xfc, 0xfc, 0xfd, 0xfd, 0xfe, 0xfe, 0xff, 0xff, + 0xff, 0x00, 0x00, 0x01, 0x01, 0x02, 0x02, 0x03, 0x03, 0x03, 0x04, 0x04, 0x05, 0x05, 0x06, 0x06, 0x06, 0x07, 0x07, 0x08, 0x08, 0x08, + 0x09, 0x09, 0x0a, 0x0a, 0x0a, 0x0b, 0x0b, 0x0b, 0x0b, 0x0c, 0x0c, 0x0c, 0x0d, 0x0d, 0x0d, 0x0d, 0x0e, 0x0e, 0x0e, 0x0e, 0x0f, 0x0f, + 0x0f, 0x0f, 0x0f, 0x10, 0x10, 0x10, 0x10, 0x10, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, + 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, + 0x12, 0x12, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x0f, + 0x0f, 0x0f, 0x0f, 0x0f, 0x0e, 0x0e, 0x0e, 0x0e, 0x0d, 0x0d, 0x0d, 0x0d, 0x0c, 0x0c, 0x0c, 0x0c, 0x0b, 0x0b, 0x0b, 0x0b, 0x0a, 0x0a, + 0x0a, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x08, 0x08, 0x08, 0x08, 0x07, 0x07, 0x07, 0x06, 0x06, 0x06, 0x05, 0x05, 0x05, 0x04, 0x04, 0x04, + 0x04, 0x03, 0x03, 0x03, 0x02, 0x02, 0x02, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xfe, 0xfe, 0xfe, 0xfd, 0xfd, + 0xfd, 0xfd, 0xfc, 0xfc, 0xfc, 0xfb, 0xfb, 0xfb, 0xfa, 0xfa, 0xfa, 0xfa, 0xf9, 0xf9, 0xf9, 0xf8, 0xf8, 0xf8, 0xf8, 0xf7, 0xf7, 0xf7, + 0xf6, 0xf6, 0xf6, 0xf6, 0xf5, 0xf5, 0xf5, 0xf5, 0xf4, 0xf4, 0xf4, 0xf4, 0xf3, 0xf3, 0xf3, 0xf3, 0xf2, 0xf2, 0xf2, 0xf2, 0xf1, 0xf1, + 0xf1, 0xf1, 0xf1, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, + 0xef, 0xee, 0xee, 0xee, 0xee, 0xee, 0xee, 0xee, 0xee, 0xee, 0xee, 0xee, 0xee, 0xee, 0xee, 0xee, 0xee, 0xee, 0xee, 0xee, 0xee, 0xee, + 0xee, 0xee, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf1, 0xf1, 0xf1, 0xf1, + 0xf1, 0xf2, 0xf2, 0xf2, 0xf2, 0xf3, 0xf3, 0xf3, 0xf3, 0xf4, 0xf4, 0xf4, 0xf5, 0xf5, 0xf5, 0xf5, 0xf6, 0xf6, 0xf6, 0xf7, 0xf7, 0xf7, + 0xf8, 0xf8, 0xf8, 0xf9, 0xf9, 0xf9, 0xfa, 0xfa, 0xfa, 0xfa, 0xfb, 0xfb, 0xfb, 0xfc, 0xfc, 0xfc, 0xfd, 0xfd, 0xfd, 0xfe, 0xfe, 0xfe, + 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x04, 0x04, 0x04, 0x04, 0x05, 0x05, + 0x05, 0x05, 0x06, 0x06, 0x06, 0x06, 0x07, 0x07, 0x07, 0x07, 0x08, 0x08, 0x08, 0x08, 0x09, 0x09, 0x09, 0x09, 0x0a, 0x0a, 0x0a, 0x0a, + 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0f, 0x0f, + 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, + 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0e, 0x0e, 0x0e, + 0x0e, 0x0e, 0x0e, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0c, 0x0c, 0x0c, 0x0c, 0x0b, 0x0b, 0x0b, 0x0b, 0x0a, 0x0a, 0x0a, 0x0a, 0x09, 0x09, + 0x09, 0x08, 0x08, 0x08, 0x07, 0x07, 0x07, 0x07, 0x06, 0x06, 0x06, 0x05, 0x05, 0x05, 0x04, 0x04, 0x04, 0x03, 0x03, 0x03, 0x02, 0x02, + 0x02, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xfe, 0xfe, 0xfe, 0xfe, 0xfd, 0xfd, 0xfd, 0xfd, 0xfc, 0xfc, + 0xfc, 0xfc, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xf9, 0xf9, 0xf9, 0xf9, 0xf9, 0xf9, 0xf8, 0xf8, 0xf8, 0xf8, + 0xf8, 0xf8, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xf6, 0xf6, 0xf6, 0xf6, 0xf6, 0xf6, 0xf6, 0xf6, 0xf6, 0xf6, 0xf6, 0xf5, 0xf5, + 0xf5, 0xf5, 0xf5, 0xf5, 0xf5, 0xf5, 0xf5, 0xf5, 0xf5, 0xf5, 0xf5, 0xf5, 0xf5, 0xf5, 0xf5, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, + 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, + 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf5, 0xf5, 0xf5, + 0xf5, 0xf5, 0xf5, 0xf5, 0xf5, 0xf5, 0xf5, 0xf5, 0xf5, 0xf6, 0xf6, 0xf6, 0xf6, 0xf6, 0xf6, 0xf6, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, + 0xf8, 0xf8, 0xf8, 0xf8, 0xf8, 0xf8, 0xf9, 0xf9, 0xf9, 0xf9, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfb, 0xfb, 0xfb, 0xfb, 0xfc, 0xfc, 0xfc, + 0xfc, 0xfc, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfe, 0xfe, 0xfe, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, + 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x03, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x05, 0x05, 0x05, 0x05, 0x05, + 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x07, 0x07, 0x07, 0x07, 0x07, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x09, 0x09, 0x09, 0x09, + 0x09, 0x09, 0x09, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, + 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0b, 0x0b, 0x0b, 0x0b, + 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, + 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x06, 0x06, 0x06, 0x06, + 0x06, 0x06, 0x05, 0x05, 0x05, 0x05, 0x05, 0x04, 0x04, 0x04, 0x04, 0x04, 0x03, 0x03, 0x03, 0x03, 0x03, 0x02, 0x02, 0x02, 0x02, 0x01, + 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, + 0xfe, 0xfe, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfa, 0xfa, 0xfa, + 0xfa, 0xfa, 0xfa, 0xf9, 0xf9, 0xf9, 0xf9, 0xf9, 0xf9, 0xf8, 0xf8, 0xf8, 0xf8, 0xf8, 0xf8, 0xf8, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, + 0xf6, 0xf6, 0xf6, 0xf6, 0xf6, 0xf6, 0xf6, 0xf5, 0xf5, 0xf5, 0xf5, 0xf5, 0xf5, 0xf5, 0xf5, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, + 0xf4, 0xf4, 0xf3, 0xf3, 0xf3, 0xf3, 0xf3, 0xf3, 0xf3, 0xf3, 0xf3, 0xf3, 0xf3, 0xf3, 0xf3, 0xf3, 0xf3, 0xf3, 0xf3, 0xf3, 0xf3, 0xf3, + 0xf3, 0xf3, 0xf3, 0xf3, 0xf3, 0xf3, 0xf3, 0xf3, 0xf3, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf5, 0xf5, 0xf5, + 0xf5, 0xf5, 0xf5, 0xf5, 0xf5, 0xf6, 0xf6, 0xf6, 0xf6, 0xf6, 0xf6, 0xf6, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xf8, 0xf8, 0xf8, 0xf8, + 0xf8, 0xf8, 0xf8, 0xf9, 0xf9, 0xf9, 0xf9, 0xf9, 0xf9, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfb, 0xfb, 0xfb, 0xfb, 0xfc, 0xfc, 0xfc, 0xfc, + 0xfd, 0xfd, 0xfd, 0xfd, 0xfe, 0xfe, 0xfe, 0xfe, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x02, + 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x03, 0x04, 0x04, 0x04, 0x04, 0x05, 0x05, 0x05, 0x05, 0x06, 0x06, 0x06, 0x06, 0x07, 0x07, 0x07, + 0x07, 0x08, 0x08, 0x08, 0x08, 0x09, 0x09, 0x09, 0x09, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0c, 0x0c, 0x0c, + 0x0c, 0x0c, 0x0c, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, + 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, + 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0a, 0x0a, 0x0a, 0x0a, 0x09, + 0x09, 0x09, 0x09, 0x08, 0x08, 0x08, 0x08, 0x07, 0x07, 0x07, 0x07, 0x06, 0x06, 0x06, 0x06, 0x05, 0x05, 0x05, 0x05, 0x04, 0x04, 0x04, + 0x04, 0x03, 0x03, 0x03, 0x03, 0x03, 0x02, 0x02, 0x02, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, + 0xfe, 0xfe, 0xfe, 0xfe, 0xfd, 0xfd, 0xfd, 0xfd, 0xfc, 0xfc, 0xfc, 0xfc, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfa, 0xfa, 0xfa, 0xfa, 0xf9, + 0xf9, 0xf9, 0xf9, 0xf8, 0xf8, 0xf8, 0xf8, 0xf8, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xf6, 0xf6, 0xf6, 0xf6, 0xf6, 0xf5, 0xf5, 0xf5, 0xf5, + 0xf5, 0xf5, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf3, 0xf3, 0xf3, 0xf3, 0xf3, 0xf3, 0xf3, 0xf3, 0xf3, 0xf2, 0xf2, 0xf2, 0xf2, + 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, + 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf3, 0xf3, 0xf3, 0xf3, 0xf3, 0xf3, + 0xf3, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf5, 0xf5, 0xf5, 0xf5, 0xf5, 0xf6, 0xf6, 0xf6, 0xf6, 0xf6, 0xf7, 0xf7, 0xf7, 0xf7, 0xf8, 0xf8, + 0xf8, 0xf8, 0xf8, 0xf8, 0xf9, 0xf9, 0xf9, 0xf9, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfb, 0xfb, 0xfb, 0xfb, 0xfc, 0xfc, 0xfc, 0xfc, 0xfd, + 0xfd, 0xfd, 0xfd, 0xfe, 0xfe, 0xfe, 0xfe, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, + 0x02, 0x03, 0x03, 0x03, 0x03, 0x04, 0x04, 0x04, 0x04, 0x05, 0x05, 0x05, 0x05, 0x06, 0x06, 0x06, 0x06, 0x07, 0x07, 0x07, 0x07, 0x07, + 0x08, 0x08, 0x08, 0x08, 0x08, 0x09, 0x09, 0x09, 0x09, 0x09, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, + 0x0b, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, + 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0d, + 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0a, 0x0a, 0x0a, + 0x0a, 0x0a, 0x09, 0x09, 0x09, 0x08, 0x08, 0x08, 0x08, 0x08, 0x07, 0x07, 0x07, 0x07, 0x06, 0x06, 0x06, 0x06, 0x05, 0x05, 0x05, 0x04, + 0x04, 0x04, 0x04, 0x04, 0x03, 0x03, 0x03, 0x03, 0x02, 0x02, 0x02, 0x02, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, + 0xff, 0xff, 0xff, 0xfe, 0xfe, 0xfe, 0xfe, 0xfd, 0xfd, 0xfd, 0xfd, 0xfc, 0xfc, 0xfc, 0xfc, 0xfb, 0xfb, 0xfb, 0xfb, 0xfa, 0xfa, 0xfa, + 0xfa, 0xf9, 0xf9, 0xf9, 0xf9, 0xf9, 0xf8, 0xf8, 0xf8, 0xf8, 0xf8, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xf6, 0xf6, 0xf6, 0xf6, 0xf6, 0xf6, + 0xf5, 0xf5, 0xf5, 0xf5, 0xf5, 0xf5, 0xf5, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf3, 0xf3, 0xf3, 0xf3, 0xf3, 0xf3, 0xf3, 0xf3, + 0xf3, 0xf3, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, + 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf3, 0xf3, 0xf3, 0xf3, 0xf3, 0xf3, + 0xf3, 0xf3, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf5, 0xf5, 0xf5, 0xf5, 0xf5, 0xf6, 0xf6, 0xf6, 0xf6, 0xf6, 0xf7, 0xf7, 0xf7, + 0xf7, 0xf7, 0xf8, 0xf8, 0xf8, 0xf8, 0xf9, 0xf9, 0xf9, 0xf9, 0xf9, 0xfa, 0xfa, 0xfa, 0xfa, 0xfb, 0xfb, 0xfb, 0xfb, 0xfc, 0xfc, 0xfc, + 0xfc, 0xfd, 0xfd, 0xfd, 0xfe, 0xfe, 0xfe, 0xfe, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, + 0x02, 0x02, 0x03, 0x03, 0x03, 0x03, 0x04, 0x04, 0x04, 0x04, 0x05, 0x05, 0x05, 0x05, 0x06, 0x06, 0x06, 0x06, 0x07, 0x07, 0x07, 0x07, + 0x08, 0x08, 0x08, 0x08, 0x09, 0x09, 0x09, 0x09, 0x09, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, + 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, + 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, + 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x09, 0x09, 0x09, + 0x09, 0x09, 0x08, 0x08, 0x08, 0x08, 0x08, 0x07, 0x07, 0x07, 0x07, 0x07, 0x06, 0x06, 0x06, 0x06, 0x05, 0x05, 0x05, 0x05, 0x04, 0x04, + 0x04, 0x04, 0x04, 0x03, 0x03, 0x03, 0x03, 0x02, 0x02, 0x02, 0x02, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, + 0xff, 0xff, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfb, 0xfb, 0xfb, 0xfb, + 0xfb, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xf9, 0xf9, 0xf9, 0xf9, 0xf9, 0xf8, 0xf8, 0xf8, 0xf8, 0xf8, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, + 0xf6, 0xf6, 0xf6, 0xf6, 0xf6, 0xf6, 0xf6, 0xf6, 0xf5, 0xf5, 0xf5, 0xf5, 0xf5, 0xf5, 0xf5, 0xf5, 0xf5, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, + 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf3, 0xf3, 0xf3, 0xf3, 0xf3, 0xf3, 0xf3, 0xf3, 0xf3, 0xf3, 0xf3, 0xf3, 0xf3, + 0xf3, 0xf3, 0xf3, 0xf3, 0xf3, 0xf3, 0xf3, 0xf3, 0xf3, 0xf3, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, + 0xf5, 0xf5, 0xf5, 0xf5, 0xf5, 0xf5, 0xf5, 0xf5, 0xf6, 0xf6, 0xf6, 0xf6, 0xf6, 0xf6, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xf8, 0xf8, 0xf8, + 0xf8, 0xf8, 0xf9, 0xf9, 0xf9, 0xf9, 0xf9, 0xfa, 0xfa, 0xfa, 0xfa, 0xfb, 0xfb, 0xfb, 0xfb, 0xfc, 0xfc, 0xfc, 0xfc, 0xfd, 0xfd, 0xfd, + 0xfd, 0xfe, 0xfe, 0xfe, 0xfe, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, + 0x02, 0x03, 0x03, 0x03, 0x03, 0x03, 0x04, 0x04, 0x04, 0x04, 0x04, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x06, 0x06, 0x06, 0x06, 0x06, + 0x06, 0x06, 0x06, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, + 0x08, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, + 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x08, 0x08, 0x08, + 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, + 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, + 0x04, 0x04, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x01, 0x01, 0x01, 0x01, 0x01, + 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xfe, + 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, + 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xf9, 0xf9, 0xf9, + 0xf9, 0xf9, 0xf9, 0xf9, 0xf9, 0xf9, 0xf8, 0xf8, 0xf8, 0xf8, 0xf8, 0xf8, 0xf8, 0xf8, 0xf8, 0xf8, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, + 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xf6, 0xf6, 0xf6, 0xf6, 0xf6, 0xf6, 0xf6, 0xf6, 0xf6, 0xf6, 0xf6, 0xf6, 0xf6, 0xf6, 0xf6, + 0xf6, 0xf6, 0xf6, 0xf6, 0xf6, 0xf6, 0xf6, 0xf6, 0xf6, 0xf6, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, + 0xf7, 0xf7, 0xf7, 0xf8, 0xf8, 0xf8, 0xf8, 0xf8, 0xf8, 0xf8, 0xf8, 0xf8, 0xf8, 0xf9, 0xf9, 0xf9, 0xf9, 0xf9, 0xf9, 0xf9, 0xfa, 0xfa, + 0xfa, 0xfa, 0xfa, 0xfa, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, + 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, + 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x04, 0x04, 0x04, 0x04, + 0x04, 0x04, 0x04, 0x04, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x07, + 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, + 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, + 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, + 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x05, 0x05, + 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x02, 0x02, 0x02, + 0x02, 0x02, 0x02, 0x02, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, + 0xfb, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xf9, 0xf9, 0xf9, 0xf9, 0xf9, 0xf9, 0xf8, 0xf8, 0xf8, 0xf8, 0xf8, 0xf7, 0xf7, 0xf7, 0xf7, + 0xf7, 0xf7, 0xf6, 0xf6, 0xf6, 0xf6, 0xf6, 0xf6, 0xf6, 0xf5, 0xf5, 0xf5, 0xf5, 0xf5, 0xf5, 0xf5, 0xf5, 0xf5, 0xf5, 0xf4, 0xf4, 0xf4, + 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf5, + 0xf5, 0xf5, 0xf5, 0xf5, 0xf5, 0xf5, 0xf5, 0xf5, 0xf5, 0xf6, 0xf6, 0xf6, 0xf6, 0xf6, 0xf6, 0xf6, 0xf6, 0xf6, 0xf7, 0xf7, 0xf7, 0xf7, + 0xf7, 0xf7, 0xf7, 0xf7, 0xf8, 0xf8, 0xf8, 0xf8, 0xf8, 0xf8, 0xf9, 0xf9, 0xf9, 0xf9, 0xf9, 0xf9, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfb, + 0xfb, 0xfb, 0xfb, 0xfb, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, + 0x03, 0x03, 0x03, 0x03, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x06, 0x06, 0x06, 0x06, 0x06, + 0x06, 0x06, 0x06, 0x06, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, + 0x08, 0x08, 0x08, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, + 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, + 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x07, 0x07, + 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x04, + 0x04, 0x04, 0x04, 0x04, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfc, 0xfc, + 0xfc, 0xfc, 0xfc, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xf9, 0xf9, 0xf9, 0xf9, 0xf9, 0xf9, 0xf8, 0xf8, 0xf8, + 0xf8, 0xf8, 0xf8, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xf6, 0xf6, 0xf6, 0xf6, 0xf6, 0xf6, 0xf5, 0xf5, 0xf5, 0xf5, 0xf5, 0xf5, 0xf5, + 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf3, 0xf3, 0xf3, 0xf3, 0xf3, 0xf3, 0xf3, 0xf3, 0xf3, 0xf3, 0xf3, 0xf3, + 0xf3, 0xf3, 0xf3, 0xf3, 0xf3, 0xf3, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf5, + 0xf5, 0xf5, 0xf5, 0xf5, 0xf5, 0xf5, 0xf5, 0xf5, 0xf6, 0xf6, 0xf6, 0xf6, 0xf6, 0xf6, 0xf6, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xf8, 0xf8, + 0xf8, 0xf8, 0xf8, 0xf9, 0xf9, 0xf9, 0xf9, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfc, 0xfc, 0xfc, 0xfc, 0xfd, + 0xfd, 0xfd, 0xfd, 0xfd, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, + 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x03, 0x03, 0x04, 0x04, 0x04, 0x04, 0x04, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x06, 0x06, + 0x06, 0x06, 0x06, 0x06, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x09, 0x09, 0x09, 0x09, + 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, + 0x0a, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, + 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, + 0x09, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x05, 0x05, + 0x05, 0x05, 0x05, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x03, 0x03, 0x03, 0x03, 0x03, 0x02, 0x02, 0x02, 0x02, 0x02, 0x01, 0x01, 0x01, + 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfc, 0xfc, + 0xfc, 0xfc, 0xfc, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfa, 0xfa, 0xfa, 0xfa, 0xf9, 0xf9, 0xf9, 0xf9, 0xf9, 0xf8, 0xf8, 0xf8, 0xf8, + 0xf8, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xf6, 0xf6, 0xf6, 0xf6, 0xf6, 0xf6, 0xf5, 0xf5, 0xf5, 0xf5, 0xf5, 0xf5, 0xf5, 0xf4, 0xf4, 0xf4, + 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf3, 0xf3, 0xf3, 0xf3, 0xf3, 0xf3, 0xf3, 0xf3, 0xf3, 0xf3, 0xf3, 0xf3, 0xf3, 0xf3, 0xf3, + 0xf3, 0xf3, 0xf3, 0xf3, 0xf3, 0xf3, 0xf3, 0xf3, 0xf3, 0xf3, 0xf3, 0xf3, 0xf3, 0xf3, 0xf3, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, + 0xf4, 0xf4, 0xf5, 0xf5, 0xf5, 0xf5, 0xf5, 0xf5, 0xf6, 0xf6, 0xf6, 0xf6, 0xf6, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xf8, 0xf8, 0xf8, 0xf8, + 0xf8, 0xf9, 0xf9, 0xf9, 0xf9, 0xf9, 0xfa, 0xfa, 0xfa, 0xfa, 0xfb, 0xfb, 0xfb, 0xfb, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfd, 0xfd, 0xfd, + 0xfd, 0xfe, 0xfe, 0xfe, 0xfe, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, + 0x02, 0x03, 0x03, 0x03, 0x03, 0x03, 0x04, 0x04, 0x04, 0x04, 0x04, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x06, 0x06, 0x06, 0x06, + 0x06, 0x06, 0x06, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, + 0x08, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, + 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, + 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x06, + 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x03, 0x03, 0x03, + 0x03, 0x03, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, + 0xfd, 0xfd, 0xfd, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, + 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xf9, + 0xf9, 0xf9, 0xf9, 0xf9, 0xf9, 0xf9, 0xf9, 0xf9, 0xf9, 0xf9, 0xf9, 0xf9, 0xf9, 0xf9, 0xf9, 0xf9, 0xf9, 0xf9, 0xf8, 0xf8, 0xf8, 0xf8, + 0xf8, 0xf8, 0xf8, 0xf8, 0xf8, 0xf8, 0xf8, 0xf8, 0xf8, 0xf8, 0xf8, 0xf8, 0xf8, 0xf8, 0xf8, 0xf8, 0xf8, 0xf8, 0xf8, 0xf8, 0xf8, 0xf8, + 0xf8, 0xf8, 0xf8, 0xf8, 0xf8, 0xf8, 0xf8, 0xf8, 0xf8, 0xf8, 0xf8, 0xf8, 0xf8, 0xf8, 0xf8, 0xf9, 0xf9, 0xf9, 0xf9, 0xf9, 0xf9, 0xf9, + 0xf9, 0xf9, 0xf9, 0xf9, 0xf9, 0xf9, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfc, + 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, + 0x02, 0x02, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x04, 0x03, 0x04, 0x04, 0x04, 0x04, 0x04, 0x05, 0x04, 0x05, 0x05, 0x05, 0x05, + 0x05, 0x05, 0x05, 0x05, 0x05, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, + 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, + 0x08, 0x08, 0x08, 0x08, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, + 0x07, 0x07, 0x07, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, + 0x05, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x02, 0x02, 0x02, + 0x02, 0x02, 0x02, 0x02, 0x02, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, + 0xfd, 0xfd, 0xfd, 0xfd, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfa, + 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xf9, 0xf9, 0xf9, 0xf9, 0xf9, 0xf9, 0xf9, 0xf9, 0xf9, 0xf9, 0xf8, 0xf8, 0xf8, 0xf8, + 0xf8, 0xf8, 0xf8, 0xf8, 0xf8, 0xf8, 0xf8, 0xf8, 0xf8, 0xf8, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, + 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, + 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xf8, 0xf8, 0xf8, 0xf8, 0xf8, 0xf8, 0xf8, 0xf8, 0xf8, 0xf8, 0xf9, 0xf9, 0xf9, 0xf9, 0xf9, 0xf9, 0xf9, + 0xf9, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfd, 0xfd, + 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, + 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, + 0x06, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, + 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, + 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x07, 0x07, 0x07, + 0x07, 0x07, 0x07, 0x07, 0x07, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x04, 0x04, 0x04, + 0x04, 0x04, 0x04, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, + 0xfd, 0xfd, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, + 0xfa, 0xfa, 0xfa, 0xfa, 0xf9, 0xf9, 0xf9, 0xf9, 0xf9, 0xf9, 0xf9, 0xf9, 0xf9, 0xf9, 0xf9, 0xf8, 0xf8, 0xf8, 0xf8, 0xf8, 0xf8, 0xf8, + 0xf8, 0xf8, 0xf8, 0xf8, 0xf8, 0xf8, 0xf8, 0xf8, 0xf8, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, + 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, 0xf7, + 0xf7, 0xf8, 0xf8, 0xf8, 0xf8, 0xf8, 0xf8, 0xf8, 0xf8, 0xf8, 0xf8, 0xf8, 0xf8, 0xf8, 0xf8, 0xf9, 0xf9, 0xf9, 0xf9, 0xf9, 0xf9, 0xf9, + 0xf9, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, + 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x03, + 0x03, 0x03, 0x03, 0x03, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x06, + 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, + 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, + 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, + 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x03, + 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, + 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xfe, 0xfe, + 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfc, 0xfc, 0xfc, 0xfc, + 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, + 0xfb, 0xfb, 0xfb, 0xfb, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, + 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xf9, 0xf9, 0xf9, 0xf9, 0xf9, 0xf9, 0xf9, 0xf9, 0xf9, 0xf9, 0xf9, 0xf9, 0xf9, 0xf9, 0xf9, 0xf9, + 0xf9, 0xf9, 0xf9, 0xf9, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, + 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfc, 0xfc, 0xfc, 0xfc, + 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, + 0xfe, 0xfe, 0xfe, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, + 0x02, 0x02, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, + 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x05, 0x05, + 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, + 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, + 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, + 0x03, 0x03, 0x03, 0x03, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, + 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfd, 0xfd, 0xfd, + 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, + 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, + 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, + 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, + 0xfa, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, + 0xfb, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, + 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x02, + 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, + 0x03, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x05, 0x05, 0x05, + 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, + 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x04, 0x04, + 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, + 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x01, 0x01, 0x01, + 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfd, + 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, + 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfa, 0xfa, + 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, + 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, + 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, + 0xfb, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfe, + 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, + 0x02, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, + 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, + 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, + 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x04, 0x04, 0x04, + 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, + 0x03, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, + 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, + 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, + 0xfb, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xf9, 0xf9, 0xf9, 0xf9, + 0xf9, 0xf9, 0xf9, 0xf9, 0xf9, 0xf9, 0xf9, 0xf9, 0xf9, 0xf9, 0xf9, 0xf9, 0xf9, 0xf9, 0xf9, 0xf9, 0xf9, 0xf9, 0xf9, 0xf9, 0xf9, 0xf9, + 0xf9, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfa, 0xfb, 0xfb, 0xfb, 0xfb, + 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfd, 0xfd, 0xfd, 0xfd, + 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, + 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, + 0x03, 0x03, 0x03, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, + 0x04, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, + 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, + 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, + 0x03, 0x03, 0x03, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, + 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfd, 0xfd, + 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, + 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfb, 0xfb, + 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, + 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, + 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfd, 0xfd, 0xfd, 0xfd, + 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, + 0xfe, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, + 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, + 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, + 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, + 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, + 0x03, 0x03, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, + 0x02, 0x02, 0x02, 0x02, 0x02, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, + 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, + 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, + 0xfd, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, + 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, + 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfd, 0xfd, 0xfd, + 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, + 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, + 0x01, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, + 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, + 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, + 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, + 0x03, 0x03, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x01, 0x01, 0x01, + 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfd, + 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfc, 0xfc, 0xfc, + 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, + 0xfc, 0xfc, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, + 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfc, 0xfb, 0xfc, 0xfb, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, + 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, + 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, + 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, + 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, + 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x04, 0x04, 0x04, 0x04, 0x03, + 0x04, 0x04, 0x03, 0x04, 0x03, 0x04, 0x04, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, + 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, + 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, + 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, + 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, + 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, + 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, + 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfc, + 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfd, 0xfd, 0xfd, 0xfd, + 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, + 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x03, + 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, + 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, + 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, + 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, + 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, + 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, + 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, + 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, + 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, + 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, + 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, + 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, + 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, + 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, + 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, + 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, + 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfd, 0xfd, 0xfd, 0xfd, + 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, + 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, + 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, + 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, + 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, + 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, + 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, + 0x02, 0x02, 0x02, 0x02, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, + 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xff, 0xfe, 0xff, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, + 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfd, 0xfd, 0xfd, 0xfd, +}; + +static const unsigned char TOP_2608[66610] = { + 0x52, 0x49, 0x46, 0x46, 0x30, 0x08, 0x02, 0x00, 0x57, 0x41, 0x56, 0x45, 0x66, 0x6d, 0x74, 0x20, 0x10, 0x00, 0x00, 0x00, 0x01, 0x00, + 0x01, 0x00, 0x44, 0xac, 0x00, 0x00, 0x88, 0x58, 0x01, 0x00, 0x02, 0x00, 0x10, 0x00, 0x66, 0x61, 0x63, 0x74, 0x04, 0x00, 0x00, 0x00, + 0x04, 0x00, 0x61, 0x61, 0x08, 0x00, 0x00, 0xff, 0xff, 0x02, 0xff, 0xfe, 0x00, 0xfc, 0x00, 0x01, 0xfb, 0x01, 0x01, 0xfd, 0xfe, 0x04, + 0x03, 0xfe, 0x07, 0xf3, 0xed, 0x09, 0xfc, 0x01, 0x0b, 0xf8, 0xf6, 0xfd, 0x04, 0x08, 0x04, 0xfb, 0xf7, 0xf6, 0xfc, 0x04, 0x0c, 0x00, + 0xfa, 0x03, 0x05, 0x00, 0xfa, 0xf9, 0xef, 0xf3, 0x01, 0x0a, 0x09, 0x04, 0x02, 0x02, 0x01, 0xff, 0xfb, 0xf9, 0xfc, 0x02, 0x05, 0x02, + 0xfe, 0xfe, 0x00, 0x05, 0x06, 0x00, 0x00, 0xfc, 0xf9, 0x03, 0x05, 0x03, 0x04, 0x05, 0x06, 0x06, 0x06, 0xfd, 0xfb, 0x00, 0xf7, 0xff, + 0x06, 0xfd, 0x05, 0x00, 0xf6, 0xfc, 0x02, 0xfe, 0xf6, 0x09, 0x02, 0xf6, 0x00, 0xf9, 0xff, 0x08, 0xf5, 0xfb, 0xfe, 0xf6, 0xff, 0x00, + 0xfe, 0x02, 0xff, 0xfd, 0xfe, 0xfd, 0x00, 0x02, 0xff, 0x07, 0xfd, 0xf4, 0x00, 0x03, 0x00, 0x00, 0x0f, 0x04, 0xfe, 0x0a, 0x04, 0xfa, + 0xf8, 0x06, 0xfb, 0xfd, 0x0c, 0xfb, 0xfc, 0x04, 0x02, 0x05, 0x05, 0x02, 0xfe, 0x04, 0x03, 0xfa, 0xfd, 0xfc, 0xfa, 0xfb, 0xf8, 0xfc, + 0x01, 0xfe, 0xf8, 0xf8, 0x00, 0x05, 0x08, 0x0b, 0x0d, 0xfd, 0xfa, 0x05, 0x02, 0x08, 0x07, 0xfc, 0xfc, 0x04, 0x04, 0xf5, 0xff, 0x05, + 0x00, 0xfe, 0x00, 0xfc, 0xf5, 0xf8, 0x03, 0x06, 0xf5, 0xf7, 0xfe, 0x00, 0xf9, 0xfb, 0xfd, 0xf8, 0xf3, 0x00, 0x0e, 0x06, 0xfd, 0xfb, + 0x00, 0x06, 0x03, 0xfa, 0xf6, 0xfe, 0x01, 0x03, 0x0f, 0x01, 0xfa, 0x04, 0xf6, 0x08, 0x14, 0xf8, 0x00, 0x07, 0x00, 0xf1, 0x00, 0x06, + 0xf7, 0x05, 0x07, 0xfc, 0xf6, 0xfe, 0xfd, 0xf7, 0x01, 0x00, 0xff, 0x07, 0xf5, 0x02, 0x10, 0xf5, 0xfb, 0x04, 0x00, 0xf9, 0xfc, 0xff, + 0xfe, 0xfe, 0x06, 0x08, 0xf2, 0x03, 0x0e, 0x03, 0xfd, 0x01, 0x04, 0xfd, 0x0d, 0x06, 0xf9, 0x0c, 0x02, 0xfc, 0x05, 0xfd, 0xfe, 0x07, + 0x0f, 0xf1, 0xf4, 0x0a, 0xf7, 0xfc, 0x03, 0xfc, 0xf8, 0xf1, 0xf3, 0x03, 0x04, 0x02, 0x04, 0x07, 0x00, 0xf7, 0xf7, 0xff, 0xfe, 0xfc, + 0x05, 0xf9, 0xfb, 0x07, 0xfa, 0xf9, 0x00, 0x04, 0xf7, 0xf8, 0x00, 0xf9, 0xfc, 0x00, 0xff, 0xf6, 0xff, 0x0b, 0x09, 0xfc, 0xff, 0x0a, + 0x00, 0x03, 0x02, 0x00, 0x13, 0x16, 0x07, 0xfa, 0xf0, 0xff, 0x0f, 0xfc, 0xfd, 0x05, 0x05, 0xf3, 0xf9, 0x02, 0xf6, 0xff, 0x01, 0xfe, + 0x0d, 0x00, 0xfa, 0x09, 0xfc, 0x02, 0x0a, 0xfb, 0x01, 0x08, 0x07, 0xff, 0x05, 0x00, 0xeb, 0x0e, 0x0c, 0xf9, 0x09, 0x05, 0xf9, 0xf5, + 0x00, 0xfb, 0x00, 0x16, 0xf4, 0xf0, 0x06, 0x08, 0xfb, 0xfe, 0x0f, 0xf7, 0xfb, 0x0a, 0x0b, 0xf1, 0xf2, 0x07, 0x06, 0xf8, 0xfb, 0x0b, + 0xe8, 0xf2, 0x07, 0xf8, 0xf3, 0xf6, 0xfa, 0xf5, 0x05, 0x05, 0xf2, 0xf7, 0x01, 0x03, 0xfd, 0xf8, 0x01, 0x09, 0xfc, 0xf4, 0x00, 0x14, + 0xff, 0xfa, 0x03, 0xff, 0x06, 0x04, 0xfc, 0x0c, 0xff, 0xf5, 0x04, 0x00, 0xff, 0x01, 0xf8, 0x02, 0x03, 0xf8, 0xfb, 0x05, 0x03, 0xf0, + 0x07, 0x07, 0xf8, 0x00, 0x05, 0x07, 0x03, 0xea, 0xfb, 0x11, 0xff, 0x0a, 0x05, 0xf5, 0xfb, 0x08, 0x09, 0xff, 0x0e, 0x05, 0xf6, 0xfc, + 0x01, 0x00, 0xfe, 0x06, 0x08, 0x03, 0xfc, 0x0b, 0x0a, 0x02, 0x05, 0x09, 0xff, 0xf1, 0xff, 0x0a, 0x0a, 0x00, 0x06, 0xf6, 0xed, 0x10, + 0xf9, 0xf2, 0x08, 0xf4, 0xf6, 0xfc, 0xf4, 0xf1, 0xf6, 0xfa, 0xf9, 0xf5, 0xfa, 0x02, 0xf7, 0xf5, 0xfc, 0x02, 0xf9, 0xf7, 0xff, 0x01, + 0x08, 0x02, 0xf3, 0xf7, 0xf7, 0xfd, 0x11, 0xfb, 0xf7, 0x06, 0xf1, 0x00, 0x11, 0x09, 0xf5, 0xf4, 0x01, 0x04, 0x0c, 0x00, 0xf0, 0x0d, + 0x07, 0xf8, 0xfd, 0x12, 0x03, 0xf3, 0x0e, 0x0b, 0x01, 0xfd, 0xf5, 0xfe, 0x09, 0x03, 0x08, 0x05, 0xfe, 0xfe, 0x05, 0x06, 0xfe, 0xfd, + 0x00, 0x05, 0x07, 0x00, 0xff, 0xfe, 0xe8, 0x08, 0x12, 0xf2, 0x06, 0x08, 0xfd, 0xf9, 0x0a, 0x04, 0xf5, 0x05, 0x10, 0x07, 0xf7, 0xf8, + 0x08, 0x0a, 0xe7, 0x00, 0x09, 0xf5, 0xf1, 0x03, 0x07, 0xf4, 0xfc, 0xfd, 0xf5, 0xf3, 0xf3, 0xfa, 0x00, 0xee, 0xf8, 0x07, 0x02, 0x05, + 0x01, 0xfd, 0x06, 0x09, 0xf7, 0xe3, 0x04, 0xfb, 0xf2, 0x0d, 0x00, 0xf4, 0xf7, 0xf6, 0x08, 0x08, 0xf4, 0xf9, 0x03, 0x00, 0xed, 0x04, + 0x13, 0x0b, 0xff, 0x03, 0x08, 0x02, 0xfe, 0x03, 0x0c, 0x12, 0x0b, 0x0b, 0x0e, 0xf9, 0x01, 0x08, 0xfa, 0x02, 0xff, 0xfa, 0x00, 0x0d, + 0x08, 0xfa, 0x02, 0x03, 0x07, 0x13, 0xf5, 0xfd, 0x0f, 0xe9, 0xfd, 0x0b, 0xfb, 0xf2, 0xfe, 0x07, 0xff, 0x03, 0x08, 0x05, 0xf3, 0x06, + 0x09, 0xf2, 0x08, 0x08, 0xfc, 0xfd, 0x02, 0xf9, 0xef, 0xf8, 0x01, 0xfe, 0xf3, 0xfc, 0xfd, 0xf9, 0xf9, 0x0f, 0x05, 0xeb, 0x03, 0xf4, + 0xec, 0x03, 0xff, 0xf8, 0xfb, 0x0a, 0x00, 0xf9, 0xfa, 0xfd, 0xf0, 0xf6, 0x14, 0x00, 0xf6, 0xfc, 0xfd, 0xf8, 0x04, 0x13, 0xf0, 0xf8, + 0x06, 0xf7, 0x05, 0x0d, 0x07, 0x08, 0x00, 0x03, 0x0d, 0x04, 0x01, 0x02, 0x00, 0x07, 0x0b, 0x09, 0x05, 0x05, 0x06, 0x05, 0xfb, 0xfd, + 0x06, 0x0c, 0x01, 0xf8, 0xf9, 0x05, 0x01, 0x07, 0x19, 0xff, 0xf7, 0x00, 0x01, 0xff, 0x01, 0x06, 0xfd, 0x04, 0x05, 0xf7, 0xff, 0x03, + 0xff, 0xfe, 0xed, 0xf7, 0x10, 0xf1, 0x01, 0x15, 0x02, 0xf3, 0xf7, 0x01, 0xf7, 0x03, 0x05, 0xf8, 0xfa, 0xff, 0xff, 0xf8, 0x00, 0xfd, + 0xf9, 0x0a, 0x07, 0xfa, 0xf5, 0x04, 0x06, 0xfe, 0xfb, 0x01, 0x01, 0xfd, 0x08, 0xf7, 0xf0, 0x02, 0x08, 0x07, 0x05, 0x07, 0x03, 0x00, + 0x00, 0xfd, 0xfc, 0x01, 0x08, 0xfe, 0xff, 0x03, 0xf8, 0xfb, 0x05, 0x07, 0xfc, 0xf8, 0xfc, 0x01, 0x0d, 0x03, 0xf3, 0xfc, 0xfa, 0xf8, + 0xfc, 0x08, 0xfb, 0xf4, 0x06, 0xfd, 0xfb, 0x02, 0x07, 0x05, 0x06, 0x09, 0xf2, 0xf4, 0x01, 0x01, 0x06, 0xff, 0xf4, 0x04, 0xee, 0xe9, + 0x07, 0x13, 0xfa, 0xeb, 0x10, 0xfd, 0xf8, 0x06, 0xfb, 0xee, 0xf1, 0x01, 0x0a, 0x00, 0xf7, 0x05, 0x07, 0x00, 0xfb, 0x05, 0x06, 0x01, + 0xfc, 0x04, 0xfb, 0xf4, 0x0c, 0x07, 0xff, 0x01, 0x03, 0xf9, 0xf3, 0xf8, 0x0e, 0x02, 0xf1, 0x13, 0x04, 0xfc, 0x0c, 0xfd, 0xfa, 0xff, + 0x00, 0xf4, 0xfb, 0x09, 0xfe, 0x04, 0x07, 0xfd, 0xfc, 0xf6, 0xf7, 0x0b, 0xf4, 0xf1, 0x07, 0x0b, 0xf7, 0xf4, 0x09, 0x00, 0xf5, 0xf3, + 0xfc, 0x02, 0xfe, 0xf9, 0x13, 0x00, 0xf1, 0x03, 0xf8, 0xf6, 0xfe, 0xff, 0x09, 0x03, 0xf1, 0x01, 0x02, 0xf8, 0xed, 0x0e, 0x01, 0xe6, + 0x0b, 0x0b, 0xf7, 0xed, 0xff, 0x04, 0x03, 0x09, 0x00, 0xfd, 0x01, 0xfe, 0xff, 0x01, 0x02, 0x05, 0x0e, 0x09, 0xed, 0x08, 0x0a, 0xf6, + 0x09, 0x0b, 0x04, 0x02, 0x05, 0x07, 0xfe, 0xe2, 0x1e, 0x1e, 0xe3, 0xfa, 0xf8, 0xf7, 0x08, 0x05, 0xff, 0x01, 0x04, 0xf9, 0xf8, 0x02, + 0x04, 0x06, 0x03, 0xfa, 0x0d, 0xff, 0xed, 0x10, 0x02, 0xf6, 0x00, 0x03, 0x00, 0xfc, 0xfa, 0xfd, 0xff, 0xfe, 0xf9, 0xfe, 0x01, 0xfd, + 0xfa, 0x04, 0x07, 0xf1, 0x08, 0x0c, 0xfb, 0xfb, 0x00, 0xfd, 0xf7, 0x0e, 0x10, 0xfd, 0xef, 0xff, 0x09, 0x00, 0xf8, 0xfc, 0xfb, 0xf2, + 0xfe, 0x07, 0x04, 0xf6, 0x00, 0x05, 0xff, 0xfe, 0x0b, 0x0b, 0xf7, 0x00, 0x03, 0xfe, 0xfc, 0x07, 0x0c, 0x04, 0xf8, 0xf8, 0x01, 0x0a, + 0xfd, 0x01, 0x0b, 0xfd, 0xf9, 0x03, 0x0d, 0xf9, 0xf3, 0xfc, 0x06, 0xfb, 0x04, 0x13, 0x00, 0x04, 0x0a, 0x03, 0xfc, 0xff, 0x07, 0x0e, + 0xfe, 0xff, 0x0a, 0xef, 0xf0, 0xfb, 0xff, 0xf3, 0x05, 0x14, 0xfc, 0xf6, 0x05, 0x11, 0xeb, 0xf1, 0x05, 0x06, 0xf5, 0xfe, 0x0b, 0xf6, + 0xfc, 0x02, 0xff, 0x04, 0xf8, 0xf5, 0x0c, 0xfa, 0xf9, 0x03, 0xf7, 0xfc, 0x0b, 0x0f, 0xf4, 0xf0, 0xff, 0x07, 0x07, 0x06, 0x03, 0xf8, + 0xfc, 0x01, 0x00, 0xff, 0x06, 0x08, 0xfa, 0xfd, 0xff, 0xff, 0x05, 0x08, 0x03, 0xfc, 0xfd, 0x04, 0x08, 0x08, 0xfd, 0x05, 0x15, 0xfc, + 0xfa, 0x02, 0x04, 0xfd, 0x05, 0x06, 0xe8, 0x03, 0x11, 0xfe, 0xfa, 0xf7, 0xfa, 0x02, 0xef, 0xff, 0x12, 0xe9, 0xfd, 0x0f, 0x01, 0x00, + 0xf8, 0xf9, 0x0b, 0xf3, 0xee, 0xff, 0x07, 0xfc, 0xfb, 0x08, 0x05, 0xf4, 0xf2, 0x0b, 0xfb, 0xea, 0xed, 0x00, 0x0a, 0x0a, 0x04, 0x0b, + 0xfe, 0xf4, 0x07, 0xf4, 0xf5, 0x0e, 0x07, 0x18, 0x13, 0xed, 0xf9, 0xfa, 0xf5, 0x09, 0x03, 0xfc, 0x00, 0x0f, 0x00, 0xf6, 0x09, 0x08, + 0xfd, 0xfa, 0x0d, 0xfa, 0xfa, 0x14, 0x10, 0x02, 0x00, 0x0d, 0xff, 0xfd, 0x04, 0xfc, 0xeb, 0xf1, 0x0a, 0x01, 0x00, 0x05, 0x03, 0xf6, + 0xed, 0xf0, 0x05, 0xfa, 0xf8, 0x0b, 0x00, 0xf7, 0xfd, 0x0e, 0x05, 0xfc, 0xfb, 0xeb, 0xf6, 0x05, 0x07, 0xf5, 0xf6, 0x02, 0x02, 0xfa, + 0x03, 0x10, 0xee, 0xf0, 0xfe, 0xfa, 0xf6, 0xf8, 0x01, 0x08, 0x00, 0xf9, 0xff, 0x0a, 0x09, 0x08, 0x15, 0x00, 0xf6, 0x00, 0x12, 0xf2, + 0xee, 0x16, 0x0f, 0x05, 0xfd, 0xfa, 0xee, 0x02, 0x19, 0x01, 0xfb, 0x00, 0x01, 0x00, 0xf5, 0xf6, 0x11, 0x06, 0xfc, 0x00, 0x02, 0xf8, + 0xf8, 0x05, 0x02, 0x01, 0x08, 0x13, 0x10, 0x02, 0xf5, 0xfe, 0xf8, 0xfa, 0x0b, 0xfb, 0xfd, 0x07, 0xf4, 0xfd, 0x07, 0x03, 0xeb, 0xfe, + 0x08, 0xe8, 0xf3, 0x03, 0x09, 0x0b, 0xfd, 0xf8, 0x03, 0x00, 0xfe, 0x00, 0x06, 0xee, 0xf6, 0x11, 0x05, 0x06, 0x04, 0xf7, 0xf4, 0xf1, + 0xf6, 0x07, 0xfe, 0xfa, 0xfe, 0xfb, 0xee, 0xf1, 0x04, 0xfc, 0xfc, 0x03, 0x06, 0xff, 0xfa, 0xfd, 0x08, 0x03, 0x01, 0x0c, 0xff, 0xfd, + 0x02, 0xfe, 0x02, 0x03, 0xff, 0xfd, 0xff, 0x02, 0x00, 0x02, 0x00, 0x01, 0x12, 0x07, 0xf9, 0xfa, 0x07, 0x01, 0xfc, 0x0a, 0xfd, 0xfe, + 0x0c, 0x07, 0x04, 0xff, 0xf9, 0xfb, 0x08, 0x0c, 0xfd, 0xf8, 0xff, 0x07, 0x06, 0xfc, 0xf8, 0xff, 0xf5, 0xf6, 0xfb, 0xfb, 0xf5, 0xf6, + 0xff, 0x15, 0xfe, 0xf2, 0x0b, 0x03, 0xed, 0xe9, 0x0b, 0xfd, 0xfc, 0x11, 0x12, 0x00, 0xfa, 0x09, 0xf9, 0xf3, 0xfb, 0x01, 0xfd, 0xfd, + 0x03, 0x06, 0xfd, 0xf8, 0xff, 0x04, 0xfe, 0xf9, 0x06, 0xf9, 0xf5, 0x04, 0x03, 0x0c, 0x0e, 0xf8, 0x07, 0x01, 0xee, 0x01, 0x0e, 0x0b, + 0x01, 0xfe, 0x02, 0x05, 0xfd, 0x00, 0xfe, 0xf9, 0xef, 0x07, 0x0c, 0xee, 0xf7, 0x09, 0x10, 0x03, 0xff, 0xfd, 0xfd, 0xfd, 0x03, 0x01, + 0xf5, 0xfd, 0x06, 0x06, 0x02, 0xfe, 0x03, 0x09, 0xf6, 0xf2, 0xfe, 0x09, 0xf6, 0xf5, 0x04, 0xfb, 0xfb, 0xf9, 0xf4, 0xe3, 0x06, 0x1b, + 0xf4, 0xfa, 0x0d, 0x0f, 0xf5, 0x05, 0x0e, 0xfc, 0x00, 0x05, 0x02, 0xf7, 0x08, 0x0f, 0x04, 0xef, 0x03, 0x0e, 0xfb, 0x02, 0x04, 0x00, + 0xfc, 0x03, 0x01, 0xf9, 0x00, 0xff, 0xf9, 0xf6, 0x15, 0x13, 0xf9, 0xee, 0x02, 0x0a, 0xfc, 0xf6, 0xff, 0x08, 0x03, 0xfd, 0xf9, 0xfc, + 0x01, 0xfc, 0xf5, 0xf6, 0xfa, 0x0a, 0x0e, 0x00, 0xfb, 0x03, 0x06, 0xf3, 0xf3, 0x00, 0x09, 0xf8, 0xf7, 0xfe, 0xfb, 0xff, 0x06, 0x08, + 0xf8, 0xfa, 0x00, 0xfe, 0xe7, 0xf5, 0x10, 0x0e, 0xf5, 0xf9, 0x13, 0x0a, 0x01, 0xfe, 0x03, 0xf6, 0x00, 0x0e, 0x0a, 0xfb, 0xfb, 0x06, + 0x02, 0xfa, 0xfd, 0x0b, 0xfb, 0xf2, 0xfd, 0x15, 0x09, 0xff, 0x08, 0x04, 0x0e, 0x0d, 0xf4, 0xf1, 0xfe, 0x07, 0xf9, 0x08, 0x13, 0x08, + 0xfb, 0xfd, 0x00, 0xf4, 0xfc, 0x01, 0xfe, 0xf6, 0x00, 0x07, 0x00, 0xff, 0xfd, 0xfd, 0x04, 0xfc, 0xfb, 0x02, 0x01, 0xfe, 0x01, 0x07, + 0xfd, 0xfc, 0xf9, 0xea, 0xef, 0xfc, 0x01, 0xfc, 0xf0, 0xf6, 0x0f, 0xfa, 0xf9, 0x04, 0xf8, 0xf6, 0xf9, 0xfc, 0x07, 0x01, 0xff, 0x0f, + 0x01, 0xfa, 0xfd, 0xfa, 0xf9, 0xf8, 0xf7, 0xff, 0x00, 0xfd, 0x00, 0xfd, 0x00, 0x02, 0xfc, 0xfc, 0xff, 0x02, 0x15, 0x08, 0xfa, 0x10, + 0x00, 0xf7, 0x01, 0x08, 0x03, 0x01, 0x0a, 0x0d, 0x0d, 0x05, 0xf9, 0xf2, 0xf8, 0x01, 0x01, 0xfd, 0xff, 0x07, 0xfc, 0xf9, 0x04, 0x12, + 0x02, 0xfd, 0x0a, 0x09, 0xf9, 0xf4, 0x06, 0x0d, 0x03, 0xf9, 0x04, 0xfe, 0xf6, 0xf8, 0xf9, 0xfc, 0x01, 0x01, 0xfb, 0xfd, 0xff, 0xee, + 0xf7, 0xff, 0xf8, 0x07, 0xfc, 0xf0, 0xfc, 0x14, 0x02, 0xe1, 0x04, 0x06, 0x01, 0x05, 0x04, 0xee, 0xeb, 0x13, 0x03, 0xf2, 0xfa, 0xf4, + 0xff, 0x03, 0xf6, 0xf6, 0x0a, 0x14, 0xfe, 0xfa, 0xff, 0x02, 0xfd, 0xfa, 0xfd, 0x07, 0x08, 0x09, 0x07, 0xfb, 0x0a, 0x0d, 0xfd, 0x05, + 0xfe, 0xfa, 0x08, 0x03, 0x0a, 0x11, 0xf6, 0xfb, 0x07, 0x06, 0xfd, 0xfd, 0x01, 0x00, 0x04, 0x05, 0x03, 0x0c, 0xfc, 0xfa, 0x0c, 0xf6, + 0xeb, 0xf7, 0x0d, 0xfe, 0xfc, 0x0c, 0x00, 0xf9, 0xfb, 0x01, 0xfd, 0x02, 0x04, 0xf4, 0xfb, 0x01, 0xfc, 0xf6, 0xfd, 0x04, 0x01, 0xf2, + 0x04, 0x13, 0xe1, 0x03, 0x12, 0xf1, 0xf7, 0x07, 0x09, 0xfc, 0xf7, 0xfe, 0x04, 0xf7, 0xf7, 0x05, 0x13, 0x02, 0xfd, 0xfe, 0xf5, 0x00, + 0x05, 0x00, 0x00, 0x06, 0x03, 0xf6, 0x06, 0x02, 0xf6, 0xf9, 0x08, 0x08, 0xfd, 0xfc, 0x0b, 0x0d, 0xf9, 0xf5, 0xfb, 0x04, 0x0a, 0x05, + 0xfc, 0xfb, 0x05, 0x08, 0x07, 0x08, 0xfe, 0xf7, 0xf6, 0xf4, 0xfe, 0xff, 0xfb, 0x10, 0x07, 0xf4, 0xfa, 0xf6, 0xfe, 0x06, 0xf7, 0xee, + 0xfe, 0x16, 0xfd, 0xfe, 0x07, 0xfd, 0xe7, 0xf3, 0x0c, 0x00, 0xf6, 0x00, 0x11, 0x00, 0xf1, 0xf3, 0x08, 0xf3, 0xef, 0xfe, 0xfc, 0xf1, + 0xff, 0x1f, 0x02, 0xfd, 0x0a, 0x02, 0x03, 0x02, 0xfc, 0x00, 0xfe, 0x05, 0x14, 0x0f, 0x07, 0x05, 0x04, 0x06, 0x01, 0xf8, 0xf5, 0x03, + 0x08, 0xf6, 0x03, 0x06, 0xff, 0x04, 0x00, 0x02, 0x07, 0xfa, 0xfa, 0x02, 0x02, 0x09, 0x08, 0x02, 0x01, 0x07, 0xfd, 0xea, 0x01, 0x09, + 0x02, 0xfd, 0x02, 0xfd, 0xf4, 0xfe, 0xfd, 0xfc, 0x01, 0xef, 0xf2, 0x02, 0x0b, 0xef, 0xf4, 0x11, 0xf8, 0xed, 0xf8, 0x0b, 0xfa, 0xfb, + 0x04, 0xf6, 0xfe, 0xff, 0xf6, 0x03, 0x07, 0x00, 0xfa, 0xf9, 0xfc, 0x01, 0x00, 0x09, 0x06, 0xfb, 0x05, 0x0b, 0x01, 0xf1, 0xf6, 0x07, + 0x11, 0x0c, 0xf7, 0xf4, 0x07, 0x06, 0x05, 0x01, 0xf9, 0xfe, 0x06, 0x0a, 0x05, 0x01, 0xfc, 0xf7, 0xff, 0x07, 0x09, 0x04, 0x03, 0xff, + 0xfc, 0x02, 0x0d, 0x0c, 0xfc, 0xf4, 0xfc, 0x05, 0xfe, 0x07, 0x04, 0xf7, 0x00, 0xff, 0xfc, 0xfe, 0xfc, 0xf9, 0xf9, 0xff, 0xfd, 0xfd, + 0x02, 0x09, 0x00, 0xf6, 0xfb, 0xf7, 0xf4, 0xfd, 0x1c, 0xfb, 0xea, 0x04, 0xfc, 0xf4, 0xfa, 0x08, 0xff, 0xf1, 0xef, 0xfe, 0x05, 0x04, + 0x02, 0xff, 0x00, 0x02, 0x03, 0xf9, 0xfb, 0x06, 0x07, 0xf3, 0xf6, 0x17, 0x06, 0xfd, 0xff, 0xf9, 0xf8, 0xfe, 0x04, 0x06, 0xfe, 0xf8, + 0xfe, 0x06, 0x04, 0x00, 0x0e, 0xfb, 0xf9, 0x0d, 0x04, 0x00, 0x01, 0xff, 0x07, 0x08, 0x01, 0x05, 0xff, 0xfe, 0x03, 0x06, 0xfe, 0xfb, + 0x0a, 0xfe, 0xf9, 0x02, 0x0f, 0xff, 0xf7, 0x06, 0xfb, 0xfd, 0x05, 0xff, 0xfc, 0xfc, 0xfe, 0x05, 0xfd, 0xf5, 0xf6, 0xfb, 0xf9, 0xf6, + 0xf9, 0xfc, 0xfb, 0xf8, 0xf6, 0x02, 0x05, 0xf6, 0xf9, 0xfa, 0xfa, 0x03, 0x01, 0xf8, 0xf4, 0x0a, 0x01, 0xfc, 0x16, 0x03, 0xf4, 0xf7, + 0x06, 0xf6, 0xed, 0xfb, 0x13, 0x02, 0xf0, 0x03, 0x08, 0xf9, 0xeb, 0x06, 0xf7, 0xf4, 0x0d, 0x07, 0x02, 0x04, 0x04, 0x04, 0x0f, 0x16, + 0xfe, 0x03, 0x07, 0xf9, 0xfc, 0x0b, 0x13, 0x03, 0x06, 0x01, 0xf8, 0x03, 0x07, 0xff, 0xf4, 0xfa, 0x01, 0x03, 0xfe, 0x15, 0x11, 0xf5, + 0x05, 0xf7, 0xec, 0x00, 0xfe, 0x01, 0x08, 0x03, 0xfc, 0xfa, 0xfe, 0xfb, 0xff, 0xff, 0xf6, 0x01, 0x00, 0xfb, 0x0e, 0x04, 0xfc, 0x03, + 0x06, 0xfe, 0xf7, 0xf9, 0xff, 0xfd, 0xf7, 0xfa, 0x02, 0x03, 0xfb, 0x07, 0x02, 0xf8, 0xfd, 0x0b, 0x0a, 0x01, 0x0f, 0xff, 0xf0, 0xf7, + 0x05, 0x0b, 0x08, 0x07, 0xfd, 0xf7, 0xfa, 0x01, 0x01, 0xfd, 0xfb, 0xfd, 0x00, 0x02, 0x02, 0xf8, 0xf5, 0xff, 0x05, 0x09, 0x04, 0xfa, + 0xff, 0x04, 0x04, 0x06, 0x06, 0x01, 0xfc, 0x07, 0x00, 0xf7, 0x03, 0xfa, 0x05, 0x18, 0x07, 0xf8, 0xf7, 0x03, 0xfe, 0x02, 0x03, 0xf7, + 0xfb, 0x01, 0x02, 0x05, 0xfa, 0xfa, 0x0a, 0x02, 0xfe, 0xfd, 0xf4, 0x06, 0x08, 0xf7, 0xf5, 0x06, 0x10, 0x05, 0xf0, 0xf2, 0x00, 0xfb, + 0xfb, 0x04, 0x0d, 0xfd, 0xfd, 0x01, 0xfb, 0xf3, 0xfd, 0x06, 0xf4, 0xf9, 0x03, 0x04, 0xff, 0x04, 0x08, 0x00, 0x03, 0xfe, 0xf7, 0xfc, + 0xfe, 0xfc, 0xfe, 0x00, 0x08, 0x09, 0xfd, 0x04, 0x03, 0xfa, 0x00, 0xf8, 0xfa, 0x0b, 0x02, 0x03, 0x06, 0xf8, 0xf5, 0xfa, 0xfe, 0xf5, + 0x01, 0x09, 0xfd, 0x01, 0x02, 0xff, 0x01, 0xf9, 0xf8, 0xfe, 0xfd, 0xf8, 0xff, 0x10, 0x01, 0xf8, 0xff, 0x08, 0x03, 0xff, 0x02, 0xfa, + 0xfd, 0x00, 0xfb, 0xfd, 0x03, 0x05, 0xfd, 0xff, 0xfe, 0xf8, 0x04, 0x02, 0xf9, 0xfd, 0xf5, 0xf6, 0xff, 0x04, 0xf8, 0xf8, 0x08, 0xfd, + 0xf6, 0xfb, 0x09, 0xfd, 0x02, 0x15, 0x00, 0x00, 0x04, 0xfd, 0xf9, 0x07, 0x11, 0xfd, 0xff, 0xff, 0xf7, 0x04, 0x00, 0xff, 0x0d, 0x0a, + 0x01, 0xfd, 0xfb, 0x02, 0xfd, 0xef, 0xfe, 0x00, 0xfc, 0x01, 0x07, 0x01, 0xf9, 0x00, 0xf9, 0xf7, 0x03, 0x00, 0x02, 0x04, 0xfd, 0xf6, + 0xf6, 0xfd, 0x0b, 0x01, 0xf5, 0xf8, 0xfb, 0xf4, 0xf3, 0x07, 0x05, 0x02, 0x03, 0xfd, 0xf3, 0xfa, 0x0f, 0xf2, 0xf6, 0x0c, 0x03, 0x05, + 0x0b, 0x0a, 0x05, 0x01, 0x02, 0x05, 0xff, 0xf3, 0xef, 0x01, 0xfe, 0xfe, 0x09, 0x03, 0x00, 0xfe, 0xfb, 0xfd, 0x01, 0x03, 0x07, 0xff, + 0xfe, 0x06, 0x05, 0xfe, 0x00, 0x11, 0x01, 0xf3, 0xf6, 0x02, 0x03, 0x06, 0x0e, 0x00, 0xff, 0x03, 0xf9, 0xfd, 0x01, 0xff, 0xfd, 0xfa, + 0xfb, 0x03, 0xfe, 0x0a, 0x13, 0xff, 0xfa, 0xf8, 0xf5, 0xf9, 0xff, 0x04, 0x07, 0xf8, 0xfa, 0x04, 0x00, 0xf9, 0xfc, 0x02, 0xee, 0xfb, + 0x07, 0xf5, 0xfa, 0xf8, 0xf4, 0xfd, 0x07, 0x06, 0xfd, 0xf9, 0xfd, 0x01, 0xfe, 0x00, 0x01, 0x04, 0x16, 0x06, 0xf9, 0x05, 0x0a, 0x07, + 0x02, 0x04, 0xf4, 0xf8, 0x07, 0xfe, 0xfe, 0x05, 0x06, 0x05, 0xf6, 0xef, 0x05, 0x00, 0x02, 0x08, 0xf5, 0xf9, 0x09, 0x0e, 0x0a, 0xf9, + 0xf3, 0x0c, 0x06, 0xf7, 0xf5, 0x05, 0x05, 0x01, 0x05, 0x0b, 0xfe, 0xef, 0xf5, 0x05, 0x03, 0xf2, 0x09, 0x08, 0xff, 0x03, 0x05, 0xfd, + 0xf8, 0x02, 0x04, 0xfc, 0xf4, 0xef, 0xfa, 0x07, 0x05, 0xfe, 0x02, 0x08, 0xf1, 0xfd, 0x03, 0xf1, 0x00, 0x02, 0xfb, 0xfb, 0x0f, 0x0e, + 0xfa, 0x00, 0xfc, 0xf2, 0xee, 0x09, 0x09, 0xfd, 0x0b, 0x09, 0xfd, 0xf7, 0x0b, 0x00, 0xf8, 0x0c, 0xfc, 0xfb, 0x09, 0x09, 0x04, 0xff, + 0xff, 0x08, 0x0a, 0x01, 0xf5, 0x06, 0x07, 0xfc, 0x02, 0x0a, 0x09, 0xfd, 0xfa, 0xf5, 0xfa, 0x09, 0x00, 0xf7, 0xfa, 0x04, 0xff, 0xfc, + 0x04, 0x04, 0x06, 0x06, 0xfa, 0xfd, 0xfa, 0xf5, 0x07, 0x0a, 0xfe, 0xf1, 0xfd, 0x02, 0xfb, 0xf5, 0x01, 0x02, 0xf6, 0x04, 0xf7, 0xef, + 0x01, 0xfc, 0xf9, 0xff, 0x06, 0x05, 0x04, 0x05, 0xfc, 0xfe, 0x06, 0x08, 0x03, 0x02, 0x02, 0xfd, 0xfd, 0xff, 0xfe, 0x01, 0xf9, 0xf2, + 0xfb, 0xff, 0x01, 0x00, 0xfc, 0x05, 0x06, 0xfb, 0xf8, 0x08, 0x10, 0xfc, 0x02, 0x01, 0xf8, 0xff, 0x09, 0x0d, 0x09, 0x05, 0x02, 0xfc, + 0xf1, 0xfb, 0x01, 0xff, 0x04, 0x06, 0x02, 0xfa, 0xfc, 0xff, 0xfc, 0xef, 0x08, 0x10, 0xff, 0x04, 0x09, 0x07, 0xfc, 0x08, 0x03, 0xf4, + 0xf9, 0xfd, 0xff, 0xff, 0xf8, 0xff, 0x07, 0x03, 0xf2, 0xee, 0xf6, 0xff, 0xf4, 0xfc, 0x14, 0xfd, 0xec, 0xf3, 0x0e, 0x07, 0x03, 0x08, + 0x01, 0xfd, 0xfe, 0x00, 0x00, 0x01, 0x02, 0x03, 0xfd, 0xf7, 0xf7, 0xff, 0x00, 0xfc, 0xfb, 0x01, 0x01, 0xfc, 0xfa, 0x00, 0x07, 0x07, + 0xff, 0xff, 0x02, 0x03, 0xfd, 0x03, 0x0a, 0xfb, 0x08, 0x0d, 0xff, 0xf3, 0x01, 0x0c, 0xfe, 0xf8, 0xfe, 0x05, 0xfa, 0x04, 0x08, 0xfd, + 0x03, 0x02, 0x00, 0x09, 0xf5, 0xf6, 0x0c, 0x13, 0x02, 0xfc, 0x09, 0xfd, 0xf7, 0xfe, 0x0d, 0xf9, 0xf7, 0x07, 0xfd, 0xf0, 0xf6, 0x0c, + 0x12, 0xfd, 0xe9, 0xf3, 0x06, 0x02, 0xed, 0xfd, 0xf6, 0xfd, 0x1d, 0x03, 0xed, 0xf3, 0x00, 0xfd, 0xf6, 0xf5, 0xf8, 0xfa, 0xfd, 0x05, + 0xea, 0xf9, 0x15, 0xf9, 0xe3, 0xf0, 0x0e, 0x02, 0xf4, 0xf8, 0x0c, 0x0c, 0x06, 0x02, 0x07, 0xf9, 0xfa, 0x0f, 0x02, 0xf6, 0xfb, 0x11, + 0xfe, 0x01, 0x14, 0xf5, 0xee, 0xfa, 0x06, 0xf8, 0xfd, 0x0a, 0x06, 0x02, 0x04, 0x09, 0x0a, 0x05, 0x02, 0x04, 0xf7, 0xfb, 0x0b, 0x0d, + 0x02, 0xf7, 0xf5, 0x0a, 0x02, 0xf8, 0x08, 0x04, 0xff, 0xfe, 0xf8, 0x04, 0x02, 0xee, 0xff, 0x06, 0x06, 0x05, 0x17, 0x0b, 0xf1, 0x01, + 0x02, 0xff, 0x02, 0x02, 0xfe, 0xfa, 0xfc, 0xf4, 0xfa, 0x04, 0xf6, 0xf3, 0xf8, 0xfb, 0x07, 0xff, 0xf4, 0x00, 0x0d, 0x07, 0xf9, 0x09, + 0xff, 0xf5, 0xfc, 0xfa, 0xfb, 0xfe, 0xfc, 0x02, 0x00, 0xf7, 0x00, 0xf5, 0xee, 0xfc, 0x06, 0xff, 0xf5, 0xfc, 0x04, 0x0b, 0x0c, 0xff, + 0xfd, 0x02, 0x00, 0x08, 0x05, 0x00, 0x0f, 0x04, 0xf6, 0xf9, 0x01, 0x05, 0x01, 0xfb, 0xf6, 0xf1, 0xf2, 0x01, 0x08, 0x07, 0x03, 0xfe, + 0x04, 0x08, 0xfc, 0x06, 0x0a, 0x02, 0xfa, 0xff, 0x0b, 0x14, 0x05, 0x01, 0x04, 0x00, 0xff, 0x08, 0x0c, 0xf4, 0xec, 0xfa, 0x0a, 0x0f, + 0x01, 0xf5, 0xfe, 0x07, 0x04, 0xfb, 0x0b, 0x03, 0xf6, 0xf9, 0x02, 0x01, 0xfa, 0xf9, 0x03, 0x04, 0xf8, 0xfd, 0xfb, 0xf8, 0xfd, 0x00, + 0xff, 0xfe, 0x01, 0xff, 0xff, 0x01, 0xf6, 0xf9, 0xff, 0xf3, 0x04, 0x0a, 0x00, 0x02, 0x00, 0xfe, 0xff, 0xff, 0x00, 0xfe, 0xf9, 0xfe, + 0x06, 0x07, 0xf8, 0xf9, 0x06, 0x0e, 0xf5, 0xfb, 0x0e, 0xf9, 0xf9, 0xff, 0x00, 0xfc, 0x02, 0x0a, 0x0e, 0xf4, 0xf5, 0x05, 0xf7, 0x00, + 0x03, 0xf9, 0x03, 0x01, 0xfb, 0x02, 0x01, 0x01, 0x04, 0x07, 0x01, 0xfc, 0xfc, 0x03, 0x0a, 0x07, 0xf5, 0x06, 0x13, 0x09, 0xf9, 0xfa, + 0xff, 0xff, 0xfd, 0x04, 0x05, 0xef, 0xff, 0x07, 0xfb, 0xf6, 0xfc, 0x00, 0xfc, 0xfc, 0x04, 0x09, 0xf9, 0x0b, 0x0e, 0xfa, 0xf9, 0xfe, + 0x02, 0x04, 0x03, 0x01, 0xfd, 0xfb, 0xf8, 0x05, 0x17, 0xfa, 0xf4, 0xf7, 0xe8, 0xfd, 0x02, 0xf8, 0xff, 0x06, 0x01, 0xf4, 0xfc, 0xfb, + 0xfb, 0x09, 0x08, 0x04, 0x00, 0xf5, 0xfd, 0x06, 0x04, 0x08, 0x05, 0xfa, 0xe9, 0xfb, 0x00, 0xf3, 0xf8, 0x00, 0x04, 0x00, 0x01, 0x03, + 0x01, 0xf7, 0x06, 0x0a, 0xfe, 0xff, 0xfa, 0xfa, 0x04, 0x02, 0x04, 0x08, 0x05, 0xf5, 0xf8, 0x0c, 0xfe, 0xf7, 0xff, 0x09, 0xfe, 0xef, + 0xee, 0x03, 0x06, 0x05, 0x0b, 0x02, 0x00, 0x01, 0xfe, 0xfe, 0x08, 0x11, 0x08, 0xfa, 0xf7, 0x01, 0x06, 0x07, 0x01, 0xfb, 0xf7, 0x02, + 0x0c, 0xf3, 0xfd, 0x0a, 0x00, 0xf2, 0xf9, 0x06, 0xff, 0xfc, 0xfb, 0xff, 0x0a, 0x01, 0xf6, 0xfb, 0x07, 0x05, 0xfb, 0x00, 0xfe, 0x03, + 0x0a, 0xf3, 0xf0, 0x00, 0x0f, 0x01, 0x00, 0x04, 0xea, 0xf1, 0xfe, 0xfd, 0x0b, 0x09, 0xff, 0xfd, 0xfd, 0xf9, 0xf8, 0x0a, 0xff, 0xf7, + 0x01, 0xff, 0xf7, 0xf6, 0x03, 0x06, 0x05, 0x04, 0x01, 0xff, 0xf6, 0xe8, 0x05, 0x06, 0xf7, 0x01, 0x05, 0x04, 0x03, 0x05, 0xfd, 0xf6, + 0xfb, 0xf7, 0xfd, 0x07, 0x0c, 0xfc, 0xfc, 0x0b, 0xfd, 0xf1, 0xf6, 0x09, 0xff, 0x04, 0x0e, 0xfa, 0xfc, 0x07, 0x08, 0xf4, 0xfc, 0x09, + 0xfc, 0x09, 0x08, 0xf8, 0xf9, 0x02, 0x05, 0x02, 0x13, 0x08, 0xf3, 0xfa, 0xf4, 0xfd, 0x0d, 0x04, 0xf9, 0xf5, 0xfb, 0x18, 0x0f, 0xf8, + 0x06, 0x03, 0xfd, 0xf8, 0xfb, 0xf3, 0xfc, 0x15, 0x0d, 0xfa, 0xf9, 0x16, 0xff, 0xee, 0xfc, 0xfd, 0x08, 0x02, 0xe6, 0xfe, 0x0f, 0x06, + 0xf5, 0x04, 0x09, 0xf7, 0xf0, 0xfc, 0x03, 0xf5, 0x06, 0x0b, 0x00, 0x00, 0xfa, 0xf4, 0xf3, 0xff, 0xf3, 0xe7, 0xfc, 0xf5, 0xfe, 0x12, + 0x10, 0xf5, 0xe6, 0xf5, 0xfc, 0x02, 0x03, 0xfb, 0x08, 0x03, 0xf4, 0x0f, 0x10, 0x02, 0xfa, 0x00, 0x02, 0x02, 0x05, 0x0b, 0x01, 0xf2, + 0x03, 0x04, 0x04, 0x11, 0x0b, 0x00, 0xf8, 0xf7, 0xfe, 0x07, 0x0c, 0x11, 0x02, 0xfb, 0x0d, 0xf7, 0xf5, 0x08, 0x08, 0x03, 0xfd, 0xfe, + 0x0d, 0x0c, 0x03, 0x05, 0xf1, 0xf4, 0x07, 0x03, 0xf8, 0xfe, 0x10, 0xf0, 0xf2, 0x09, 0x0b, 0xfa, 0x05, 0x19, 0xed, 0xf1, 0x01, 0xfc, + 0xff, 0x01, 0x03, 0x0b, 0xf1, 0xec, 0x05, 0x08, 0x01, 0xf2, 0xe4, 0xf6, 0x05, 0x00, 0xf1, 0xfc, 0xfb, 0xed, 0x05, 0x04, 0xf8, 0xf8, + 0xf8, 0xfe, 0x04, 0x00, 0x09, 0x06, 0xf6, 0x07, 0x0b, 0x00, 0xf6, 0xfe, 0x0c, 0x0c, 0xf5, 0xf7, 0x04, 0x0a, 0x09, 0x0d, 0x0a, 0xf7, + 0xf1, 0xf4, 0xfd, 0x04, 0x0e, 0x12, 0x0d, 0xf6, 0x02, 0x16, 0x02, 0xf7, 0xf6, 0xfc, 0x03, 0x0b, 0x08, 0xfe, 0x0a, 0x08, 0xfb, 0xfd, + 0xf5, 0xfc, 0x0e, 0x07, 0xfe, 0xf8, 0xf4, 0x02, 0x0b, 0x06, 0xfe, 0xfa, 0xfc, 0xfe, 0xf6, 0xff, 0x05, 0xf8, 0x06, 0x0b, 0x02, 0xfa, + 0xfc, 0xff, 0xfb, 0xf4, 0xf1, 0xfb, 0x10, 0xf7, 0xea, 0xf9, 0x02, 0x06, 0x00, 0xf9, 0xef, 0xfc, 0x08, 0xfa, 0xf9, 0xfa, 0xfb, 0x12, + 0xff, 0xee, 0xff, 0x04, 0x07, 0x04, 0xf2, 0x09, 0x0c, 0xf3, 0xfd, 0x04, 0x09, 0x12, 0xf1, 0xf9, 0x12, 0xed, 0xf4, 0x03, 0x06, 0x12, + 0x10, 0x00, 0xf4, 0xf0, 0xfa, 0x07, 0xfd, 0x13, 0x10, 0xee, 0xf8, 0x07, 0x0b, 0x05, 0x08, 0x04, 0xfc, 0xfd, 0xfa, 0xfe, 0x0a, 0xff, + 0xff, 0x01, 0xf6, 0x03, 0x0a, 0x00, 0xf2, 0xf7, 0x00, 0xfe, 0xf9, 0xfb, 0x05, 0x0d, 0x09, 0xfa, 0xf1, 0x05, 0x03, 0xfa, 0x01, 0x00, + 0xfe, 0x02, 0x11, 0xfe, 0xed, 0xf2, 0xf6, 0x01, 0x02, 0xf3, 0xf7, 0xf9, 0xf9, 0xff, 0x04, 0x03, 0x02, 0xf7, 0x05, 0x0d, 0xf7, 0xf6, + 0x05, 0x0f, 0x08, 0xfb, 0xfd, 0x0d, 0xfd, 0x01, 0x0c, 0x05, 0xf3, 0xf7, 0x08, 0xf3, 0x08, 0x19, 0x07, 0xef, 0xf7, 0x05, 0xf8, 0xf8, + 0x06, 0x13, 0x02, 0xff, 0x06, 0x0d, 0xeb, 0xf7, 0x13, 0xf9, 0xf4, 0xfd, 0x03, 0x00, 0xfd, 0x02, 0x10, 0xf6, 0xf2, 0x04, 0xfd, 0x04, + 0xfe, 0xec, 0xfd, 0x04, 0xfc, 0xf3, 0x01, 0x01, 0xf7, 0x03, 0x00, 0xf9, 0xf8, 0xfe, 0x00, 0xff, 0xfd, 0x05, 0x04, 0xf8, 0xf9, 0xf0, + 0xf9, 0x14, 0x08, 0xfa, 0xf8, 0xfa, 0x02, 0x03, 0xff, 0x03, 0x05, 0x05, 0x03, 0xfa, 0xf8, 0xfe, 0x01, 0x10, 0x11, 0x04, 0x00, 0x01, + 0x04, 0x05, 0xfb, 0xff, 0x08, 0xf9, 0x00, 0x07, 0x03, 0x0b, 0x0a, 0x02, 0xfc, 0xf7, 0xfc, 0x06, 0x0a, 0x00, 0x02, 0x0e, 0xfa, 0xe5, + 0xed, 0x13, 0x12, 0x04, 0xfe, 0x09, 0xfb, 0xf3, 0xff, 0x04, 0x04, 0x06, 0x11, 0xfa, 0xf5, 0x02, 0xf1, 0xee, 0xf6, 0xff, 0xff, 0x04, + 0x05, 0xf8, 0xf7, 0xfd, 0xfe, 0xe9, 0xf2, 0x04, 0x05, 0xf7, 0xf5, 0xff, 0x01, 0x07, 0x09, 0x04, 0xff, 0xf9, 0xf7, 0xf8, 0x00, 0xff, + 0xf9, 0xfc, 0xfd, 0x05, 0x0d, 0xfc, 0xf5, 0xf9, 0xfb, 0xfd, 0x01, 0x07, 0x0d, 0x13, 0x0e, 0x01, 0xee, 0xf4, 0x07, 0x0e, 0x02, 0xfd, + 0x03, 0xff, 0x02, 0x05, 0x01, 0x06, 0x03, 0xf8, 0xf0, 0xfa, 0x04, 0x05, 0xff, 0x05, 0x0d, 0x0b, 0xf5, 0xfe, 0x0f, 0xf4, 0x04, 0x12, + 0x07, 0xf8, 0xf9, 0x01, 0x01, 0x0b, 0x0c, 0x02, 0xf1, 0x01, 0x01, 0xe8, 0xf7, 0x06, 0x0b, 0x07, 0x01, 0xff, 0xfd, 0xf3, 0xf5, 0xfd, + 0x02, 0x15, 0x09, 0xf4, 0xfa, 0x00, 0x00, 0xfc, 0xf9, 0xfd, 0x02, 0x00, 0xf1, 0xf4, 0xfd, 0xf1, 0x07, 0x07, 0xf0, 0x08, 0x08, 0xf7, + 0xeb, 0xfe, 0xfd, 0xf3, 0xfe, 0x0e, 0x0b, 0xfa, 0x03, 0xfd, 0xf6, 0xfe, 0x05, 0x01, 0xfd, 0x0a, 0x00, 0xf8, 0x00, 0xf9, 0x00, 0x06, + 0xfc, 0xfc, 0x08, 0x0c, 0xef, 0xfe, 0x0b, 0xfe, 0x11, 0x08, 0xf5, 0xf9, 0x03, 0xfe, 0xf4, 0x04, 0x06, 0x01, 0x00, 0x0e, 0x05, 0xfa, + 0x0d, 0x04, 0xfe, 0x03, 0x01, 0xfc, 0x00, 0x08, 0x07, 0xfa, 0xf5, 0x09, 0x0c, 0xff, 0xf3, 0x01, 0x03, 0x00, 0x03, 0x0b, 0xfa, 0xe7, + 0xfc, 0x07, 0xfe, 0xef, 0x15, 0x04, 0xeb, 0x03, 0x04, 0xfd, 0xfd, 0x06, 0x03, 0xfb, 0xf6, 0xf9, 0xfb, 0xfd, 0x01, 0xfc, 0xfe, 0x04, + 0xfb, 0xf7, 0xfc, 0x06, 0xfd, 0xfe, 0xfe, 0xed, 0x05, 0x1a, 0x0e, 0xe3, 0xf1, 0x0e, 0x0d, 0xf8, 0xfc, 0x10, 0x11, 0xfe, 0xf7, 0x03, + 0xf7, 0xf6, 0x00, 0x0c, 0xf2, 0xfa, 0x0e, 0xf1, 0xf5, 0x05, 0x0a, 0xf5, 0xfd, 0x0b, 0x02, 0x00, 0x00, 0x01, 0xfe, 0x04, 0x07, 0x02, + 0xf7, 0xfd, 0x07, 0x02, 0xf7, 0xfe, 0x0c, 0x05, 0xf8, 0xf1, 0xf6, 0x03, 0x07, 0x03, 0x00, 0x02, 0x04, 0x04, 0xfa, 0x0e, 0x11, 0xf1, + 0xf4, 0x03, 0x0a, 0x02, 0x06, 0x09, 0x04, 0xf7, 0xfc, 0xff, 0xf3, 0x00, 0x08, 0x00, 0xef, 0xfb, 0x03, 0xfb, 0xf8, 0x01, 0x06, 0xfc, + 0xfa, 0x02, 0x07, 0xf0, 0x01, 0x0d, 0x00, 0xf1, 0x01, 0x11, 0x00, 0xf5, 0xfb, 0x08, 0xfd, 0xff, 0xff, 0xf8, 0xfe, 0x06, 0x02, 0xf5, + 0xf9, 0x03, 0x05, 0xf6, 0xfa, 0x05, 0x08, 0xf9, 0xf9, 0x02, 0x03, 0xfb, 0xfe, 0x08, 0x03, 0xf7, 0xfa, 0x0e, 0xfa, 0xfa, 0x07, 0xfc, + 0xfe, 0x05, 0x09, 0x00, 0x00, 0x04, 0x03, 0x00, 0x02, 0x02, 0xf9, 0xfc, 0x07, 0x0d, 0xfb, 0xf9, 0x01, 0x02, 0x02, 0xff, 0xff, 0x09, + 0x03, 0xfa, 0xfb, 0xf8, 0xfc, 0x03, 0x09, 0xfe, 0xfe, 0x05, 0xf6, 0xf8, 0x04, 0x0c, 0x02, 0x02, 0x00, 0xec, 0xf5, 0x03, 0x04, 0xf8, + 0xfa, 0x03, 0x05, 0xf8, 0xfc, 0x07, 0xfd, 0xfd, 0x01, 0x03, 0x03, 0x00, 0xfc, 0xfb, 0xfc, 0x02, 0x07, 0x04, 0xff, 0xfd, 0xff, 0x04, + 0xff, 0xfb, 0x01, 0x01, 0xff, 0xfe, 0xfd, 0xff, 0x00, 0x00, 0xfe, 0x02, 0x05, 0x01, 0x00, 0x04, 0x08, 0x03, 0x04, 0x05, 0x02, 0xf6, + 0xfd, 0x06, 0xfd, 0xfc, 0xfe, 0xff, 0xff, 0xf7, 0xfb, 0x0d, 0xf7, 0xf0, 0xfc, 0x01, 0x06, 0x02, 0xfa, 0xf7, 0x03, 0x09, 0xff, 0x03, + 0x0d, 0x0e, 0xf9, 0xfa, 0xfb, 0xf5, 0xfd, 0x05, 0x06, 0xff, 0x01, 0xfd, 0xf7, 0xf7, 0xff, 0x06, 0x07, 0xfd, 0x00, 0x01, 0xf6, 0xf7, + 0xff, 0x07, 0x0a, 0x05, 0x04, 0x09, 0xf5, 0xf8, 0x04, 0x00, 0x06, 0x0a, 0x05, 0xfa, 0xf5, 0xf5, 0xf7, 0x05, 0x05, 0xfb, 0xf8, 0x06, + 0x06, 0xf8, 0x09, 0x07, 0x00, 0x04, 0x03, 0x01, 0xfe, 0xf9, 0xff, 0x03, 0x01, 0x03, 0x05, 0x01, 0xf9, 0x03, 0x05, 0xfc, 0xf5, 0xfc, + 0xfb, 0xf1, 0x01, 0x02, 0xfb, 0xf9, 0x04, 0xfd, 0xf1, 0x00, 0x09, 0x07, 0x01, 0x01, 0xfd, 0xfb, 0x03, 0x00, 0xfd, 0xfd, 0xf1, 0xf7, + 0x00, 0x00, 0x01, 0x0c, 0x0e, 0xfb, 0xf6, 0xfe, 0x05, 0x01, 0xf9, 0xf9, 0x04, 0x0b, 0x08, 0xff, 0xfb, 0xfa, 0x01, 0x09, 0x05, 0xfc, + 0xfd, 0x09, 0xf7, 0xf5, 0x02, 0x00, 0x02, 0x04, 0x01, 0xf3, 0xf8, 0x05, 0x0b, 0x05, 0x03, 0x06, 0xff, 0xff, 0xfe, 0xfb, 0xfd, 0x02, + 0x01, 0xf6, 0xfe, 0x00, 0xfb, 0xff, 0x03, 0x06, 0x06, 0x02, 0xfa, 0xf8, 0x03, 0xfd, 0xf8, 0xfe, 0x0b, 0x01, 0xf8, 0x00, 0x07, 0x01, + 0xf7, 0xf6, 0xfd, 0xff, 0xfa, 0x05, 0xfd, 0xf6, 0xff, 0x01, 0xfa, 0xf5, 0xf9, 0x06, 0x09, 0x01, 0xfb, 0x01, 0x05, 0xfc, 0xfc, 0x05, + 0x08, 0xef, 0xff, 0x08, 0xf6, 0xf2, 0x04, 0x0e, 0xfd, 0x01, 0x03, 0xfb, 0xec, 0xf7, 0x05, 0x06, 0xf8, 0x02, 0x0d, 0xf9, 0xfc, 0x0c, + 0x16, 0x07, 0xfd, 0xfa, 0xfd, 0xfe, 0x08, 0x0d, 0x01, 0xfd, 0xfe, 0xfd, 0xf9, 0xf8, 0xfd, 0x07, 0xfc, 0xf8, 0x01, 0x09, 0xff, 0xfe, + 0x0b, 0x04, 0xfc, 0xfa, 0xfd, 0xff, 0x03, 0x08, 0x05, 0x0c, 0x0a, 0xfb, 0xfb, 0xfb, 0xf9, 0xf8, 0x02, 0x06, 0xff, 0xf6, 0xf3, 0xfa, + 0x05, 0x06, 0xff, 0xfa, 0xfc, 0xfd, 0xff, 0x03, 0xfd, 0x05, 0x07, 0xfa, 0xfd, 0x01, 0x01, 0xfc, 0xff, 0xfc, 0xf7, 0xff, 0x06, 0xfe, + 0xec, 0xfd, 0x03, 0xfc, 0xfe, 0xff, 0xfc, 0xf7, 0x01, 0xfe, 0xfd, 0x08, 0x0e, 0xfc, 0xed, 0x06, 0x0d, 0x02, 0xf7, 0x02, 0x06, 0x00, + 0xfa, 0x01, 0x05, 0x01, 0x06, 0xf7, 0xf4, 0x06, 0x0c, 0x03, 0xfb, 0x02, 0x04, 0x00, 0xfd, 0x02, 0x07, 0x0c, 0x0d, 0xf8, 0xf8, 0x04, + 0x04, 0xff, 0x04, 0x0e, 0x07, 0xfe, 0xfa, 0xfd, 0xfe, 0x00, 0x00, 0xff, 0x00, 0x03, 0x03, 0xf7, 0xf9, 0x04, 0x0b, 0x03, 0xfe, 0xfe, + 0xf7, 0xf4, 0xf7, 0xfe, 0xf8, 0x07, 0x0d, 0xf4, 0xf7, 0xfe, 0xfd, 0xee, 0xfb, 0x05, 0xff, 0xfd, 0xff, 0x01, 0x00, 0xfe, 0x01, 0x02, + 0xfc, 0xf8, 0xfb, 0x02, 0xfd, 0xfc, 0x00, 0x02, 0xf6, 0xf9, 0x09, 0x04, 0x00, 0xfa, 0xf4, 0xf9, 0x02, 0x09, 0x0c, 0x0a, 0x03, 0xfb, + 0xf9, 0xfe, 0x07, 0x0b, 0xff, 0xfc, 0x04, 0x08, 0x04, 0xff, 0xff, 0x02, 0x01, 0xff, 0xfe, 0xf7, 0xf8, 0x00, 0x02, 0x0a, 0x0c, 0x06, + 0x01, 0x03, 0x01, 0xf5, 0xf8, 0xff, 0x06, 0x0e, 0x0c, 0x01, 0xf8, 0x03, 0x09, 0x02, 0xf7, 0xfb, 0xff, 0xff, 0xfc, 0xff, 0x04, 0x04, + 0xfc, 0x01, 0x08, 0xfc, 0xf6, 0xfa, 0x03, 0x02, 0x06, 0x08, 0x02, 0x01, 0xfe, 0xf8, 0xf7, 0xf9, 0xfc, 0xfd, 0xf7, 0xfb, 0x02, 0x01, + 0x02, 0xfa, 0xf6, 0x08, 0x00, 0xf8, 0xfe, 0x02, 0xfd, 0xf9, 0x02, 0xfe, 0x01, 0x09, 0x09, 0xfc, 0xf3, 0xf9, 0xf8, 0xfb, 0x01, 0x05, + 0x04, 0xfa, 0xf4, 0x05, 0x00, 0xf6, 0xf8, 0x05, 0x05, 0xff, 0x05, 0x05, 0x03, 0x03, 0x0d, 0x05, 0xfd, 0x03, 0x08, 0x03, 0xfb, 0x00, + 0x01, 0x04, 0x07, 0x0a, 0x04, 0xfd, 0xfc, 0x00, 0xfb, 0xf5, 0xfd, 0x0a, 0x08, 0xf9, 0xfc, 0x00, 0x04, 0x08, 0x00, 0xfb, 0xff, 0x0a, + 0xfa, 0xf3, 0x04, 0xfc, 0xfb, 0x03, 0x08, 0xfa, 0xf7, 0xff, 0xfa, 0xf9, 0xfc, 0xfe, 0xf4, 0xfd, 0x0b, 0x03, 0xf8, 0xf5, 0xfb, 0xf5, + 0x01, 0x0a, 0xff, 0xf6, 0xfd, 0x07, 0xfc, 0x02, 0x02, 0xf7, 0xf5, 0xfd, 0x02, 0xff, 0xf4, 0xf6, 0x00, 0xfb, 0x02, 0x0a, 0x09, 0xfc, + 0xf9, 0x00, 0x09, 0x00, 0x01, 0x07, 0xf9, 0xfd, 0x05, 0x03, 0x05, 0xff, 0x00, 0x0e, 0xfe, 0xec, 0xf0, 0x05, 0x10, 0x08, 0xfc, 0xfa, + 0xff, 0x05, 0x04, 0xfa, 0xf7, 0xff, 0xfe, 0x08, 0x0d, 0x03, 0xff, 0x01, 0xff, 0xf6, 0x00, 0x05, 0xfd, 0xf9, 0xfa, 0xfe, 0x01, 0x0c, + 0x06, 0xfc, 0x0a, 0xfc, 0xf2, 0xfb, 0xfe, 0x04, 0x01, 0xf6, 0x00, 0x0d, 0x0c, 0xfe, 0xf5, 0xfd, 0x0d, 0xf9, 0xfa, 0x08, 0x09, 0x00, + 0xfc, 0xfe, 0xf3, 0x01, 0x09, 0xfc, 0xf1, 0xf9, 0x03, 0xfc, 0xfc, 0x02, 0x06, 0xfe, 0xfb, 0x01, 0x06, 0xfc, 0xf2, 0xf5, 0x07, 0x0b, + 0x05, 0x01, 0x08, 0xfd, 0xf3, 0xfb, 0xf9, 0x00, 0x08, 0xff, 0x04, 0x07, 0x02, 0xfd, 0x00, 0x04, 0x01, 0xfe, 0x00, 0x02, 0x01, 0x01, + 0x07, 0x0f, 0xf4, 0xf8, 0x05, 0xf8, 0xf7, 0xfd, 0x02, 0x06, 0xfd, 0xf6, 0xfa, 0xfb, 0xfe, 0x01, 0x05, 0xfe, 0xfd, 0x03, 0x02, 0xfa, + 0xfa, 0x05, 0xfc, 0xf9, 0xfe, 0x02, 0x00, 0x05, 0x0a, 0xf6, 0xf3, 0xfe, 0x08, 0x05, 0x00, 0xff, 0x08, 0xfc, 0xf8, 0x03, 0x0c, 0x00, + 0xfa, 0x0d, 0x0c, 0xfd, 0xf3, 0x0a, 0xfa, 0xf9, 0x11, 0xff, 0xf2, 0xfa, 0x0b, 0xfa, 0xf6, 0x03, 0x0a, 0x03, 0x00, 0x05, 0xfb, 0xf3, + 0xf7, 0x09, 0x0c, 0x08, 0x04, 0xfd, 0x07, 0x09, 0xfb, 0xff, 0x04, 0x05, 0x07, 0xf6, 0xfb, 0x0e, 0xf6, 0xf8, 0x01, 0xfd, 0x06, 0x06, + 0xfb, 0xee, 0xf8, 0x08, 0x0c, 0xf6, 0xfe, 0x08, 0xf5, 0xff, 0x02, 0xfc, 0xfe, 0x04, 0x00, 0xf6, 0x04, 0x00, 0xf5, 0xf7, 0xf5, 0xf9, + 0xff, 0xfe, 0xf9, 0xf9, 0xfd, 0x03, 0xff, 0xfe, 0x09, 0x03, 0xfd, 0xfe, 0xfa, 0x01, 0x08, 0x08, 0xfa, 0xfc, 0x06, 0x05, 0xfd, 0xfd, + 0x06, 0x04, 0x00, 0x02, 0x09, 0x04, 0x01, 0xff, 0xfe, 0xf6, 0xf8, 0x03, 0x08, 0x05, 0x02, 0x04, 0xfd, 0xf9, 0xfa, 0xfb, 0x06, 0x08, + 0xfd, 0x02, 0xfd, 0xfb, 0x06, 0x04, 0x00, 0xff, 0xfa, 0xfb, 0x01, 0x04, 0xfa, 0xfe, 0x08, 0x06, 0x04, 0xfe, 0xf9, 0xf7, 0xfe, 0x06, + 0x09, 0xfa, 0x04, 0x0d, 0xf3, 0xf8, 0x03, 0x02, 0xf3, 0xf9, 0x01, 0xfd, 0xfd, 0xfd, 0xfd, 0xfa, 0xfe, 0x03, 0x06, 0xfd, 0xfe, 0xfc, + 0xf2, 0xf7, 0x09, 0x11, 0xfb, 0xf6, 0xfa, 0xfe, 0x02, 0xfc, 0xf9, 0x04, 0xfb, 0xfc, 0x07, 0x06, 0xfb, 0xfc, 0x06, 0xf9, 0xf3, 0xff, + 0x14, 0x06, 0xfc, 0xfe, 0xfc, 0xf7, 0x01, 0x15, 0x09, 0xfe, 0xf9, 0xf4, 0xf9, 0x07, 0x0d, 0xf4, 0xf6, 0x05, 0x08, 0x0c, 0x01, 0xf7, + 0x01, 0xfe, 0xfb, 0xfe, 0x0a, 0x03, 0xf9, 0xfc, 0xfc, 0x00, 0x07, 0x0d, 0xfc, 0xf6, 0x00, 0xf3, 0xf5, 0x00, 0x05, 0x02, 0x01, 0x01, + 0xfc, 0x00, 0x00, 0xfa, 0xfb, 0xff, 0x04, 0x09, 0x05, 0x02, 0x03, 0x05, 0x00, 0xfa, 0xfb, 0xfb, 0xfe, 0xff, 0xff, 0x02, 0x0a, 0x09, + 0xef, 0xf4, 0x03, 0x04, 0x02, 0xfd, 0xfb, 0x00, 0xfb, 0xfa, 0x00, 0x07, 0x05, 0xfe, 0xfa, 0x04, 0xfd, 0xf4, 0x0a, 0x07, 0xfb, 0xf6, + 0xfd, 0x04, 0x04, 0xfb, 0x02, 0x01, 0xfa, 0xfc, 0xfe, 0x00, 0x02, 0x04, 0x02, 0x03, 0x09, 0xfe, 0xf6, 0xf7, 0xf5, 0x04, 0x0b, 0x01, + 0x05, 0x04, 0xfd, 0xf7, 0xff, 0x02, 0xfc, 0xfb, 0xfd, 0xfe, 0xfe, 0x03, 0x02, 0xff, 0x04, 0xff, 0xfc, 0xfe, 0x02, 0xf6, 0xf2, 0x02, + 0x03, 0x04, 0x05, 0x06, 0x01, 0xfd, 0xfd, 0x08, 0xff, 0xf8, 0x05, 0xfa, 0x01, 0x10, 0x0b, 0xf9, 0xf5, 0x03, 0x00, 0xfc, 0x02, 0x12, + 0xfc, 0xf8, 0x04, 0xfc, 0x02, 0x09, 0x07, 0xff, 0xfd, 0xfc, 0xf7, 0xf7, 0xfb, 0x00, 0xfd, 0x07, 0x09, 0xfb, 0xfd, 0xfd, 0xf8, 0xf4, + 0xfa, 0x04, 0x0a, 0x0b, 0xfe, 0xf5, 0xf8, 0x04, 0x06, 0x02, 0x01, 0x05, 0xfe, 0xf4, 0x00, 0x07, 0x03, 0xfc, 0xf3, 0xf8, 0x04, 0x06, + 0xfe, 0xfd, 0x03, 0xf7, 0xf6, 0xff, 0x0b, 0x07, 0x09, 0x06, 0xef, 0xee, 0xfd, 0x09, 0xfe, 0xfc, 0x00, 0xfd, 0x03, 0x06, 0x03, 0xf8, + 0x07, 0x0d, 0xfc, 0xfd, 0xff, 0x01, 0x06, 0x00, 0xfd, 0x03, 0x08, 0x00, 0xfb, 0x03, 0xff, 0xfc, 0xfe, 0x05, 0xfa, 0xfd, 0x0a, 0xf9, + 0xfe, 0x07, 0x01, 0xfb, 0xf9, 0xfb, 0xfd, 0xfe, 0x02, 0x09, 0x11, 0x07, 0xf9, 0xf7, 0xf6, 0xf6, 0xf9, 0xfc, 0x01, 0x04, 0x03, 0x03, + 0x02, 0xff, 0xf8, 0xfb, 0x03, 0x06, 0xff, 0xfd, 0xfd, 0xfe, 0x07, 0x03, 0xfe, 0x09, 0xfd, 0xfa, 0x03, 0x05, 0xfc, 0xfb, 0x07, 0xfa, + 0xf9, 0x06, 0x0d, 0xfe, 0xf4, 0xf6, 0xf0, 0xfd, 0x05, 0xf9, 0x0e, 0x0e, 0xfb, 0xf1, 0x02, 0x04, 0xf6, 0x00, 0x08, 0x08, 0x02, 0xfa, + 0xf7, 0xfd, 0x06, 0x0a, 0x01, 0xf6, 0x03, 0x05, 0xfd, 0xfa, 0xfb, 0xfc, 0xff, 0x0e, 0x04, 0xfc, 0x04, 0x0a, 0x06, 0xfb, 0xf4, 0xfb, + 0x04, 0x08, 0x10, 0x03, 0xfa, 0x00, 0xfe, 0xf9, 0xfa, 0x03, 0xff, 0xfa, 0xfb, 0xfb, 0xff, 0x01, 0xff, 0x02, 0x00, 0xfb, 0xfb, 0xff, + 0x03, 0x02, 0xf2, 0xf4, 0x05, 0x11, 0x02, 0xf7, 0xfb, 0x02, 0xfe, 0xf3, 0xf1, 0x11, 0x0c, 0xf9, 0x03, 0xf9, 0x02, 0x11, 0x01, 0xf3, + 0xf5, 0x00, 0xfe, 0x03, 0x08, 0x02, 0xfd, 0xff, 0x02, 0x00, 0xfa, 0xf7, 0xfa, 0x05, 0x03, 0xfe, 0x04, 0x03, 0xfd, 0xf9, 0x03, 0x01, + 0xfd, 0x02, 0x09, 0x01, 0xf5, 0xfa, 0x01, 0x06, 0x06, 0x03, 0xfc, 0xfb, 0x00, 0xfb, 0xf6, 0xf9, 0x04, 0x08, 0x03, 0xfc, 0x01, 0xfa, + 0xf9, 0x0a, 0xfb, 0xfa, 0x07, 0xff, 0xfa, 0xfe, 0x03, 0xf1, 0xff, 0x0c, 0xf8, 0x02, 0x0b, 0x06, 0xf8, 0xf9, 0xf8, 0xf2, 0x02, 0x0d, + 0x09, 0xf9, 0x00, 0xff, 0xf5, 0xfc, 0x02, 0x03, 0x04, 0x05, 0x08, 0x04, 0xf3, 0xff, 0x03, 0xf9, 0x01, 0xff, 0xfb, 0xff, 0xff, 0x01, + 0x02, 0xfe, 0xfe, 0x03, 0x06, 0xff, 0xf3, 0xf5, 0x05, 0x05, 0xfd, 0xfc, 0x0b, 0x0a, 0x04, 0xff, 0xf8, 0xf1, 0xf9, 0x14, 0xf9, 0xf9, + 0x11, 0x07, 0xf9, 0xf9, 0x04, 0x00, 0xfa, 0xfb, 0x03, 0xfe, 0xfd, 0x03, 0x04, 0x06, 0x05, 0xff, 0xea, 0xf5, 0x06, 0xf8, 0xfd, 0xfd, + 0xf9, 0x08, 0x03, 0xfc, 0x05, 0x05, 0x06, 0x01, 0xf3, 0xf5, 0x01, 0x09, 0x0e, 0x04, 0xfb, 0xfd, 0x06, 0x01, 0xf8, 0xf7, 0x02, 0x03, + 0xfa, 0x06, 0x0b, 0x08, 0x03, 0xf5, 0xf9, 0x05, 0xf9, 0xfd, 0x01, 0xfd, 0xfd, 0x01, 0x02, 0xfa, 0x05, 0x02, 0xf4, 0xf8, 0xff, 0x01, + 0xff, 0xf1, 0x00, 0x11, 0xff, 0xf9, 0x03, 0x0c, 0xff, 0xf7, 0xf6, 0xf9, 0x06, 0x0a, 0x05, 0x04, 0x00, 0x00, 0x03, 0x04, 0xfd, 0xfb, + 0x02, 0xfc, 0xf9, 0xfd, 0x08, 0x0c, 0x07, 0xfc, 0x00, 0xf7, 0xf4, 0x04, 0xfe, 0xf9, 0xfd, 0x06, 0xfd, 0xfa, 0x02, 0xfc, 0xfb, 0xff, + 0x00, 0x00, 0x02, 0x01, 0xfb, 0x06, 0x0c, 0x04, 0x0d, 0x07, 0xf9, 0xf8, 0xf6, 0xf9, 0x01, 0x0a, 0x03, 0x00, 0x0b, 0x05, 0xfc, 0xfa, + 0xfc, 0x03, 0x05, 0x01, 0x01, 0xfd, 0xfd, 0x02, 0xf7, 0xfc, 0x08, 0xfd, 0xfa, 0xfb, 0xfb, 0xfa, 0xfd, 0x01, 0xff, 0x05, 0x01, 0xf7, + 0xf3, 0x01, 0x01, 0xf2, 0x03, 0x0a, 0x04, 0xfc, 0x06, 0x07, 0xfc, 0xf4, 0x03, 0x05, 0xf2, 0x15, 0x0c, 0xef, 0xef, 0x05, 0x0a, 0xfe, + 0x06, 0xff, 0xff, 0x0d, 0x00, 0xf7, 0xf9, 0xfc, 0xff, 0x04, 0x08, 0x04, 0xfe, 0xfa, 0xfc, 0xf7, 0xfe, 0x0b, 0x0f, 0x01, 0xfa, 0x01, + 0xfc, 0xfd, 0x04, 0x0c, 0xff, 0xf8, 0xfc, 0x01, 0x01, 0xfe, 0xfe, 0x05, 0x04, 0x03, 0x08, 0xff, 0xf5, 0xf5, 0x05, 0xfe, 0xf9, 0x05, + 0x04, 0xfd, 0xf9, 0x01, 0x03, 0x00, 0xfe, 0x09, 0xfe, 0xf5, 0xff, 0xf7, 0xfc, 0x05, 0x07, 0xf5, 0xf7, 0x09, 0x02, 0xfc, 0xfd, 0x00, + 0x03, 0xfe, 0xfc, 0x09, 0xff, 0xf9, 0xff, 0xfc, 0x01, 0x05, 0xff, 0x01, 0xfb, 0xf6, 0x02, 0x08, 0x03, 0xfb, 0x04, 0x04, 0xfd, 0xfa, + 0xfd, 0xff, 0x00, 0x02, 0x04, 0x07, 0x07, 0x01, 0xff, 0xfd, 0xf7, 0x06, 0x0d, 0x05, 0xfb, 0x04, 0x02, 0xef, 0xfe, 0x08, 0x08, 0x05, + 0xf9, 0xf7, 0xfd, 0xee, 0x04, 0x0e, 0xf4, 0x02, 0x0d, 0x04, 0xf0, 0xf8, 0xfb, 0xf5, 0x01, 0x06, 0x03, 0x03, 0xfe, 0xff, 0x02, 0xff, + 0xfd, 0xfc, 0xfa, 0x00, 0xff, 0xfc, 0x01, 0x0a, 0x05, 0xf9, 0x03, 0xf9, 0xfa, 0x0a, 0x08, 0xf8, 0xf4, 0x08, 0xfc, 0xf2, 0xfb, 0x0d, + 0x01, 0xf2, 0xf5, 0xfd, 0xff, 0xfb, 0xfb, 0x01, 0x07, 0x06, 0x01, 0xf9, 0xf9, 0x01, 0xfb, 0x00, 0x0a, 0x0a, 0xfd, 0xf9, 0x01, 0xfe, + 0x06, 0x0b, 0x03, 0xf7, 0xf8, 0x01, 0x0d, 0xfd, 0xfe, 0x11, 0xf9, 0x01, 0x10, 0x05, 0x04, 0x01, 0xfa, 0xf7, 0x02, 0x0a, 0x04, 0x04, + 0xf9, 0xf4, 0xfc, 0x0d, 0x07, 0xf5, 0xfe, 0xfb, 0xf6, 0xf8, 0xfc, 0x05, 0x08, 0xfe, 0xfc, 0x02, 0x08, 0x04, 0x01, 0x01, 0x00, 0xf7, + 0xf5, 0xfb, 0x04, 0x05, 0x00, 0xfb, 0xf4, 0xfa, 0xff, 0xf8, 0xf9, 0xfd, 0x01, 0x00, 0x07, 0x08, 0x02, 0xf8, 0xfd, 0x02, 0xfa, 0xf7, + 0xfc, 0x06, 0x07, 0x07, 0x01, 0xfb, 0x00, 0xfc, 0xf8, 0x00, 0xf5, 0xf5, 0x05, 0x1c, 0xf8, 0xea, 0x0c, 0xf8, 0xf5, 0x01, 0x08, 0xfe, + 0xfd, 0x04, 0x03, 0xff, 0x04, 0x0f, 0x0a, 0xfc, 0xf5, 0x00, 0xfe, 0xfc, 0x02, 0x0e, 0x0c, 0x01, 0xf9, 0x02, 0x01, 0xfa, 0x01, 0x00, + 0xfe, 0xff, 0xfd, 0x02, 0x06, 0x00, 0x03, 0x00, 0xfa, 0xfb, 0x02, 0x01, 0xf9, 0xff, 0x01, 0xfd, 0xf7, 0x01, 0x02, 0xfd, 0x07, 0x00, + 0xf3, 0xf0, 0xfb, 0x06, 0x07, 0xfd, 0x01, 0x05, 0x03, 0x00, 0xfd, 0xfe, 0x03, 0x05, 0x02, 0x02, 0x08, 0xfd, 0xf8, 0xff, 0xfd, 0x02, + 0x04, 0xfa, 0xfd, 0xfe, 0xfb, 0xf6, 0x0b, 0x0c, 0xf6, 0xfd, 0xff, 0xfd, 0x01, 0x04, 0x01, 0xfa, 0xf5, 0xfb, 0x00, 0xfd, 0xff, 0xfd, + 0xfe, 0x01, 0x03, 0xfb, 0xf2, 0xf9, 0x04, 0x0a, 0x09, 0x03, 0xfd, 0xfd, 0x02, 0x01, 0x04, 0x0d, 0x14, 0xfe, 0xef, 0xfe, 0xfd, 0x04, + 0x0d, 0x0f, 0xf9, 0xf0, 0xfa, 0x04, 0xf5, 0xf6, 0x13, 0x00, 0xf7, 0xfc, 0xfd, 0xf9, 0xfe, 0x04, 0x00, 0xee, 0xf0, 0x11, 0x09, 0x01, + 0x01, 0x02, 0xf8, 0xf8, 0x02, 0x07, 0xfd, 0xf3, 0xf6, 0x0b, 0x0d, 0xfe, 0xf9, 0x00, 0x01, 0xf9, 0x0c, 0x0f, 0x07, 0x01, 0xff, 0xfd, + 0xfb, 0xf4, 0x05, 0x0b, 0xfb, 0xf3, 0xfd, 0x08, 0x00, 0xfe, 0xfe, 0xff, 0xf8, 0xfe, 0x02, 0xfb, 0xf7, 0xfa, 0xfe, 0xfb, 0x01, 0x02, + 0xff, 0x00, 0x08, 0x07, 0xfb, 0x02, 0x04, 0xfc, 0xf5, 0xfa, 0x07, 0x0c, 0xf4, 0xee, 0xf7, 0xfd, 0x05, 0x0a, 0x09, 0xff, 0x04, 0x00, + 0xf1, 0xff, 0x03, 0x01, 0x05, 0x00, 0xfe, 0xfe, 0xfc, 0xf5, 0xfa, 0x0a, 0x04, 0xfd, 0xfd, 0x02, 0xfe, 0xff, 0x05, 0x01, 0x01, 0x02, + 0x00, 0xf3, 0xfe, 0x0e, 0x07, 0x00, 0x01, 0x06, 0xff, 0x02, 0x06, 0x04, 0xf8, 0xfc, 0x04, 0xfb, 0xfd, 0x04, 0x07, 0x07, 0xf8, 0xf2, + 0x03, 0xfe, 0x02, 0x09, 0xfd, 0xfd, 0x00, 0x00, 0x03, 0x03, 0xfd, 0xf2, 0x05, 0x08, 0xfc, 0x05, 0xf7, 0xf1, 0x00, 0x07, 0x01, 0xfb, + 0xfd, 0xfe, 0xf8, 0xf1, 0xff, 0x00, 0xfc, 0xfa, 0x05, 0xfe, 0xf6, 0x02, 0x09, 0x00, 0xf2, 0xff, 0xfd, 0xf9, 0xfe, 0x0c, 0x07, 0xf8, + 0xf8, 0xff, 0xff, 0xf7, 0x03, 0xfb, 0xf8, 0x0b, 0x00, 0x00, 0x08, 0x01, 0xf8, 0xfe, 0x0c, 0x07, 0x03, 0x01, 0x00, 0x07, 0x06, 0x00, + 0x05, 0x00, 0xfb, 0xfd, 0xfd, 0xfc, 0xfe, 0x08, 0xfb, 0xf9, 0x05, 0x04, 0x00, 0x00, 0x04, 0xfc, 0xfb, 0x00, 0x08, 0x00, 0xfe, 0x04, + 0x05, 0xfd, 0x00, 0x0f, 0x04, 0xf8, 0xf8, 0x03, 0x05, 0x06, 0x06, 0xfc, 0xfa, 0xfe, 0x00, 0x0d, 0x07, 0xf9, 0xfa, 0x03, 0xff, 0xf4, + 0x07, 0x04, 0xf8, 0xf5, 0x04, 0x00, 0xf2, 0xfa, 0xfd, 0xff, 0x03, 0x00, 0xfc, 0xfb, 0xfd, 0xfb, 0xf6, 0xf4, 0xfd, 0xf9, 0xfc, 0x09, + 0x02, 0xfc, 0xfc, 0xff, 0xfc, 0xff, 0x07, 0x07, 0xfb, 0xf8, 0x02, 0xfd, 0xfc, 0xff, 0xfe, 0x00, 0x05, 0x06, 0xf6, 0x00, 0x06, 0xf7, + 0xf9, 0x08, 0x0f, 0xfb, 0xfb, 0x01, 0x02, 0xff, 0x01, 0x04, 0x04, 0x06, 0x04, 0x00, 0xfe, 0x03, 0x04, 0x01, 0x05, 0x01, 0xfc, 0x00, + 0xf8, 0xf8, 0x05, 0x14, 0x08, 0xff, 0x06, 0xfa, 0xfd, 0x07, 0x08, 0x05, 0xfd, 0xf8, 0x07, 0x02, 0xfd, 0x04, 0x00, 0xf9, 0xf8, 0xfd, + 0x05, 0x02, 0xf9, 0x01, 0xfa, 0xf4, 0xf9, 0x06, 0x03, 0xfc, 0x06, 0x00, 0xf3, 0xf1, 0x0e, 0x0d, 0xfb, 0xf1, 0x06, 0x00, 0xef, 0xfe, + 0xfe, 0xf9, 0xf9, 0x06, 0x06, 0xfb, 0xf3, 0xfe, 0xff, 0xf8, 0x01, 0xfb, 0xfc, 0x07, 0x05, 0xf7, 0xf4, 0x09, 0x01, 0xff, 0x05, 0xfd, + 0x04, 0x09, 0x03, 0xfc, 0x03, 0x0b, 0x07, 0x01, 0xfe, 0xfe, 0x01, 0x00, 0xff, 0x04, 0x0c, 0x0b, 0x03, 0xfe, 0xfe, 0x00, 0xff, 0xfe, + 0xfe, 0x00, 0x01, 0x06, 0x00, 0xfb, 0x0d, 0xfc, 0xf1, 0xfe, 0x08, 0x04, 0xfd, 0xff, 0x00, 0xff, 0xff, 0x09, 0xfe, 0xfd, 0x0b, 0x06, + 0xfc, 0xfd, 0x0a, 0x05, 0x02, 0x04, 0xfb, 0xfa, 0xfd, 0xff, 0x01, 0x00, 0xfa, 0xf7, 0xf8, 0xfc, 0x00, 0xfe, 0xfd, 0xfe, 0x00, 0x02, + 0xff, 0xfb, 0xfc, 0xfb, 0xf7, 0xf5, 0x03, 0x07, 0x02, 0xfc, 0xfe, 0xfc, 0xfb, 0x05, 0x03, 0xfb, 0xf5, 0xfe, 0x03, 0x00, 0xfa, 0x01, + 0x01, 0xfd, 0x09, 0x05, 0x04, 0x07, 0xfa, 0xfc, 0x04, 0x02, 0x02, 0xff, 0xfc, 0xfc, 0xff, 0xfb, 0xf3, 0x01, 0x06, 0x01, 0xff, 0x08, + 0x05, 0xf8, 0xf4, 0xfb, 0xfe, 0xf9, 0x01, 0x06, 0x07, 0x04, 0x05, 0x04, 0x04, 0x07, 0x05, 0x03, 0x07, 0xf5, 0xfb, 0x09, 0xff, 0xf8, + 0xfb, 0x02, 0x04, 0x01, 0xfe, 0xfd, 0xf8, 0xf5, 0xfa, 0x07, 0x0b, 0x07, 0xff, 0xf2, 0xf9, 0xff, 0xf5, 0xfc, 0x05, 0x05, 0xfe, 0xfa, + 0xfa, 0xfd, 0x02, 0xfc, 0xf7, 0xff, 0xf8, 0xf8, 0xff, 0xf5, 0x03, 0x08, 0xf8, 0x02, 0x04, 0x00, 0x02, 0xfe, 0xfe, 0x02, 0x08, 0x02, + 0xff, 0x05, 0x01, 0xfe, 0xff, 0x03, 0x07, 0x05, 0xff, 0xfe, 0xf8, 0xfa, 0x07, 0x07, 0xff, 0xfd, 0x0a, 0x00, 0xf7, 0xfb, 0x02, 0xfd, + 0xfc, 0x0d, 0xff, 0xfb, 0x05, 0x09, 0xff, 0xfa, 0x00, 0x0b, 0xf5, 0xe8, 0x07, 0x03, 0xfa, 0xfb, 0x02, 0xfd, 0xfc, 0x04, 0xf3, 0xf5, + 0x04, 0x05, 0xfe, 0xfc, 0x01, 0x02, 0x02, 0xff, 0xfa, 0xfa, 0xff, 0x00, 0xfa, 0xfb, 0x06, 0x0c, 0xf5, 0xf9, 0x04, 0xfd, 0xf7, 0xfb, + 0x05, 0x0c, 0xfd, 0xf6, 0x01, 0xfc, 0x07, 0x0b, 0xfb, 0xff, 0x02, 0xfc, 0xf4, 0xf8, 0x03, 0x0b, 0x10, 0x04, 0xfb, 0x05, 0x07, 0xfd, + 0xf4, 0x06, 0xfd, 0xff, 0x15, 0x0b, 0xff, 0x01, 0x0c, 0x02, 0xfe, 0x03, 0xfc, 0x00, 0x06, 0x02, 0x04, 0xfd, 0xfa, 0x07, 0x08, 0xff, + 0xf9, 0x01, 0x00, 0xfb, 0xf9, 0x05, 0xfd, 0xf2, 0x05, 0x02, 0xf9, 0xf7, 0x01, 0xf1, 0xea, 0x02, 0x01, 0x01, 0x03, 0xf7, 0xfb, 0xfd, + 0xf7, 0xfb, 0xfb, 0xfa, 0xfe, 0xfe, 0xff, 0x01, 0x01, 0x04, 0x01, 0xfa, 0x09, 0x05, 0xf9, 0xfe, 0x03, 0x02, 0xfd, 0xff, 0x00, 0x01, + 0x01, 0x01, 0xff, 0xfe, 0xfe, 0x04, 0xfd, 0xf2, 0x04, 0x08, 0x05, 0x05, 0x00, 0xfc, 0xfb, 0xf7, 0x03, 0x0b, 0x09, 0x08, 0x05, 0x03, + 0x03, 0x07, 0x01, 0xfc, 0x0d, 0xfb, 0xf9, 0x0e, 0x00, 0x00, 0x07, 0x04, 0x07, 0x0a, 0x06, 0xf9, 0xfd, 0x03, 0x01, 0x00, 0xfc, 0xfb, + 0x03, 0xfb, 0xfb, 0x01, 0xfb, 0xfb, 0xfe, 0xfd, 0xf6, 0xf8, 0xfd, 0xfd, 0x05, 0x00, 0xf2, 0xf6, 0xf7, 0xf7, 0xfc, 0x06, 0x00, 0xf8, + 0x05, 0xff, 0xfc, 0x01, 0xf8, 0xfb, 0xfe, 0xf6, 0x07, 0x00, 0xf1, 0x00, 0xfb, 0xfa, 0x05, 0xff, 0x06, 0x0a, 0xfa, 0xf3, 0xfb, 0x04, + 0xf5, 0x02, 0x08, 0xfa, 0x03, 0x05, 0x00, 0xfd, 0x04, 0x06, 0x01, 0x02, 0x06, 0x0a, 0x0b, 0x08, 0x05, 0xff, 0xf8, 0xfe, 0x07, 0x09, + 0xfc, 0x02, 0x09, 0x02, 0x01, 0xfe, 0xfd, 0x02, 0x0c, 0x09, 0xfb, 0xf8, 0xf9, 0xfe, 0x04, 0x05, 0x0d, 0x0d, 0xf1, 0xfd, 0x05, 0xf8, + 0xfc, 0x00, 0xfe, 0xf7, 0xfc, 0x01, 0xff, 0xf2, 0xfe, 0x02, 0xf5, 0xf7, 0x04, 0x08, 0xf7, 0xfe, 0xff, 0xf9, 0xf7, 0x04, 0xff, 0xe6, + 0x03, 0x04, 0xf5, 0xfc, 0xfc, 0xff, 0x02, 0xfb, 0xfc, 0xfe, 0xfc, 0x00, 0xfa, 0xf5, 0x01, 0x07, 0x08, 0x06, 0xfd, 0xf6, 0x00, 0x13, + 0x00, 0xfa, 0x05, 0x00, 0x06, 0x02, 0xf9, 0x05, 0x0f, 0x0a, 0xfb, 0xfe, 0x04, 0x05, 0x05, 0xfa, 0xfd, 0x0e, 0x03, 0xfe, 0xff, 0xfe, + 0x00, 0x05, 0x08, 0x00, 0x01, 0xff, 0xf6, 0x05, 0x05, 0xff, 0x04, 0x03, 0x01, 0xfd, 0xf7, 0xf8, 0xfe, 0x04, 0x06, 0x03, 0x02, 0x05, + 0xff, 0xfb, 0xfd, 0xfe, 0xfd, 0xfb, 0xfc, 0xf9, 0xfd, 0x03, 0xff, 0xf9, 0xf6, 0xfa, 0x00, 0xfd, 0xf4, 0xed, 0x01, 0x02, 0xf5, 0xf9, + 0xfa, 0xff, 0x06, 0x00, 0xfa, 0xf9, 0xfb, 0xf8, 0xfe, 0x08, 0xff, 0x0a, 0x0a, 0xf8, 0x05, 0x00, 0xf5, 0x00, 0x03, 0x0b, 0x0f, 0xfc, + 0xf9, 0x02, 0x0a, 0xff, 0x02, 0x0b, 0x04, 0x00, 0x00, 0x01, 0xfb, 0x00, 0x07, 0x09, 0x03, 0x04, 0x04, 0xf7, 0xf9, 0xff, 0x01, 0x0b, + 0x03, 0xf9, 0xfb, 0x07, 0x06, 0xfb, 0xf8, 0x03, 0x06, 0xfd, 0x06, 0x05, 0xfe, 0x00, 0xf7, 0x00, 0x0c, 0xfb, 0xfa, 0xfe, 0xfd, 0xfc, + 0xf9, 0xf7, 0xfc, 0xfe, 0x01, 0x03, 0xff, 0x01, 0x02, 0xff, 0xed, 0xf7, 0x07, 0xff, 0xfb, 0x00, 0x06, 0xfe, 0xff, 0xfe, 0xf7, 0x00, + 0x04, 0xff, 0xf9, 0xf6, 0xf9, 0xff, 0x03, 0x08, 0x06, 0xfe, 0xf2, 0xf5, 0x03, 0x0d, 0xfd, 0xf7, 0x04, 0x05, 0x02, 0x00, 0x04, 0xfe, + 0xfe, 0x02, 0x05, 0xfb, 0xf7, 0x00, 0x0b, 0x0c, 0x04, 0xfb, 0x04, 0x00, 0xf7, 0x07, 0x04, 0xfb, 0xfb, 0x05, 0x05, 0x05, 0x12, 0xfa, + 0xf3, 0x04, 0x02, 0xfe, 0xfc, 0xfe, 0x04, 0x06, 0x01, 0x00, 0xf5, 0xfa, 0x09, 0x01, 0xf7, 0xfa, 0x07, 0xf4, 0xf5, 0x07, 0x0d, 0x04, + 0xff, 0x03, 0xf9, 0xf5, 0xfb, 0x07, 0xf6, 0xf9, 0x0b, 0x0b, 0xfe, 0xfa, 0x01, 0xf5, 0xf4, 0xfd, 0x01, 0x08, 0x04, 0xfd, 0x02, 0x05, + 0xfd, 0xf1, 0x0a, 0x0b, 0xfc, 0xf9, 0xf8, 0xf6, 0xf8, 0x0a, 0x06, 0xfd, 0xff, 0x06, 0xff, 0xf5, 0xfb, 0xff, 0xfb, 0xf8, 0x0f, 0x0c, + 0x02, 0x02, 0x03, 0x00, 0xff, 0x04, 0x09, 0x06, 0x00, 0xfc, 0x05, 0x0a, 0x01, 0xf3, 0xf9, 0x09, 0x04, 0x01, 0xfe, 0xfb, 0xf2, 0x06, + 0x14, 0x00, 0x05, 0x03, 0xfa, 0xfb, 0xfd, 0xf8, 0xf2, 0x05, 0x07, 0xfe, 0x00, 0xf9, 0xf6, 0xfa, 0xfd, 0xfc, 0xfe, 0x04, 0xf9, 0xfa, + 0x00, 0xfd, 0x05, 0x04, 0xfa, 0xff, 0x04, 0xff, 0xf5, 0x00, 0x0a, 0x08, 0xfe, 0x02, 0xfd, 0xf1, 0xfb, 0x02, 0xfe, 0xf5, 0xfe, 0x01, + 0xff, 0x02, 0xff, 0xfd, 0x00, 0xf8, 0x00, 0x0a, 0x04, 0xf6, 0xf5, 0xff, 0xfc, 0x09, 0x0a, 0xfb, 0x0e, 0x06, 0xf9, 0x05, 0x03, 0xfb, + 0xf9, 0x06, 0x06, 0x05, 0x08, 0x02, 0xf3, 0xf3, 0x11, 0x04, 0xfa, 0x02, 0x05, 0x01, 0xfe, 0x00, 0xf4, 0xfd, 0x0b, 0x01, 0x05, 0xff, + 0xf0, 0xfd, 0xfd, 0xfa, 0xff, 0x13, 0x06, 0xef, 0xf6, 0x02, 0xfc, 0xee, 0xff, 0x06, 0x05, 0x05, 0x01, 0xf7, 0xf3, 0x00, 0x09, 0x03, + 0xf7, 0x04, 0x02, 0xf6, 0xf0, 0x00, 0x06, 0x01, 0x03, 0x06, 0x00, 0xf4, 0xfb, 0xfe, 0x02, 0x0c, 0x01, 0xf9, 0xfd, 0x07, 0x06, 0xff, + 0xfc, 0xee, 0xf9, 0x0b, 0x02, 0x06, 0x05, 0xfd, 0x00, 0xfc, 0xfc, 0x04, 0xf9, 0xfe, 0x08, 0xfc, 0x01, 0x08, 0x03, 0xfa, 0x02, 0x08, + 0xfe, 0x03, 0xff, 0xf8, 0x01, 0x02, 0xfe, 0xfc, 0xf5, 0xff, 0x0a, 0x07, 0xf9, 0xf8, 0x00, 0xfd, 0xfe, 0x01, 0x02, 0x07, 0xfd, 0xf6, + 0x04, 0x04, 0xff, 0xfe, 0x04, 0xfe, 0xfd, 0x07, 0x04, 0x00, 0x00, 0xff, 0xff, 0xfd, 0xfa, 0xf8, 0xfc, 0x01, 0x02, 0xf6, 0xfb, 0x05, + 0xfb, 0xfc, 0x00, 0x01, 0xfe, 0xfe, 0x01, 0x05, 0xff, 0xfd, 0x00, 0x03, 0x02, 0x04, 0x06, 0xfc, 0xf7, 0xfd, 0x06, 0x01, 0xfd, 0xff, + 0xfb, 0x01, 0x01, 0xf8, 0xf5, 0x01, 0x0a, 0x01, 0x01, 0x06, 0x07, 0x03, 0xfd, 0x00, 0x0b, 0x05, 0xfb, 0xfb, 0x09, 0xf9, 0xf7, 0x06, + 0xfd, 0xff, 0x04, 0x03, 0xfc, 0xfc, 0xfd, 0xf6, 0x02, 0x06, 0xfc, 0x06, 0xfe, 0xf8, 0x03, 0x07, 0x01, 0xfb, 0xfd, 0x04, 0x09, 0x07, + 0x05, 0xfd, 0xfa, 0x01, 0xff, 0xf9, 0xfb, 0x0f, 0x01, 0xf3, 0xf9, 0x03, 0xfe, 0xf7, 0xff, 0xfe, 0xff, 0x01, 0x05, 0xfd, 0xfb, 0x02, + 0xff, 0xf8, 0xfb, 0x0d, 0x00, 0xf9, 0x01, 0xfd, 0x00, 0x05, 0x06, 0xf9, 0xfa, 0x03, 0xff, 0x01, 0xff, 0xfb, 0x00, 0x01, 0x02, 0x05, + 0x05, 0xff, 0xfc, 0x06, 0xfe, 0xf8, 0xff, 0x0a, 0xff, 0xf7, 0x06, 0xfe, 0xfb, 0xff, 0x02, 0xf7, 0xf9, 0x07, 0x04, 0xfd, 0xfe, 0x04, + 0x05, 0x01, 0xfc, 0xf3, 0x07, 0x13, 0x05, 0xfd, 0xfb, 0xfe, 0x04, 0xfb, 0xfa, 0x03, 0x04, 0xfd, 0xf9, 0xfe, 0xf8, 0xff, 0x04, 0xf7, + 0x02, 0x0a, 0x00, 0xef, 0xf9, 0x07, 0x04, 0x03, 0x04, 0x03, 0xfd, 0xf6, 0xf7, 0x01, 0x03, 0xff, 0xfc, 0x01, 0xfd, 0x03, 0x06, 0xfa, + 0xf3, 0xfd, 0x0c, 0x03, 0xfa, 0xff, 0x0d, 0x04, 0xfb, 0xfa, 0xfb, 0x03, 0x07, 0x02, 0xfc, 0xfd, 0x01, 0x06, 0xfc, 0xfb, 0x05, 0x08, + 0xff, 0xf9, 0xfd, 0xfc, 0xff, 0x02, 0x04, 0x04, 0x01, 0xfc, 0xfa, 0xfe, 0x02, 0x03, 0x07, 0x02, 0xfd, 0xff, 0xfd, 0xfd, 0x00, 0xfe, + 0x00, 0x01, 0xfd, 0xf9, 0xfe, 0x03, 0xf8, 0xfd, 0x05, 0x05, 0xfc, 0xfb, 0xfc, 0xf8, 0x01, 0x07, 0x04, 0xfd, 0x00, 0x00, 0xf8, 0xfa, + 0x00, 0x05, 0x06, 0x01, 0xfb, 0xfa, 0xfe, 0x00, 0xff, 0xfd, 0x00, 0x02, 0x03, 0x01, 0x04, 0x01, 0xfa, 0xf9, 0x01, 0x05, 0xff, 0x02, + 0x04, 0x02, 0xfb, 0x01, 0x00, 0xf6, 0xfa, 0xfb, 0x01, 0x0c, 0xfd, 0xf1, 0xf9, 0x0a, 0x08, 0x01, 0x00, 0xff, 0xfd, 0xfc, 0xff, 0xfe, + 0x05, 0x0c, 0x09, 0xfb, 0xfa, 0x05, 0xfa, 0xf9, 0x03, 0x07, 0x08, 0xfd, 0xf4, 0xff, 0xff, 0xfe, 0x03, 0xfd, 0xfb, 0xfe, 0x04, 0xf9, + 0xf8, 0x03, 0x04, 0x03, 0x02, 0x02, 0xfe, 0xfb, 0xf9, 0xf6, 0x08, 0x0f, 0x04, 0xff, 0xf9, 0xf9, 0xff, 0xff, 0xfc, 0xfb, 0xff, 0xff, + 0xfb, 0xfa, 0x02, 0x05, 0x01, 0xfb, 0xf8, 0xfc, 0x04, 0x0b, 0x04, 0xfb, 0xfa, 0xf7, 0x03, 0x0b, 0xff, 0xfd, 0xfe, 0xfd, 0xf6, 0x02, + 0x05, 0xf7, 0xf4, 0xff, 0x0a, 0x03, 0x03, 0xff, 0xfa, 0xfe, 0x02, 0x02, 0x01, 0x00, 0x00, 0xff, 0xfc, 0x04, 0x09, 0x06, 0x01, 0x00, + 0xfe, 0xf8, 0xfe, 0x06, 0x09, 0x01, 0x03, 0x00, 0xf9, 0xfd, 0x04, 0x06, 0x01, 0xfc, 0xfb, 0xfc, 0xfe, 0xff, 0x03, 0x08, 0x02, 0xfc, + 0xf8, 0xf3, 0xff, 0x02, 0xfd, 0x06, 0x05, 0x03, 0x01, 0xfd, 0xfc, 0x01, 0x07, 0x07, 0xff, 0xf6, 0xf9, 0xfa, 0xfe, 0x07, 0x03, 0xff, + 0xff, 0x02, 0xec, 0xec, 0x04, 0x04, 0x01, 0xfd, 0xfb, 0xff, 0xfd, 0xf9, 0xfc, 0x01, 0x03, 0xfe, 0xf6, 0xf9, 0x05, 0x0d, 0x07, 0xfe, + 0xfe, 0x05, 0x01, 0xfb, 0xfb, 0xfc, 0xff, 0x04, 0x05, 0x07, 0x01, 0xfa, 0x04, 0x02, 0xfe, 0x00, 0x09, 0x04, 0xfd, 0xfe, 0x09, 0x06, + 0xfb, 0xfd, 0x06, 0x0b, 0x06, 0xff, 0xfb, 0xfe, 0x03, 0x02, 0xfc, 0xfb, 0x07, 0x07, 0x01, 0x00, 0xf8, 0xfb, 0x03, 0x04, 0xf9, 0xfd, + 0x0a, 0x07, 0xfc, 0xf7, 0xfe, 0x01, 0x01, 0x00, 0x03, 0xf9, 0xf8, 0x03, 0xfe, 0x00, 0x06, 0x06, 0xfb, 0xf5, 0xf7, 0xfd, 0xf4, 0xf8, + 0x08, 0xfb, 0xf9, 0x02, 0x09, 0xfb, 0xf6, 0xfd, 0xfe, 0xfd, 0xff, 0x03, 0xfe, 0x01, 0x05, 0x01, 0x02, 0x02, 0xfe, 0xff, 0xfa, 0xfc, + 0x07, 0xff, 0xfe, 0x04, 0x00, 0x05, 0x06, 0x01, 0x02, 0xfd, 0xfa, 0xff, 0xff, 0x01, 0x05, 0x07, 0x09, 0x05, 0xfe, 0x01, 0x00, 0xff, + 0x03, 0x02, 0xff, 0xfb, 0xf8, 0x01, 0x06, 0x04, 0x08, 0x08, 0xfe, 0xed, 0xfb, 0x07, 0x04, 0xfd, 0x01, 0x06, 0x03, 0x02, 0xfb, 0xf7, + 0xfb, 0x01, 0x01, 0xff, 0xfc, 0x00, 0xff, 0xf8, 0xff, 0x05, 0x02, 0xf9, 0xfc, 0xfc, 0xf5, 0xf9, 0xfe, 0x01, 0x03, 0x06, 0x03, 0xfb, + 0xf5, 0xfc, 0x03, 0x02, 0xfa, 0xfa, 0xff, 0xff, 0x03, 0x01, 0x00, 0x0c, 0xff, 0xf6, 0xfe, 0x00, 0xfe, 0xfd, 0x00, 0x07, 0x03, 0xfb, + 0x01, 0x03, 0x02, 0x01, 0x04, 0xfe, 0xf7, 0xfc, 0x07, 0x0a, 0x04, 0xff, 0x01, 0xfe, 0xf5, 0xfa, 0xfc, 0xfb, 0x03, 0x06, 0x09, 0x08, + 0xfd, 0xf5, 0xfd, 0x0e, 0xfa, 0xfb, 0x05, 0xf6, 0xfa, 0x01, 0x03, 0x0a, 0x04, 0xfb, 0xff, 0xfc, 0xfe, 0x01, 0xfc, 0xfc, 0x01, 0x04, + 0x03, 0xf8, 0xf9, 0x0d, 0x01, 0xf6, 0xf7, 0xfb, 0xf9, 0xfc, 0x06, 0x0a, 0x02, 0xfa, 0xfe, 0xf1, 0xf5, 0x04, 0xff, 0xf7, 0xfa, 0x04, + 0x05, 0xfd, 0xfa, 0x06, 0x08, 0x04, 0xfc, 0xee, 0xf7, 0x01, 0xfc, 0x05, 0x0a, 0x05, 0xf6, 0xfb, 0x02, 0x03, 0x04, 0x03, 0x00, 0x00, + 0xfd, 0x03, 0x09, 0x02, 0x00, 0x04, 0x07, 0xfc, 0xf9, 0xfe, 0x05, 0x01, 0x05, 0x0a, 0x01, 0xff, 0x00, 0x01, 0xfe, 0xfb, 0xfa, 0xfa, + 0xfe, 0x04, 0x05, 0x00, 0xfe, 0xfc, 0xf9, 0x00, 0xff, 0xfa, 0xfc, 0xf5, 0xf8, 0x06, 0x0b, 0x05, 0xfe, 0xfb, 0xfa, 0xff, 0x02, 0xfa, + 0x00, 0x01, 0xfc, 0x04, 0x05, 0x02, 0xff, 0xff, 0xff, 0xfc, 0xf5, 0xf6, 0xfb, 0x02, 0x11, 0x0c, 0xfc, 0xf1, 0xfe, 0x06, 0x01, 0xfb, + 0xfe, 0x03, 0x01, 0xfc, 0xf9, 0xfc, 0x01, 0x0a, 0x09, 0xff, 0xf5, 0xff, 0x05, 0xfc, 0xfa, 0x01, 0x07, 0x01, 0x09, 0x06, 0xfc, 0x01, + 0xfe, 0xfc, 0xff, 0x08, 0x03, 0xfc, 0x00, 0x04, 0x09, 0x07, 0xf8, 0xfb, 0x02, 0xfd, 0x01, 0xfb, 0xf6, 0x08, 0xfe, 0xfc, 0x0a, 0x05, + 0xfb, 0xf8, 0xfe, 0xf4, 0xfb, 0x07, 0xfa, 0xf9, 0x02, 0x0a, 0x01, 0xfd, 0xff, 0x03, 0xf1, 0xf9, 0x0d, 0x02, 0xf9, 0xf7, 0xfc, 0x07, + 0x05, 0xfc, 0xfd, 0xf9, 0xfe, 0x04, 0xfa, 0xfc, 0x04, 0x07, 0x04, 0x00, 0x01, 0x06, 0xfe, 0xf7, 0xf9, 0xff, 0x0a, 0x09, 0xfa, 0x00, + 0x04, 0x01, 0x00, 0x00, 0xfd, 0xfa, 0xfd, 0x01, 0x04, 0x05, 0xfe, 0x02, 0x08, 0x02, 0xfa, 0xfd, 0x07, 0xfc, 0x00, 0x06, 0x00, 0xff, + 0x05, 0x0a, 0x05, 0xfe, 0xf9, 0xf9, 0xfe, 0x08, 0x06, 0xf3, 0x00, 0x05, 0xfe, 0xfe, 0x07, 0x04, 0xf5, 0xfd, 0xfd, 0xf9, 0x02, 0xf6, + 0xf6, 0x02, 0xfb, 0x02, 0x06, 0xff, 0xfe, 0x01, 0x00, 0xf6, 0xf2, 0xfa, 0x05, 0xff, 0x04, 0x05, 0xf8, 0xfd, 0xfe, 0xfb, 0xff, 0x01, + 0xfb, 0xf6, 0xff, 0x0d, 0x0a, 0xf6, 0xf9, 0x02, 0x05, 0x01, 0xfb, 0xf6, 0xf8, 0x02, 0x0b, 0x0e, 0x0a, 0x02, 0xfd, 0xfb, 0xf9, 0xff, + 0x01, 0xfb, 0x0d, 0x07, 0xf9, 0x01, 0x04, 0x00, 0xff, 0x11, 0xfc, 0xf0, 0x05, 0x01, 0xfd, 0x00, 0x0a, 0xff, 0xfd, 0x05, 0xfb, 0xf7, + 0xf9, 0xfc, 0x07, 0x0a, 0x05, 0xfe, 0x02, 0x03, 0xfd, 0xfb, 0x02, 0x03, 0xf9, 0xf7, 0xfc, 0x05, 0x0c, 0x04, 0xfb, 0xfa, 0x04, 0xfe, + 0xf7, 0x00, 0xfe, 0xf8, 0xf9, 0x09, 0x01, 0xfb, 0x02, 0xf9, 0xfb, 0x03, 0x03, 0xf3, 0xf4, 0x03, 0x01, 0xff, 0xfe, 0xff, 0xf8, 0xfd, + 0x03, 0x00, 0xf2, 0xf7, 0x08, 0xfc, 0x05, 0x08, 0xf6, 0xfd, 0x03, 0x04, 0x06, 0x08, 0xfe, 0xf3, 0x01, 0x08, 0x06, 0x06, 0xfd, 0x05, + 0x0c, 0xf7, 0x01, 0x08, 0xfd, 0xf6, 0xfa, 0x02, 0x03, 0xfe, 0xfd, 0x00, 0x00, 0x02, 0x06, 0x08, 0xf8, 0xf9, 0x00, 0xf8, 0x01, 0x03, + 0xff, 0x08, 0x07, 0x00, 0xfe, 0xfb, 0xfc, 0xff, 0x01, 0xfa, 0xfb, 0x04, 0x04, 0xfe, 0xfe, 0x07, 0x04, 0x00, 0xfd, 0xf6, 0x01, 0x04, + 0xfc, 0xfc, 0x08, 0x0c, 0xfe, 0xfe, 0xf7, 0xf5, 0x09, 0x01, 0xf8, 0xfc, 0xfb, 0xfb, 0xfd, 0x00, 0x02, 0xf8, 0xf2, 0x02, 0x01, 0xf7, + 0xf7, 0x01, 0x11, 0x10, 0xf5, 0xf9, 0xff, 0xfc, 0xf6, 0x04, 0x0d, 0x03, 0xfc, 0x01, 0x05, 0xfb, 0x02, 0x03, 0xfd, 0x04, 0x02, 0xfb, + 0xf9, 0x03, 0x01, 0x01, 0x12, 0x0c, 0xf8, 0xec, 0xff, 0x01, 0xfc, 0x00, 0x09, 0x0b, 0x05, 0x03, 0xf6, 0xf6, 0x04, 0x01, 0x01, 0x01, + 0xf9, 0xf8, 0xfe, 0x03, 0xfb, 0x08, 0x05, 0xf2, 0x04, 0x08, 0xff, 0xfd, 0xf8, 0xfb, 0x02, 0x09, 0x01, 0x00, 0x08, 0x00, 0xf2, 0xf1, + 0x04, 0x07, 0x04, 0x01, 0x01, 0xf9, 0xf9, 0x03, 0xfc, 0xfd, 0x05, 0x03, 0x01, 0xfa, 0xf5, 0xfb, 0x01, 0x02, 0x01, 0x01, 0xfe, 0xfc, + 0x01, 0xff, 0xfb, 0xfa, 0xfe, 0x01, 0x05, 0x0a, 0xff, 0xf5, 0xf8, 0x03, 0x0b, 0x08, 0xfd, 0x03, 0xfe, 0xf9, 0xff, 0x05, 0x0a, 0x07, + 0xfa, 0xff, 0x02, 0xf8, 0xfd, 0x01, 0xff, 0xfb, 0x07, 0x05, 0xfa, 0x04, 0x00, 0xfb, 0x00, 0x02, 0x05, 0x04, 0xfa, 0xfe, 0x07, 0x0a, + 0xfb, 0xfa, 0x02, 0x06, 0xf4, 0xfb, 0x09, 0xf9, 0xfb, 0x06, 0x0a, 0xf2, 0xfe, 0x09, 0xf5, 0xf0, 0xf8, 0x02, 0x03, 0x03, 0x04, 0x06, + 0x08, 0xfe, 0xf6, 0xfd, 0x08, 0x05, 0xfb, 0xfe, 0x03, 0x01, 0xf8, 0xff, 0xfd, 0xfd, 0x09, 0x03, 0xf8, 0xf5, 0xfc, 0xfe, 0xfe, 0x01, + 0x06, 0x0c, 0x08, 0xf9, 0xfa, 0x01, 0x02, 0xf7, 0x03, 0x0b, 0xfd, 0xff, 0xff, 0xfe, 0xfe, 0x06, 0x00, 0xf3, 0xfc, 0xff, 0xfe, 0xff, + 0x00, 0x03, 0x05, 0x01, 0xfb, 0xfd, 0x06, 0x08, 0xfd, 0xf8, 0x06, 0xfe, 0xfe, 0x04, 0xff, 0x00, 0x05, 0x07, 0xf9, 0xfb, 0x01, 0xfb, + 0xfb, 0x00, 0x02, 0x00, 0xff, 0xfb, 0xf6, 0x04, 0xff, 0xf7, 0x04, 0x06, 0xfd, 0xf8, 0x0c, 0x07, 0xfd, 0xff, 0x05, 0x02, 0xfa, 0xf5, + 0xfd, 0x03, 0xff, 0x02, 0xfb, 0xf9, 0x01, 0x0a, 0x06, 0xfb, 0xf4, 0x02, 0x05, 0xf7, 0xff, 0xff, 0x02, 0x12, 0xff, 0xf9, 0x00, 0xfd, + 0xf9, 0x00, 0x0c, 0x03, 0xfc, 0xfe, 0x0a, 0x00, 0xfd, 0x02, 0x03, 0xf5, 0xf3, 0x02, 0x01, 0x02, 0x07, 0x0e, 0x00, 0xf8, 0xfb, 0xff, + 0xfa, 0xfa, 0x03, 0x00, 0xf9, 0xfa, 0x08, 0xfd, 0xfe, 0x0a, 0xf6, 0xf9, 0x04, 0x02, 0xf9, 0xf7, 0xff, 0x07, 0x07, 0x04, 0x04, 0x04, + 0xf9, 0xf2, 0xfb, 0xfc, 0x03, 0x0a, 0x04, 0xf7, 0xf6, 0x00, 0xfa, 0xfc, 0x01, 0x01, 0xfb, 0x01, 0x06, 0xf9, 0xf7, 0xfe, 0x04, 0x00, + 0xfd, 0x01, 0x06, 0x00, 0xfa, 0xfa, 0xfe, 0x05, 0x08, 0x04, 0x02, 0x04, 0x00, 0xf3, 0xfc, 0x05, 0x02, 0xf9, 0x01, 0x07, 0xfc, 0x03, + 0xfb, 0xf1, 0xfd, 0x0b, 0x07, 0xf9, 0x05, 0x01, 0xfd, 0x06, 0x01, 0x02, 0x09, 0x03, 0x06, 0x00, 0xf5, 0xfb, 0x07, 0x09, 0xfc, 0xfa, + 0xfe, 0x00, 0xf9, 0x02, 0x08, 0x02, 0xff, 0xfe, 0xfd, 0xfc, 0x02, 0x04, 0x00, 0xfe, 0x04, 0x04, 0xfb, 0xf4, 0xfd, 0x06, 0xff, 0xf7, + 0xfd, 0x08, 0x05, 0xf4, 0xf2, 0x09, 0x04, 0xff, 0xfd, 0xf9, 0xfd, 0x00, 0xff, 0xfb, 0x04, 0x06, 0xf6, 0xff, 0x03, 0xfd, 0xfc, 0xfb, + 0xfa, 0xfc, 0xfa, 0x02, 0x06, 0xfa, 0x06, 0x01, 0xf3, 0xfb, 0xfd, 0xfe, 0x04, 0x0f, 0x0a, 0x00, 0xff, 0xff, 0xfd, 0xfe, 0x06, 0x05, + 0x00, 0xfd, 0xfa, 0xfe, 0x04, 0x04, 0x00, 0xfe, 0xfe, 0x00, 0xfc, 0xf9, 0xfc, 0xfa, 0xfe, 0x04, 0x07, 0xff, 0xfc, 0x00, 0xfd, 0x04, + 0x0b, 0x0a, 0x03, 0xff, 0xff, 0x03, 0xfe, 0x00, 0x07, 0xfe, 0xfa, 0xfb, 0xfb, 0xfc, 0x00, 0x03, 0xfd, 0x02, 0x02, 0xfa, 0xfe, 0x01, + 0x03, 0x07, 0xfd, 0xfa, 0x00, 0x01, 0xfd, 0xff, 0x07, 0x00, 0x00, 0xff, 0xf5, 0xf9, 0xfd, 0xfd, 0xf9, 0x01, 0x04, 0xfc, 0xf7, 0xfc, + 0x02, 0xff, 0xfe, 0x02, 0x07, 0xfe, 0xff, 0x02, 0xfc, 0x00, 0x02, 0x00, 0xfe, 0x05, 0x07, 0x00, 0xf9, 0xf9, 0xff, 0x04, 0x04, 0xfd, + 0xf8, 0xfa, 0xfc, 0xff, 0x01, 0xf7, 0xfb, 0x06, 0x0b, 0xfa, 0xf9, 0x04, 0xfd, 0x04, 0x0b, 0x07, 0xfa, 0xff, 0x07, 0xff, 0x06, 0x06, + 0xff, 0xfa, 0x00, 0x05, 0x00, 0x01, 0x02, 0x00, 0xfc, 0xfb, 0x00, 0x06, 0xfe, 0xff, 0x04, 0x04, 0xfc, 0xfd, 0x03, 0x02, 0x02, 0xff, + 0xfb, 0xfa, 0x00, 0x02, 0xfa, 0x04, 0x02, 0xf9, 0x00, 0xfb, 0xf9, 0x00, 0xff, 0x01, 0x01, 0xfc, 0xf9, 0xfd, 0x07, 0x0b, 0x03, 0xf8, + 0xf6, 0xf9, 0xff, 0x03, 0x01, 0xfe, 0xff, 0x01, 0xfe, 0xff, 0x02, 0x01, 0xf8, 0xf8, 0x01, 0x08, 0x07, 0x02, 0x00, 0x03, 0x00, 0xff, + 0x05, 0x01, 0xfc, 0xfa, 0xfc, 0xfb, 0xfc, 0x00, 0x03, 0x01, 0xff, 0x00, 0xfc, 0xfd, 0xff, 0xfc, 0xfa, 0x04, 0x12, 0x01, 0xf9, 0x03, + 0x13, 0xfa, 0xf5, 0x04, 0xff, 0x04, 0x07, 0x02, 0x00, 0xfd, 0xf8, 0xf7, 0x03, 0x06, 0xfe, 0xf7, 0xfa, 0xff, 0x02, 0x01, 0x02, 0x02, + 0xfd, 0x00, 0x06, 0x06, 0xfb, 0xf9, 0xff, 0x07, 0x02, 0x00, 0x01, 0x00, 0xf6, 0xf8, 0x04, 0x00, 0x02, 0x01, 0xfb, 0x01, 0x05, 0x00, + 0xfd, 0xf9, 0xfe, 0x07, 0xfd, 0xfc, 0x02, 0x07, 0x05, 0x08, 0x0b, 0x03, 0xfb, 0xfd, 0x04, 0xf2, 0xfe, 0x0d, 0x01, 0xfe, 0xfe, 0xfe, + 0xf7, 0xfc, 0x03, 0x05, 0xff, 0xfb, 0xfc, 0xff, 0x04, 0x04, 0x00, 0x03, 0x01, 0xfd, 0xfd, 0xfc, 0x02, 0x06, 0xfc, 0xfd, 0x00, 0xff, + 0xf7, 0xfa, 0xfd, 0xfa, 0xfe, 0x02, 0x03, 0x00, 0xfc, 0xfc, 0xff, 0xfa, 0xf9, 0xfe, 0x03, 0x05, 0xff, 0xf8, 0xff, 0xfc, 0xfb, 0x00, + 0x08, 0x02, 0xfa, 0xfe, 0x02, 0x02, 0xfe, 0xfe, 0x02, 0xff, 0xf7, 0x04, 0x04, 0x01, 0x05, 0x01, 0xfa, 0xf8, 0x01, 0x02, 0x02, 0x06, + 0x04, 0xfc, 0xf8, 0xff, 0x00, 0x04, 0x07, 0x01, 0xfc, 0xfd, 0x02, 0x04, 0xff, 0xfc, 0x00, 0x05, 0x04, 0x01, 0x05, 0x06, 0x00, 0xf7, + 0xfa, 0x05, 0x09, 0xfc, 0x01, 0x08, 0x05, 0x00, 0xf6, 0xf5, 0xff, 0x0b, 0x03, 0xf4, 0xfa, 0x02, 0x04, 0x00, 0x07, 0xfc, 0xf1, 0xf9, + 0xfc, 0xfd, 0xff, 0x0a, 0x00, 0xf5, 0xf9, 0x04, 0x00, 0xf9, 0x03, 0xfb, 0xf6, 0xfb, 0x01, 0x01, 0x01, 0x03, 0xfe, 0xfd, 0xff, 0xfa, + 0xfb, 0xfd, 0xff, 0xfd, 0x05, 0x06, 0xf9, 0xf8, 0x02, 0x09, 0xfd, 0xfa, 0xfe, 0x04, 0x07, 0xff, 0xf9, 0x02, 0xfb, 0xfb, 0x04, 0x06, + 0x04, 0x02, 0x02, 0x05, 0xfe, 0xf8, 0xff, 0x01, 0x03, 0x05, 0x02, 0x00, 0x02, 0x05, 0xfc, 0xfe, 0x06, 0x05, 0x02, 0x01, 0x01, 0xf7, + 0xfb, 0x00, 0x00, 0x02, 0x06, 0x04, 0xf9, 0xfb, 0x05, 0x09, 0xf6, 0xff, 0x08, 0xfb, 0x03, 0x05, 0xfe, 0xf2, 0x01, 0x04, 0xf7, 0xff, + 0x05, 0x03, 0xfc, 0xfa, 0xfd, 0xfe, 0xf6, 0xf7, 0xfb, 0xfe, 0xfe, 0x02, 0x01, 0xf8, 0x03, 0x07, 0xfe, 0xf8, 0xfb, 0x02, 0x04, 0xfe, + 0xfd, 0xff, 0xfd, 0x06, 0x04, 0xf9, 0xf9, 0x05, 0x03, 0xf0, 0x01, 0x05, 0xff, 0x03, 0x05, 0x00, 0xfa, 0xfa, 0x00, 0x02, 0xfd, 0x08, + 0x07, 0x00, 0x06, 0x02, 0xfe, 0x00, 0x0a, 0x01, 0xfa, 0x04, 0xff, 0xf7, 0xf7, 0x05, 0x03, 0x01, 0x04, 0xfd, 0xfe, 0x02, 0x02, 0x01, + 0x07, 0x09, 0xfb, 0xf9, 0xff, 0x04, 0x00, 0x02, 0x06, 0x02, 0xf9, 0xfb, 0x04, 0x02, 0xff, 0xfb, 0xf8, 0xfd, 0x02, 0x02, 0xfd, 0xfb, + 0xfc, 0xfe, 0x03, 0x02, 0xfe, 0xfa, 0xfc, 0xfd, 0xfe, 0x01, 0x01, 0x04, 0x07, 0xfa, 0xf9, 0xfc, 0xfa, 0xf9, 0xfe, 0x05, 0x02, 0x01, + 0xfc, 0xf8, 0xff, 0x03, 0x02, 0x00, 0xf8, 0x00, 0x0c, 0x04, 0x00, 0x00, 0x01, 0xfd, 0xfe, 0x03, 0x03, 0x01, 0xff, 0x00, 0x04, 0x08, + 0x04, 0xfc, 0xfc, 0x02, 0x03, 0xfb, 0xfa, 0xfe, 0x04, 0x06, 0x03, 0x02, 0x08, 0xfa, 0xfa, 0xff, 0xf6, 0xfa, 0x06, 0x0c, 0xfd, 0x01, + 0x08, 0x01, 0xf8, 0xfa, 0x00, 0x00, 0xfe, 0x01, 0x07, 0x02, 0xfd, 0xfd, 0x02, 0xfb, 0x02, 0x0a, 0xf9, 0xf9, 0xfd, 0xfc, 0x01, 0x04, + 0x01, 0xfd, 0xfc, 0x00, 0x01, 0xf7, 0xf9, 0x00, 0x03, 0x03, 0x00, 0xfe, 0x03, 0xfd, 0xfc, 0x01, 0x01, 0x02, 0x01, 0xfe, 0x02, 0x04, + 0x02, 0xff, 0xff, 0xfe, 0xfd, 0xfd, 0x01, 0x00, 0xfa, 0xfe, 0x02, 0x02, 0xfe, 0x01, 0x05, 0x06, 0xff, 0x02, 0x06, 0xfe, 0x04, 0x04, + 0x00, 0x01, 0x03, 0xfc, 0xf3, 0xfd, 0x07, 0x06, 0xff, 0xf9, 0xfb, 0x00, 0x00, 0xfe, 0xfb, 0xfb, 0x00, 0x00, 0xfe, 0x01, 0x05, 0x00, + 0xf8, 0x02, 0x04, 0xff, 0xfc, 0xff, 0x00, 0xff, 0x01, 0x04, 0xfd, 0xf3, 0x03, 0xfa, 0xf5, 0x07, 0x02, 0xfc, 0xfe, 0x06, 0x02, 0xfc, + 0xf9, 0x02, 0xff, 0xfa, 0xfe, 0x02, 0x04, 0x04, 0x04, 0xff, 0xfb, 0xfb, 0xfb, 0xfe, 0x03, 0x06, 0xfe, 0xfb, 0xfe, 0xff, 0xff, 0x04, + 0x09, 0xf8, 0xf4, 0xfc, 0x02, 0xff, 0xfe, 0x02, 0x06, 0x07, 0x06, 0x04, 0x01, 0xfd, 0xfc, 0x00, 0x08, 0x08, 0x05, 0x03, 0x05, 0xfe, + 0xf0, 0xfb, 0x05, 0x07, 0x04, 0x02, 0xfc, 0xf5, 0xfb, 0x01, 0x00, 0xfc, 0x05, 0x01, 0xf6, 0xf8, 0xfa, 0xfc, 0xfe, 0x05, 0x0b, 0x06, + 0xf6, 0xfe, 0x01, 0xfd, 0xfe, 0xfd, 0xfd, 0x00, 0xfc, 0xfb, 0xfd, 0xfc, 0x01, 0xfe, 0xfa, 0x04, 0x02, 0xfa, 0xfa, 0x01, 0x02, 0xff, + 0x00, 0xfc, 0x01, 0x0a, 0x02, 0xfc, 0xf9, 0xf8, 0x00, 0x01, 0x00, 0x06, 0x03, 0xff, 0xff, 0xfe, 0xfc, 0xfc, 0xfe, 0xfd, 0xfc, 0xfd, + 0x00, 0x06, 0x08, 0x07, 0x04, 0x03, 0x03, 0x02, 0xfd, 0xfd, 0x01, 0xfd, 0x02, 0x06, 0x04, 0xfc, 0xfe, 0x03, 0x02, 0x00, 0x01, 0x02, + 0xf9, 0x04, 0x09, 0xfe, 0xfd, 0xfd, 0xff, 0x03, 0x02, 0xfe, 0xfc, 0xfc, 0x00, 0x04, 0x06, 0x03, 0xfe, 0xfc, 0xfb, 0xff, 0xfc, 0xf4, + 0xf7, 0xf9, 0xfe, 0x06, 0x00, 0xff, 0x02, 0x00, 0xff, 0xfa, 0xf6, 0x0a, 0x05, 0xf7, 0xf7, 0xfd, 0xfe, 0xfb, 0xff, 0x01, 0x02, 0x02, + 0xfb, 0xfd, 0x00, 0xfd, 0x05, 0x04, 0xfe, 0x00, 0xfc, 0xf9, 0xfc, 0xff, 0xfb, 0xfc, 0x0b, 0x01, 0xff, 0x05, 0xfe, 0xf9, 0xfa, 0xfe, + 0x01, 0x01, 0xfe, 0xff, 0xfb, 0xfe, 0x04, 0x03, 0x03, 0x06, 0x08, 0x04, 0xfd, 0xfd, 0x0d, 0x06, 0xfc, 0xfd, 0x03, 0x06, 0x07, 0x09, + 0x01, 0xfc, 0xfc, 0xfc, 0xf8, 0xfa, 0x03, 0x02, 0x01, 0x01, 0x01, 0xf4, 0xf9, 0x08, 0x02, 0x02, 0x01, 0xfb, 0xf6, 0xfb, 0x04, 0x07, + 0x07, 0xff, 0xf8, 0xfd, 0xfe, 0xfc, 0xfc, 0xf8, 0xfa, 0xfe, 0xff, 0xf7, 0xfc, 0x08, 0xf8, 0xfa, 0x02, 0xff, 0x02, 0xff, 0xfd, 0x06, + 0x02, 0xfe, 0xff, 0xff, 0x03, 0x03, 0xfb, 0xfd, 0x02, 0x01, 0xf7, 0x00, 0x06, 0xff, 0x01, 0xfd, 0xfb, 0x01, 0x00, 0x03, 0x03, 0xf6, + 0xfd, 0x07, 0x05, 0x01, 0xfa, 0xf8, 0xfd, 0x0b, 0x09, 0xfc, 0x00, 0xfc, 0xfc, 0x05, 0x08, 0x01, 0xfd, 0x06, 0x00, 0xfa, 0xfa, 0x02, + 0xff, 0x01, 0x0b, 0x06, 0xfc, 0xf6, 0xf9, 0x01, 0x05, 0x05, 0x0a, 0x01, 0xfc, 0x02, 0xfb, 0xfe, 0x05, 0x04, 0x00, 0xff, 0xff, 0xfa, + 0xfb, 0x00, 0x03, 0x03, 0xfb, 0xf4, 0xfd, 0xff, 0xfe, 0xfe, 0xfe, 0x00, 0xff, 0xf9, 0x04, 0x07, 0xff, 0xf8, 0x01, 0x05, 0xfb, 0xff, + 0x00, 0xff, 0x02, 0xf9, 0xfa, 0x05, 0x02, 0xfe, 0xff, 0x04, 0x09, 0x02, 0xfa, 0xff, 0xff, 0xfa, 0xf7, 0xff, 0x04, 0x06, 0x04, 0x0b, + 0xff, 0xf2, 0xfe, 0x07, 0x03, 0xfa, 0xfb, 0x00, 0x00, 0xf8, 0xff, 0x05, 0x03, 0xfc, 0xfe, 0x01, 0xff, 0x02, 0xfe, 0xfd, 0x05, 0x01, + 0x01, 0x04, 0x00, 0xfc, 0xfd, 0x00, 0xfc, 0xff, 0x06, 0x0b, 0xfe, 0xfa, 0x01, 0x05, 0xfd, 0xfb, 0x04, 0xfa, 0xf8, 0x00, 0x08, 0x04, + 0xff, 0x00, 0x04, 0x00, 0xfc, 0x00, 0x01, 0xfa, 0xf6, 0x02, 0x06, 0x04, 0x00, 0xff, 0xf8, 0xf7, 0x00, 0x01, 0xff, 0xff, 0x05, 0x04, + 0x02, 0x00, 0x01, 0xfe, 0xfb, 0xfc, 0x02, 0x00, 0xfb, 0x02, 0x02, 0xff, 0x00, 0x07, 0x08, 0x01, 0xfb, 0xf4, 0xfb, 0x06, 0x02, 0xff, + 0x00, 0x03, 0x06, 0x01, 0xfa, 0xfb, 0xf8, 0xff, 0x0a, 0xfd, 0xfc, 0xfd, 0xfa, 0xfd, 0xff, 0xfd, 0xf9, 0xff, 0x03, 0x01, 0xfe, 0xfc, + 0xfa, 0xfa, 0x00, 0x02, 0x02, 0x05, 0x01, 0xfa, 0xf6, 0x04, 0xff, 0xf8, 0x03, 0x0a, 0x09, 0x02, 0x00, 0xff, 0xfc, 0xfa, 0xfc, 0x02, + 0x03, 0xfd, 0xfa, 0xfb, 0x00, 0x05, 0x06, 0x01, 0xfb, 0x03, 0x04, 0xfd, 0xfc, 0xfd, 0x01, 0x07, 0x0b, 0x06, 0x03, 0x05, 0xfd, 0xfa, + 0xff, 0x02, 0x06, 0x05, 0x01, 0x04, 0xfc, 0xf5, 0xf9, 0x05, 0x04, 0xfc, 0x01, 0xfd, 0xfb, 0x01, 0x0f, 0x0a, 0xff, 0xfc, 0x06, 0xfe, + 0xf1, 0xfc, 0xff, 0x01, 0x05, 0x02, 0x00, 0x00, 0xfc, 0xfb, 0xfd, 0xfc, 0xf2, 0xfa, 0x02, 0x01, 0xfe, 0xfe, 0xff, 0xfe, 0xff, 0xff, + 0xfe, 0xfe, 0xfd, 0xff, 0x02, 0xff, 0xfd, 0xfc, 0xfb, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0xfd, 0xff, 0xfe, 0x02, 0x06, 0xff, 0x00, 0xff, + 0xfc, 0xfe, 0xfd, 0x00, 0x09, 0x01, 0x04, 0x0a, 0xff, 0xfa, 0xfd, 0x04, 0x04, 0x06, 0x04, 0xfc, 0xf9, 0xfe, 0x03, 0x01, 0xfb, 0xfc, + 0x04, 0x03, 0x04, 0x07, 0x05, 0x00, 0xfd, 0xff, 0x01, 0x08, 0x04, 0xf9, 0xfe, 0x0b, 0x0c, 0xf7, 0xfc, 0xff, 0xfc, 0x03, 0x02, 0xfd, + 0xfd, 0xff, 0x01, 0x02, 0xff, 0xfb, 0xf9, 0xfb, 0x05, 0x03, 0xfd, 0xfe, 0x05, 0x07, 0x03, 0x01, 0xf9, 0xf8, 0xff, 0x00, 0xff, 0xfd, + 0xfd, 0xfa, 0xfc, 0x00, 0x05, 0xfc, 0xfa, 0x02, 0xf9, 0xf9, 0xfe, 0xfe, 0x02, 0x02, 0xfd, 0x01, 0xfd, 0xf7, 0xf7, 0x04, 0xff, 0xf6, + 0x00, 0x02, 0x04, 0x05, 0xfd, 0x02, 0x03, 0xf8, 0xfc, 0xfd, 0xfd, 0x03, 0x03, 0x00, 0x01, 0x06, 0xff, 0xfb, 0x03, 0x05, 0x04, 0xff, + 0xfa, 0xf8, 0xfd, 0x04, 0x06, 0x04, 0x00, 0xfb, 0x00, 0x01, 0xff, 0xff, 0x05, 0x03, 0xf9, 0x01, 0x03, 0xff, 0xff, 0xfa, 0xff, 0x07, + 0x00, 0xfd, 0xfd, 0xfd, 0x03, 0x01, 0xfe, 0x05, 0x04, 0x03, 0x03, 0x01, 0xf5, 0xf4, 0x03, 0x09, 0x03, 0xfe, 0x08, 0x02, 0xfa, 0xfb, + 0x07, 0x05, 0xfe, 0xfc, 0x00, 0xfe, 0xfa, 0xfc, 0x02, 0x00, 0xf9, 0x02, 0xfd, 0xf6, 0xfb, 0xf6, 0xfd, 0x05, 0xf9, 0xfc, 0x02, 0x03, + 0x0c, 0x04, 0xfa, 0xfd, 0xf7, 0xf9, 0x02, 0x07, 0x06, 0x05, 0x06, 0xfc, 0xfc, 0x00, 0xf9, 0x03, 0x01, 0xf6, 0x02, 0xf9, 0xf5, 0x05, + 0x05, 0x04, 0x02, 0xfd, 0xf6, 0xfa, 0x05, 0x00, 0x02, 0x06, 0x04, 0xfe, 0x00, 0x03, 0xfe, 0xfc, 0xff, 0x03, 0xfb, 0x00, 0x03, 0xfa, + 0x00, 0x08, 0x0a, 0x01, 0xfc, 0xf8, 0xf6, 0xfa, 0x00, 0x02, 0x01, 0x08, 0x07, 0x01, 0x04, 0x06, 0x06, 0x02, 0x02, 0xff, 0xfc, 0xfc, + 0x01, 0x03, 0x02, 0x00, 0x01, 0x00, 0xfd, 0xfa, 0xfd, 0xff, 0xfd, 0xfb, 0xff, 0x04, 0xfe, 0x01, 0xff, 0xf6, 0xff, 0x00, 0xfd, 0x03, + 0x05, 0x01, 0xfe, 0x06, 0x03, 0xfd, 0xfc, 0xf4, 0xfa, 0x05, 0x01, 0xfc, 0xfe, 0x04, 0xff, 0xfb, 0xfc, 0xff, 0x03, 0x03, 0xff, 0xfb, + 0xf8, 0xfb, 0x02, 0x00, 0x01, 0x04, 0x02, 0xfb, 0xf9, 0xfd, 0xff, 0xff, 0xfd, 0xfd, 0xfe, 0x04, 0x05, 0xfb, 0xfc, 0x05, 0x08, 0xfb, + 0xf7, 0xfc, 0x03, 0x05, 0x04, 0x02, 0xfe, 0x01, 0x00, 0xfd, 0x09, 0x05, 0xfd, 0xff, 0x02, 0xff, 0xfb, 0x02, 0x04, 0x09, 0x0f, 0x03, + 0xfc, 0xfe, 0xff, 0xfd, 0xfc, 0xfe, 0xff, 0x04, 0x02, 0xf9, 0x05, 0x04, 0xfd, 0xff, 0xfe, 0xfc, 0xfb, 0x00, 0x00, 0x00, 0x01, 0x06, + 0xfd, 0xf6, 0x02, 0x03, 0xfd, 0xfb, 0x05, 0x00, 0xfc, 0x00, 0x03, 0xff, 0xfb, 0xfb, 0xfd, 0xfa, 0xf6, 0xf8, 0xfe, 0x05, 0x07, 0x07, + 0x00, 0xf8, 0xf8, 0xfa, 0xfe, 0x02, 0x00, 0x01, 0x03, 0x01, 0xf5, 0xf8, 0x06, 0x09, 0x06, 0x00, 0xfb, 0xfe, 0xfe, 0xfc, 0xfc, 0x05, + 0x05, 0xfe, 0x00, 0xff, 0xfc, 0xfa, 0x03, 0x05, 0x03, 0x02, 0x04, 0x00, 0xfb, 0x08, 0x06, 0xfe, 0xfc, 0xfc, 0xfd, 0x00, 0x07, 0x01, + 0x02, 0x07, 0xfb, 0xfd, 0x00, 0xfa, 0xfd, 0x02, 0x03, 0xfa, 0x01, 0x02, 0xfa, 0xfe, 0x07, 0x0a, 0x05, 0xfc, 0xfc, 0x01, 0xfe, 0x02, + 0xff, 0xf7, 0xfd, 0x00, 0x01, 0x03, 0x04, 0x02, 0xfd, 0xfb, 0xfa, 0xfc, 0xff, 0xff, 0xff, 0x02, 0x07, 0x03, 0xfa, 0xf4, 0xfe, 0xff, + 0xff, 0x04, 0x06, 0x01, 0xfe, 0x05, 0x01, 0xff, 0x00, 0xff, 0xf6, 0xf5, 0x00, 0xff, 0x01, 0x05, 0xff, 0x01, 0xfe, 0xfa, 0x07, 0x06, + 0xfd, 0xf8, 0xf9, 0xff, 0x05, 0x02, 0x06, 0x05, 0xfc, 0xf9, 0xf9, 0xfa, 0xfc, 0x09, 0x07, 0xff, 0x0c, 0xfe, 0xf3, 0xfa, 0x01, 0x01, + 0x00, 0x04, 0xff, 0xfc, 0xff, 0x02, 0x03, 0x05, 0x06, 0xfe, 0xfb, 0xfe, 0x05, 0xfb, 0xf8, 0x00, 0x01, 0x05, 0x05, 0x00, 0xfa, 0xfb, + 0x01, 0x00, 0x03, 0x03, 0xfe, 0xf8, 0x00, 0x04, 0xf8, 0x03, 0x00, 0xf7, 0x00, 0x01, 0xfe, 0xfd, 0x05, 0x03, 0xff, 0x00, 0x01, 0x00, + 0xff, 0x04, 0x04, 0xff, 0xf7, 0xff, 0xff, 0x01, 0x0b, 0x08, 0xfc, 0xf5, 0x04, 0xfb, 0xf7, 0x02, 0xfb, 0xfc, 0x02, 0x01, 0x00, 0xfa, + 0xf8, 0x06, 0x09, 0x05, 0x02, 0xf8, 0xf5, 0xfc, 0x05, 0x06, 0x01, 0xff, 0xfd, 0x01, 0x00, 0xf6, 0xfe, 0x04, 0x03, 0xfd, 0xfe, 0xfa, + 0xf5, 0x02, 0xff, 0xfb, 0x05, 0xfe, 0xfc, 0x00, 0xfe, 0x01, 0x02, 0xfe, 0x02, 0x04, 0x03, 0x02, 0xf6, 0xf3, 0xfb, 0x02, 0x03, 0x03, + 0x04, 0xfb, 0xff, 0x02, 0xf8, 0xfe, 0x05, 0x03, 0xfa, 0x00, 0x08, 0x06, 0x00, 0xff, 0x01, 0x00, 0x03, 0x02, 0x00, 0xff, 0x04, 0x04, + 0xfd, 0xfb, 0x06, 0x0e, 0xff, 0x03, 0x02, 0xf6, 0xf9, 0xfe, 0x01, 0x02, 0x03, 0xff, 0xfb, 0xfe, 0xfb, 0xfc, 0x02, 0x02, 0x04, 0x02, + 0xfc, 0xf7, 0xf7, 0xfd, 0x06, 0x03, 0xff, 0x01, 0xf9, 0xfe, 0x04, 0xf9, 0xfe, 0x02, 0x01, 0xfe, 0x04, 0x01, 0xf4, 0xfa, 0x01, 0x01, + 0xf9, 0x01, 0x01, 0xf9, 0xfe, 0x02, 0x01, 0xfd, 0x06, 0xff, 0xf7, 0x03, 0x04, 0xfd, 0xf7, 0xfd, 0x00, 0x01, 0x02, 0x07, 0x02, 0xfc, + 0x04, 0xfd, 0xf8, 0xfd, 0x02, 0x00, 0x01, 0x06, 0x06, 0xfd, 0xf8, 0x04, 0x05, 0x02, 0x01, 0x02, 0x01, 0x01, 0x03, 0x02, 0x07, 0x0a, + 0xfe, 0xfe, 0x04, 0x03, 0xfd, 0xfe, 0x00, 0xf7, 0x06, 0x08, 0xf9, 0xf9, 0x00, 0x06, 0x03, 0x08, 0x04, 0xfd, 0xfd, 0x04, 0xfe, 0xf4, + 0xfe, 0x04, 0x06, 0x04, 0xfa, 0xf9, 0xfe, 0xfd, 0xfc, 0xfe, 0x03, 0x02, 0xff, 0xfb, 0xfd, 0xf4, 0xf9, 0x04, 0xff, 0xf9, 0xfc, 0x04, + 0xf2, 0xf7, 0x08, 0x0c, 0xfd, 0xf8, 0x01, 0x02, 0xf8, 0xf8, 0x05, 0xfb, 0xfe, 0x04, 0xfd, 0x02, 0x03, 0xfe, 0x02, 0xfc, 0xf9, 0xfd, + 0x06, 0x04, 0xff, 0x02, 0x03, 0xfd, 0xf7, 0xff, 0x04, 0x03, 0x00, 0xfd, 0xfe, 0x01, 0x01, 0x03, 0x04, 0x03, 0x05, 0x04, 0xfc, 0xf3, + 0x00, 0x03, 0xfe, 0x05, 0x01, 0x02, 0x07, 0x03, 0x01, 0x00, 0xfa, 0xff, 0x03, 0x02, 0xfe, 0x02, 0x05, 0x02, 0xfb, 0xff, 0x06, 0x02, + 0xfa, 0xfb, 0x02, 0xfb, 0x00, 0x03, 0xfc, 0x02, 0x03, 0xfd, 0xf7, 0xfa, 0xf8, 0xf3, 0x03, 0xfd, 0xf9, 0x05, 0x04, 0x01, 0x00, 0x00, + 0xf9, 0xf9, 0x01, 0xfe, 0xfa, 0xfa, 0xfe, 0x03, 0x01, 0xfc, 0xfe, 0x01, 0x01, 0xfd, 0xfc, 0xfc, 0xfe, 0x00, 0x07, 0x07, 0x00, 0xfe, + 0xfb, 0xfe, 0x03, 0x00, 0xfb, 0xfa, 0x00, 0x06, 0x0b, 0x0a, 0x02, 0x02, 0xfe, 0xf5, 0x01, 0x04, 0xfb, 0xf6, 0x01, 0x09, 0x05, 0x03, + 0xfa, 0xf6, 0xfd, 0x03, 0xfd, 0xf6, 0xfc, 0x02, 0x02, 0xff, 0x04, 0x03, 0x01, 0x02, 0x03, 0x00, 0xfd, 0xfd, 0x03, 0x05, 0x00, 0x04, + 0x02, 0xfd, 0xfe, 0x04, 0x05, 0x01, 0xfe, 0xfa, 0xfd, 0x04, 0xf9, 0xfa, 0x05, 0x0a, 0x03, 0xfc, 0xfa, 0xfe, 0xfb, 0xfa, 0x01, 0x04, + 0x00, 0xfb, 0xfd, 0xfe, 0x00, 0x02, 0x04, 0xfe, 0xfc, 0x01, 0xfe, 0xfc, 0xfd, 0x01, 0x02, 0x03, 0x02, 0x00, 0xfb, 0xfa, 0xfe, 0xff, + 0x01, 0x04, 0x02, 0x03, 0x07, 0x08, 0xfa, 0xfa, 0xfd, 0xf7, 0xfe, 0x05, 0x04, 0xfd, 0xff, 0x05, 0x06, 0xf9, 0xf8, 0xfd, 0xfb, 0xfd, + 0x00, 0xff, 0xfa, 0xfe, 0x02, 0xff, 0x06, 0x03, 0xfc, 0xfb, 0x02, 0x03, 0xfd, 0xf9, 0x04, 0x0c, 0x05, 0x06, 0x01, 0xf9, 0xf9, 0xfe, + 0x03, 0x05, 0x01, 0x00, 0x02, 0x04, 0x02, 0xfe, 0xfc, 0xff, 0x04, 0x03, 0xfd, 0xfe, 0xff, 0x01, 0x03, 0x07, 0x02, 0xfc, 0xfb, 0x04, + 0x04, 0xfc, 0x04, 0x04, 0xfc, 0xf6, 0x03, 0x07, 0xfd, 0xfa, 0xf8, 0xfb, 0xfe, 0x02, 0xfc, 0xf8, 0x00, 0x03, 0x03, 0x04, 0x03, 0x08, + 0x06, 0xfd, 0x01, 0x00, 0xfc, 0xfb, 0xfb, 0xff, 0x05, 0x06, 0x01, 0xfb, 0xf9, 0xff, 0x01, 0xfe, 0xfb, 0xfc, 0xfb, 0xf8, 0xfc, 0xfe, + 0xff, 0x01, 0x01, 0x00, 0xff, 0xfe, 0xf8, 0xf9, 0x04, 0x05, 0x07, 0x05, 0xff, 0xfd, 0x01, 0x02, 0xf9, 0xf7, 0xfc, 0x03, 0x06, 0x07, + 0x04, 0xfc, 0x03, 0x03, 0xfb, 0xfa, 0xfc, 0x02, 0x07, 0xfa, 0xfc, 0x08, 0x08, 0x05, 0x01, 0xfe, 0xfd, 0xf9, 0xfb, 0x03, 0x02, 0x01, + 0x03, 0x03, 0xff, 0x00, 0x04, 0x05, 0xfb, 0xf6, 0xfc, 0x02, 0x04, 0x03, 0x03, 0x03, 0x01, 0xfd, 0xf5, 0xfc, 0x04, 0xff, 0xff, 0xff, + 0xfc, 0xfc, 0xfc, 0x01, 0x07, 0x06, 0xfd, 0xf8, 0xfe, 0xfe, 0xfb, 0xfc, 0x02, 0x05, 0x00, 0xf9, 0xfd, 0x03, 0x02, 0xf7, 0xf8, 0x00, + 0x04, 0xf9, 0xfc, 0x01, 0x00, 0x03, 0x03, 0xff, 0xfa, 0xf8, 0xfd, 0x03, 0xff, 0xff, 0x04, 0x08, 0xfc, 0xfd, 0x05, 0x00, 0xfa, 0xf9, + 0xfd, 0xf8, 0xfc, 0x01, 0x00, 0x04, 0x05, 0x05, 0x06, 0x02, 0xfc, 0xfa, 0x00, 0x05, 0x05, 0x01, 0x03, 0x02, 0x01, 0x0e, 0x05, 0xf8, + 0xf6, 0x04, 0x03, 0xfa, 0xfb, 0x03, 0x07, 0x04, 0x03, 0x01, 0xfe, 0xf7, 0xf7, 0xf9, 0xff, 0x07, 0x08, 0x00, 0xfc, 0x08, 0x04, 0xfc, + 0xfe, 0xfc, 0xff, 0x02, 0xfd, 0xfb, 0x00, 0x06, 0x06, 0x01, 0xfd, 0xfb, 0xfb, 0xf6, 0xf3, 0xfd, 0xff, 0xfe, 0xff, 0x04, 0x06, 0x03, + 0xfb, 0xfb, 0xf9, 0xf9, 0x08, 0xff, 0xf6, 0xff, 0x0a, 0x09, 0x01, 0xfb, 0xfd, 0xfe, 0xfa, 0xff, 0xfa, 0xfa, 0x05, 0xff, 0xfc, 0x01, + 0x09, 0xfc, 0xf7, 0xfe, 0xfe, 0xfb, 0xfe, 0x09, 0x06, 0x06, 0x08, 0x05, 0xff, 0xfc, 0xfc, 0xfe, 0x00, 0x01, 0xfe, 0x00, 0x05, 0x07, + 0x03, 0x05, 0x04, 0xfd, 0xfa, 0xfc, 0xfe, 0xfd, 0x05, 0x07, 0x03, 0x03, 0x03, 0x00, 0xfb, 0xfe, 0x00, 0xff, 0xfa, 0xff, 0xff, 0xfd, + 0x09, 0x03, 0xfb, 0xfb, 0xfe, 0xfc, 0xfa, 0xfe, 0xff, 0xfc, 0xfb, 0x08, 0x03, 0xfb, 0xfe, 0x00, 0xff, 0xff, 0xff, 0xfe, 0xfd, 0xfe, + 0x03, 0x05, 0x04, 0x02, 0xfb, 0xfb, 0xff, 0xff, 0xfc, 0xfd, 0x01, 0x01, 0x03, 0x01, 0xfa, 0xf9, 0xfe, 0x04, 0x06, 0x02, 0xfb, 0xf5, + 0xf7, 0xff, 0x04, 0x00, 0xfe, 0xfd, 0xff, 0x03, 0xff, 0xf9, 0xf9, 0xfd, 0x01, 0x03, 0x04, 0x08, 0x07, 0x03, 0x03, 0x00, 0xfc, 0xfa, + 0xfa, 0xfd, 0x02, 0x01, 0x06, 0x03, 0xfb, 0x01, 0x05, 0x01, 0xf9, 0xff, 0x01, 0xfe, 0xfd, 0x00, 0x04, 0x05, 0x07, 0x05, 0xff, 0xf9, + 0x00, 0xff, 0xfb, 0xff, 0x06, 0x07, 0x01, 0xfc, 0xfe, 0x01, 0xfd, 0xf7, 0xf8, 0xfe, 0xfe, 0x03, 0x07, 0x07, 0x00, 0x05, 0x08, 0xfd, + 0xf3, 0xf6, 0x00, 0x05, 0x01, 0xfe, 0x04, 0x04, 0x04, 0x01, 0xf9, 0xf8, 0xfb, 0xfd, 0x00, 0x00, 0xff, 0xfe, 0xfe, 0xfd, 0xfc, 0x01, + 0xfd, 0xf9, 0xfb, 0x01, 0x01, 0xff, 0x00, 0x07, 0x04, 0xfc, 0x03, 0xff, 0xfb, 0xfd, 0x01, 0x04, 0x02, 0xfd, 0x00, 0x01, 0xff, 0xfe, + 0x00, 0x01, 0x00, 0xfb, 0x05, 0x0a, 0xfd, 0xf8, 0xfe, 0x05, 0xfd, 0x00, 0x03, 0x03, 0x05, 0x04, 0x00, 0xfb, 0xf8, 0xfc, 0x02, 0x05, + 0xff, 0xfd, 0x03, 0xff, 0xfd, 0xfe, 0xfa, 0xff, 0x04, 0x02, 0xfe, 0xff, 0x02, 0x03, 0x01, 0x02, 0x02, 0xfb, 0xfb, 0xfb, 0xfb, 0xfc, + 0x05, 0x07, 0xff, 0x00, 0x03, 0x03, 0xff, 0xf9, 0xf9, 0xfe, 0xf9, 0xfa, 0x01, 0x06, 0x07, 0x02, 0xfd, 0xf9, 0x02, 0x03, 0xf9, 0xfe, + 0x04, 0x04, 0x00, 0x00, 0x02, 0x02, 0xf9, 0xfb, 0xff, 0xfd, 0xfc, 0xff, 0x02, 0x00, 0x02, 0x04, 0x02, 0xfb, 0xfc, 0xfe, 0xfc, 0xfe, + 0xfe, 0xfe, 0x05, 0x03, 0x00, 0x01, 0xff, 0xfe, 0xfc, 0xfa, 0x02, 0x04, 0xfe, 0xf9, 0x00, 0x04, 0xff, 0xfe, 0xfd, 0xfd, 0xfc, 0x02, + 0x05, 0x02, 0xfd, 0x02, 0x03, 0xfd, 0x01, 0x01, 0xff, 0x03, 0x02, 0x01, 0xff, 0xf8, 0xfc, 0x00, 0xfe, 0xff, 0x01, 0x02, 0x05, 0xff, + 0xfd, 0x00, 0x01, 0x02, 0x01, 0xfd, 0xfe, 0xfe, 0xfe, 0x01, 0x01, 0x00, 0xff, 0xfb, 0xfc, 0xff, 0x00, 0x02, 0x00, 0xfe, 0x05, 0x03, + 0xff, 0xfe, 0xfd, 0xff, 0x01, 0x01, 0xff, 0xfd, 0xfd, 0x07, 0x02, 0xfd, 0x01, 0xfc, 0xfa, 0xfb, 0xfd, 0x00, 0xff, 0xfe, 0x02, 0x05, + 0x04, 0x00, 0xfd, 0xfa, 0xfb, 0xff, 0x04, 0x06, 0x04, 0xfc, 0xfc, 0x02, 0x05, 0xff, 0xf9, 0xfa, 0x01, 0xfc, 0xfa, 0x00, 0x06, 0x00, + 0xfb, 0x00, 0xff, 0xff, 0xff, 0xf9, 0xfd, 0x03, 0x02, 0xfe, 0xfd, 0x00, 0x03, 0x06, 0x04, 0xfd, 0xfc, 0xfd, 0x03, 0x08, 0x08, 0xfb, + 0xf6, 0x07, 0x01, 0xf8, 0xf9, 0xfd, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xff, 0x04, 0xff, 0xfd, 0x03, 0x03, 0x01, 0xfe, 0xfc, 0x02, 0x03, + 0x01, 0x01, 0x04, 0x06, 0x04, 0xfb, 0xfc, 0x02, 0x03, 0xfb, 0xf9, 0xff, 0x01, 0x02, 0x04, 0x05, 0xf9, 0xfa, 0x02, 0x03, 0xff, 0xfe, + 0x02, 0x03, 0xff, 0xfe, 0x01, 0xff, 0xf9, 0xfa, 0x05, 0xfe, 0xfa, 0xff, 0x04, 0x04, 0x03, 0x02, 0xfd, 0xfe, 0x00, 0xff, 0xf9, 0xfd, + 0x04, 0xfe, 0xfe, 0x01, 0x01, 0x06, 0x02, 0xfc, 0xff, 0x00, 0x01, 0x01, 0xfb, 0xff, 0x05, 0x02, 0xfd, 0xfb, 0xfe, 0x03, 0x06, 0xff, + 0xf5, 0xf7, 0x02, 0x06, 0x00, 0x02, 0x02, 0xfe, 0xf9, 0x01, 0x05, 0x00, 0xfe, 0xfc, 0xfd, 0xfd, 0x01, 0xff, 0xfc, 0x05, 0x07, 0x02, + 0xfb, 0xfc, 0xff, 0x00, 0xfe, 0x02, 0x03, 0x00, 0x03, 0x00, 0xfd, 0x00, 0xfe, 0xfc, 0xfd, 0x03, 0x06, 0x00, 0xf9, 0xff, 0x02, 0x01, + 0xff, 0xff, 0x00, 0x01, 0x03, 0xf9, 0xf8, 0x02, 0x03, 0x03, 0x03, 0x02, 0x02, 0x00, 0xfb, 0xfb, 0xfc, 0x00, 0x03, 0x01, 0xfc, 0xfc, + 0x02, 0xfc, 0xf9, 0xfc, 0x03, 0xfe, 0xfc, 0x01, 0x06, 0x00, 0xfb, 0x04, 0xff, 0xff, 0x04, 0xfd, 0xfd, 0x00, 0x00, 0xfd, 0xfc, 0x02, + 0x09, 0x02, 0xf7, 0xf6, 0x00, 0x01, 0xff, 0x00, 0x00, 0x02, 0x02, 0x01, 0xfc, 0xfb, 0x01, 0x05, 0x03, 0x00, 0x00, 0x03, 0x01, 0xfd, + 0x02, 0x04, 0x03, 0x00, 0xfc, 0xfb, 0xfe, 0x03, 0x00, 0x00, 0x01, 0xfd, 0xfe, 0xfe, 0xfd, 0xfd, 0xff, 0x03, 0x05, 0x01, 0xfc, 0xfb, + 0x00, 0xfc, 0xfd, 0x07, 0x04, 0x01, 0x00, 0x03, 0xfd, 0xf9, 0xfb, 0x02, 0xfc, 0xf8, 0xfe, 0x03, 0x03, 0x00, 0xfe, 0x01, 0xff, 0xfa, + 0xff, 0x01, 0x00, 0xfe, 0x01, 0xff, 0xfc, 0xff, 0x01, 0xff, 0xfd, 0x02, 0xfe, 0xfa, 0xff, 0x05, 0x04, 0xff, 0xfc, 0xfd, 0x01, 0x00, + 0xff, 0xfd, 0xfd, 0x01, 0x08, 0x06, 0xfe, 0x00, 0x02, 0x02, 0xff, 0x01, 0x03, 0x02, 0x01, 0xff, 0xff, 0xff, 0xfc, 0xff, 0x02, 0x01, + 0xfc, 0xfe, 0x02, 0x00, 0xfd, 0xfd, 0xff, 0x00, 0xfe, 0xfc, 0xfa, 0x03, 0x04, 0xff, 0xfe, 0x02, 0x01, 0xfc, 0x00, 0x04, 0x03, 0xfc, + 0xfd, 0xff, 0x00, 0x00, 0x02, 0x00, 0xfc, 0xfa, 0xfd, 0xfd, 0xf8, 0x03, 0x06, 0x00, 0x00, 0x02, 0xfe, 0xf9, 0xfe, 0x01, 0x01, 0xff, + 0xfc, 0x00, 0x06, 0x01, 0xfd, 0xfb, 0xfa, 0x05, 0x02, 0xfa, 0xff, 0x01, 0x03, 0x03, 0xff, 0xfe, 0xfe, 0xfd, 0x00, 0xfd, 0xfc, 0x03, + 0x06, 0x04, 0x01, 0x09, 0x03, 0xfb, 0xfd, 0xfe, 0xff, 0x02, 0x06, 0x01, 0xff, 0x03, 0x00, 0xfe, 0xff, 0x03, 0x00, 0xfe, 0xff, 0xfa, + 0xfe, 0x02, 0xff, 0xfe, 0x01, 0x01, 0xfe, 0xfe, 0x03, 0x05, 0xf7, 0xfa, 0x02, 0x04, 0xfe, 0x00, 0x02, 0xf8, 0xf8, 0xfe, 0x03, 0xff, + 0x02, 0x03, 0xfc, 0xf7, 0xfa, 0xff, 0xfc, 0xff, 0x03, 0x03, 0x02, 0xf9, 0xf4, 0xfb, 0x01, 0x01, 0xff, 0x03, 0xfe, 0xfe, 0x05, 0x00, + 0xff, 0x00, 0xfd, 0x01, 0x02, 0xfe, 0xfd, 0xfb, 0xfe, 0x06, 0x08, 0x00, 0xf9, 0xfd, 0xfd, 0x00, 0x00, 0xfb, 0xfe, 0x07, 0x0c, 0x03, + 0xfd, 0xfd, 0xfc, 0xfc, 0xfe, 0x03, 0x06, 0x09, 0x09, 0x05, 0x05, 0x04, 0xff, 0xfc, 0xf9, 0xfb, 0x01, 0x01, 0xff, 0x00, 0x04, 0x01, + 0xfe, 0xfd, 0xff, 0xf8, 0xf7, 0x01, 0x04, 0x02, 0x00, 0x05, 0xff, 0xfc, 0xfe, 0xfb, 0xfa, 0xfc, 0x00, 0x06, 0x03, 0x00, 0x03, 0x03, + 0xfd, 0xfa, 0xff, 0xfc, 0xf8, 0xf9, 0xfc, 0xfe, 0x00, 0xff, 0x00, 0x00, 0xfe, 0x00, 0xff, 0xfa, 0xf7, 0x01, 0x01, 0xfd, 0x05, 0x05, + 0x04, 0x03, 0xfb, 0xfd, 0x01, 0xfd, 0x03, 0x03, 0xff, 0x02, 0xfe, 0xfe, 0x01, 0x00, 0xfd, 0xfd, 0x02, 0xff, 0x01, 0x03, 0xfb, 0xfc, + 0x03, 0x08, 0x03, 0x03, 0x02, 0xfb, 0x00, 0x03, 0x02, 0x01, 0x01, 0x02, 0x03, 0x03, 0xff, 0xfd, 0x03, 0x02, 0x00, 0x00, 0xfe, 0xfc, + 0xfc, 0x01, 0x03, 0x02, 0xff, 0x00, 0xfc, 0xfc, 0xfe, 0xfd, 0xfd, 0xfe, 0xfe, 0x00, 0x02, 0x02, 0x00, 0x02, 0x01, 0xfd, 0xf8, 0xf9, + 0xfd, 0xff, 0x01, 0x03, 0x02, 0xfd, 0x01, 0xff, 0xf7, 0xff, 0x03, 0x00, 0xfc, 0xfb, 0xff, 0x03, 0xfd, 0x00, 0x02, 0x00, 0x03, 0x00, + 0xfa, 0xfb, 0xfd, 0x02, 0x05, 0x01, 0xfe, 0xff, 0x02, 0x00, 0xfd, 0xfc, 0x01, 0x06, 0x03, 0xfd, 0x02, 0x01, 0xff, 0x01, 0x05, 0x02, + 0xfd, 0x00, 0xff, 0x00, 0x03, 0xf9, 0x00, 0x06, 0xff, 0x00, 0x01, 0xff, 0xfb, 0x02, 0x04, 0xff, 0xfd, 0x02, 0x05, 0xff, 0x01, 0x04, + 0x01, 0xf6, 0xfa, 0x00, 0xff, 0x00, 0x01, 0x03, 0x04, 0xfc, 0xfa, 0x02, 0x08, 0x04, 0xfe, 0xff, 0xf8, 0xf7, 0xfd, 0x05, 0xff, 0xfe, + 0x04, 0x01, 0xff, 0xfe, 0xfe, 0x01, 0x00, 0xff, 0x03, 0xfe, 0xfb, 0xfd, 0xfd, 0xfd, 0x00, 0x02, 0x01, 0xfc, 0xfa, 0x01, 0x04, 0x02, + 0xfe, 0x00, 0xfe, 0xfc, 0xfe, 0xfe, 0xfe, 0xff, 0xfb, 0xfd, 0x00, 0x02, 0x03, 0x03, 0x00, 0xfb, 0x01, 0x02, 0xfd, 0xfc, 0xfc, 0xfd, + 0xfe, 0x00, 0x01, 0x03, 0x05, 0x00, 0xfe, 0x02, 0xfc, 0xff, 0x02, 0xfe, 0xfa, 0x00, 0x07, 0x01, 0xfb, 0xfb, 0x00, 0x03, 0xfd, 0xfa, + 0x02, 0xfe, 0xfe, 0x03, 0x0a, 0x00, 0xf9, 0xfc, 0x09, 0x03, 0xfb, 0x01, 0x00, 0xfc, 0xfb, 0xff, 0x03, 0x05, 0x02, 0x00, 0xfd, 0xfb, + 0xfe, 0xfc, 0xff, 0x04, 0x00, 0x04, 0x02, 0xf8, 0xfa, 0x00, 0x03, 0x01, 0xfd, 0xfc, 0x00, 0x06, 0xff, 0xfd, 0x05, 0xfc, 0xfb, 0x01, + 0x02, 0xfb, 0xfb, 0x03, 0x02, 0xff, 0xff, 0x02, 0xfd, 0xff, 0x03, 0x00, 0xfb, 0xfc, 0x03, 0x06, 0x05, 0x00, 0xfd, 0xfc, 0xfd, 0xff, + 0x00, 0x00, 0x01, 0x03, 0xff, 0xfc, 0xfc, 0xfd, 0xfb, 0xfe, 0x03, 0x01, 0x00, 0xfd, 0xfa, 0x04, 0xff, 0xf8, 0xff, 0x06, 0x02, 0xfb, + 0x05, 0x03, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xfd, 0x00, 0x00, 0xfd, 0xff, 0x04, 0x05, 0x00, 0xfb, 0xf9, 0xfc, 0x00, 0x04, 0x03, 0x00, + 0x04, 0x05, 0x02, 0xfe, 0xfd, 0xfa, 0xf9, 0x01, 0x01, 0xfe, 0xfd, 0x05, 0x05, 0x00, 0xfc, 0xfe, 0xff, 0xfd, 0xfa, 0xff, 0x01, 0xff, + 0x06, 0x08, 0x03, 0xfe, 0x04, 0x00, 0xf9, 0x05, 0x02, 0xfa, 0xf9, 0x03, 0x09, 0x06, 0x00, 0xfc, 0xfb, 0xfc, 0xfc, 0xff, 0x03, 0x04, + 0x02, 0x05, 0x04, 0xf6, 0xf8, 0xfa, 0xf8, 0xfc, 0x03, 0x05, 0x01, 0xfe, 0x00, 0x04, 0x08, 0xfd, 0xf8, 0xfe, 0xfc, 0xfa, 0xfb, 0x02, + 0xfc, 0xff, 0x07, 0x05, 0xfc, 0xf7, 0xfa, 0xff, 0xff, 0xff, 0x04, 0x04, 0xfd, 0xf8, 0xff, 0x02, 0xff, 0xfb, 0x02, 0xfe, 0xf9, 0x00, + 0x00, 0x02, 0x04, 0x00, 0x00, 0x02, 0x01, 0xfd, 0xff, 0x02, 0xfc, 0x02, 0x06, 0x01, 0xfc, 0x02, 0x05, 0xfd, 0x02, 0x02, 0xfe, 0xfb, + 0x01, 0x02, 0xfd, 0xfc, 0xff, 0x01, 0x00, 0xfa, 0x03, 0x0d, 0xfb, 0xfb, 0x01, 0x02, 0x00, 0x02, 0x04, 0x02, 0x04, 0x02, 0xfd, 0xff, + 0xff, 0xfd, 0xfc, 0xfe, 0x00, 0x01, 0x00, 0xfe, 0x00, 0x02, 0xff, 0xfd, 0xfc, 0xfd, 0xfb, 0xfc, 0xff, 0xff, 0x02, 0x03, 0x01, 0x01, + 0x02, 0xff, 0xf8, 0xfe, 0xfd, 0xfb, 0x01, 0x06, 0x02, 0xf8, 0xfc, 0xfa, 0xf9, 0xfd, 0xfb, 0x02, 0x08, 0x00, 0xfb, 0xfe, 0x03, 0xfe, + 0xfb, 0xfd, 0x02, 0x02, 0xfe, 0xfb, 0x02, 0x03, 0x02, 0x03, 0x03, 0x00, 0xfe, 0xfc, 0x00, 0xfe, 0xfb, 0xff, 0x06, 0x06, 0xff, 0xfb, + 0x02, 0x09, 0x02, 0x03, 0x01, 0xfd, 0x02, 0x02, 0xff, 0x00, 0x03, 0x01, 0xfe, 0x00, 0x00, 0x00, 0x00, 0xfd, 0xf8, 0xfa, 0x06, 0x03, + 0x02, 0x04, 0x00, 0xff, 0xfe, 0xfc, 0xfc, 0xfd, 0x00, 0x03, 0xfe, 0xfd, 0x04, 0x08, 0x02, 0xfa, 0xfa, 0xfe, 0xfe, 0xfc, 0xfd, 0x01, + 0x02, 0xff, 0xfd, 0xfb, 0xfe, 0x05, 0xfa, 0xf6, 0xfc, 0x01, 0x01, 0x00, 0x01, 0x02, 0xfd, 0xfa, 0xfe, 0xff, 0xfc, 0xfb, 0xff, 0x00, + 0x02, 0x04, 0xf9, 0x00, 0x09, 0x04, 0x01, 0xfd, 0xfa, 0xfc, 0x01, 0x02, 0x00, 0x00, 0x05, 0x08, 0x03, 0xfb, 0xff, 0x06, 0xfd, 0xff, + 0x03, 0x02, 0x01, 0x00, 0xff, 0x02, 0x01, 0xfe, 0xfe, 0x00, 0xff, 0x01, 0x07, 0xfb, 0xfe, 0x07, 0x02, 0xfc, 0xfe, 0x02, 0xfd, 0xfd, + 0xff, 0xfe, 0x06, 0x01, 0xfa, 0x01, 0x00, 0xfd, 0xfc, 0xf9, 0xfc, 0xff, 0xfd, 0xfd, 0xff, 0x01, 0xfe, 0x03, 0x04, 0xff, 0xfe, 0x01, + 0x01, 0xfc, 0xfe, 0xfe, 0xfd, 0xfe, 0x03, 0x00, 0xf9, 0x01, 0x00, 0xfd, 0x00, 0xff, 0xfc, 0xfb, 0xff, 0x03, 0x04, 0x01, 0xfc, 0xff, + 0x01, 0xfc, 0x00, 0x03, 0x02, 0x00, 0x00, 0x04, 0x07, 0x00, 0xfd, 0xff, 0x00, 0x02, 0x01, 0xfe, 0xff, 0x01, 0x04, 0x05, 0x00, 0xfc, + 0xfc, 0xff, 0x01, 0x02, 0x01, 0xfb, 0xfd, 0x02, 0x04, 0x03, 0xfc, 0xf9, 0x02, 0x02, 0xfd, 0xfc, 0x00, 0xff, 0xfe, 0x03, 0x01, 0xfd, + 0xfb, 0xfd, 0xff, 0x00, 0x00, 0xfd, 0x00, 0x02, 0xfe, 0xfe, 0x00, 0x01, 0x02, 0xfc, 0xfe, 0x05, 0x02, 0xfa, 0xf9, 0x04, 0x00, 0xfa, + 0xfa, 0xff, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xfd, 0xfb, 0xff, 0x00, 0x03, 0x05, 0x03, 0x06, 0x02, 0xfc, 0xfd, 0xff, 0xff, + 0xfd, 0xff, 0xfe, 0xfd, 0x00, 0x05, 0x02, 0xfb, 0xfa, 0x01, 0x03, 0xfc, 0xfe, 0x02, 0x03, 0x03, 0x01, 0x02, 0x02, 0xfb, 0xfe, 0x04, + 0x04, 0xfa, 0xfd, 0x06, 0x06, 0x04, 0xff, 0xfb, 0xfa, 0xfd, 0xfe, 0xfc, 0xfd, 0x02, 0x05, 0xfc, 0xfc, 0xfe, 0xfe, 0x01, 0xff, 0xfc, + 0xfd, 0x00, 0x02, 0x03, 0x04, 0xff, 0xfd, 0xfd, 0xfd, 0xfd, 0xff, 0x01, 0x02, 0xfd, 0xfa, 0x00, 0x02, 0x00, 0xfb, 0xfc, 0xfe, 0xff, + 0xff, 0x01, 0x00, 0xfd, 0x02, 0x05, 0x03, 0xfe, 0xfe, 0x00, 0x00, 0xfe, 0x02, 0x02, 0xfe, 0x00, 0x01, 0x00, 0xff, 0x01, 0x07, 0x06, + 0xf7, 0xfe, 0x07, 0x04, 0xf8, 0xfd, 0x03, 0xff, 0x00, 0x00, 0xff, 0x03, 0x00, 0xfe, 0xff, 0x01, 0xfd, 0xfc, 0x00, 0x05, 0x01, 0xfa, + 0xfe, 0x00, 0x00, 0x01, 0x02, 0xff, 0xfd, 0xff, 0x00, 0xff, 0xfe, 0x01, 0x01, 0xfe, 0xfb, 0xfe, 0xff, 0xfe, 0xfd, 0xfc, 0xfc, 0xfd, + 0xfd, 0x00, 0x01, 0xfc, 0x01, 0xfe, 0xfa, 0xfe, 0x03, 0x02, 0xfd, 0x01, 0x00, 0xfd, 0xfc, 0xfe, 0xfe, 0xff, 0x02, 0x00, 0xfe, 0x01, + 0x00, 0x02, 0x02, 0xfe, 0xf6, 0xfc, 0x05, 0xfd, 0x00, 0x04, 0x02, 0xfc, 0xff, 0x04, 0x03, 0x00, 0x01, 0x05, 0x08, 0x05, 0x00, 0x00, + 0x02, 0x01, 0xfe, 0xfd, 0x01, 0x01, 0xfe, 0x05, 0x00, 0xfb, 0xfc, 0xff, 0x01, 0x01, 0xfb, 0x01, 0x04, 0xff, 0xfa, 0xfe, 0x04, 0x04, + 0xfe, 0xfd, 0xff, 0xf9, 0xfc, 0x02, 0x05, 0x04, 0x00, 0xfb, 0xf7, 0xfa, 0xfb, 0xfc, 0x02, 0x04, 0x02, 0xff, 0xfe, 0xff, 0xff, 0xfb, + 0x01, 0x05, 0x01, 0xfc, 0x00, 0x02, 0xff, 0xff, 0x00, 0xfe, 0xf9, 0xfd, 0xfc, 0xf9, 0xff, 0xfe, 0xfe, 0x03, 0x05, 0x03, 0xfd, 0xf8, + 0xfd, 0xff, 0xfc, 0xff, 0x02, 0x01, 0xfe, 0x06, 0x07, 0x02, 0xfd, 0xff, 0x02, 0x02, 0xfe, 0x01, 0x03, 0xff, 0xff, 0x01, 0x00, 0xfc, + 0xff, 0x02, 0x03, 0x00, 0x02, 0x04, 0x04, 0x04, 0x05, 0x03, 0xfa, 0xf7, 0xfb, 0x00, 0x04, 0x02, 0xff, 0x00, 0x01, 0x00, 0xff, 0xff, + 0xfc, 0xfb, 0xfd, 0xfe, 0xff, 0x00, 0x01, 0xff, 0xfe, 0xfe, 0xff, 0x03, 0x03, 0xfe, 0xfe, 0xff, 0x00, 0x00, 0xfd, 0xfd, 0x00, 0x03, + 0xfe, 0xfa, 0xfc, 0x04, 0x01, 0xfa, 0xfe, 0x04, 0x00, 0xf8, 0x03, 0x04, 0xfe, 0xfa, 0xfe, 0x01, 0x00, 0xfb, 0xfa, 0xfd, 0x00, 0x00, + 0x01, 0x02, 0x00, 0x01, 0x02, 0x00, 0xfd, 0xfe, 0x03, 0x04, 0xfd, 0xfc, 0x00, 0x02, 0x01, 0x00, 0x02, 0x06, 0x05, 0xff, 0xfc, 0xfe, + 0x02, 0x02, 0xfe, 0xff, 0x03, 0x03, 0x00, 0xfc, 0xfd, 0x03, 0x01, 0xfe, 0xfe, 0xfd, 0x03, 0x06, 0x03, 0xfe, 0xfc, 0xfc, 0xfc, 0xff, + 0x01, 0x01, 0x01, 0xff, 0xff, 0x03, 0x02, 0xff, 0xff, 0xff, 0x00, 0xfc, 0xf9, 0xff, 0xff, 0xfd, 0xfc, 0x01, 0x01, 0x00, 0xff, 0xff, + 0xff, 0xfe, 0xfd, 0x02, 0x04, 0x00, 0xff, 0x01, 0x00, 0xfa, 0xfa, 0xfe, 0x02, 0x03, 0x00, 0xfe, 0xff, 0xff, 0xfe, 0xff, 0x05, 0x00, + 0xfc, 0xfc, 0x00, 0xfc, 0xfb, 0x02, 0x07, 0x05, 0x00, 0x01, 0x01, 0xfe, 0xfa, 0xff, 0x01, 0x00, 0x01, 0xfd, 0xff, 0x04, 0xff, 0xfe, + 0xfc, 0xf8, 0x04, 0x03, 0xfb, 0xfe, 0x02, 0x05, 0x05, 0x02, 0x01, 0x02, 0x01, 0xfc, 0xfd, 0xff, 0xfe, 0x00, 0x02, 0x03, 0x05, 0x01, + 0xfb, 0xfa, 0xff, 0xff, 0xfd, 0x00, 0x00, 0xff, 0xfd, 0xfd, 0xfd, 0x00, 0x02, 0x05, 0x00, 0xfb, 0xfd, 0x01, 0x01, 0xff, 0xff, 0x01, + 0x02, 0x01, 0xfc, 0xfb, 0xfc, 0xfd, 0xfd, 0x00, 0x03, 0xff, 0xfe, 0x00, 0x01, 0x00, 0x00, 0x01, 0xfe, 0xfe, 0xff, 0x01, 0x01, 0xff, + 0x00, 0x03, 0x04, 0x02, 0x00, 0xfe, 0xfe, 0xfe, 0xfd, 0xfe, 0xfc, 0xfe, 0x05, 0x03, 0xfe, 0xfc, 0xfe, 0xfd, 0xfe, 0x01, 0x05, 0x03, + 0x00, 0x01, 0xff, 0xff, 0x01, 0xfc, 0xfe, 0x01, 0xff, 0xff, 0x00, 0x02, 0x02, 0x02, 0x01, 0x00, 0xff, 0xfe, 0xfe, 0xfb, 0xfa, 0xfc, + 0x01, 0x04, 0x05, 0x02, 0xfc, 0xfc, 0xff, 0xff, 0xfc, 0x00, 0x00, 0xfc, 0xfa, 0x02, 0x06, 0xff, 0xfc, 0xfd, 0x00, 0xfe, 0xfe, 0xfc, + 0xfb, 0xfe, 0x04, 0x04, 0xfe, 0xfc, 0xff, 0x03, 0x02, 0x00, 0x00, 0x02, 0xfe, 0x01, 0x03, 0xfd, 0xff, 0x02, 0x02, 0xff, 0x01, 0x02, + 0x00, 0xfe, 0xff, 0x00, 0xfe, 0xff, 0xff, 0xfe, 0x01, 0x06, 0x06, 0x00, 0xfe, 0xfd, 0xfc, 0xfe, 0xff, 0x01, 0x01, 0xff, 0xff, 0x01, + 0x00, 0xfd, 0xfc, 0xfe, 0xff, 0xfe, 0xfd, 0xff, 0x04, 0x05, 0x03, 0x00, 0x00, 0xfe, 0xfc, 0xfe, 0xff, 0x00, 0x01, 0x04, 0x05, 0x00, + 0xf9, 0xfc, 0xfd, 0xf9, 0xf9, 0xfd, 0x01, 0x02, 0x01, 0x02, 0x03, 0xff, 0x02, 0xfd, 0xf5, 0xf8, 0x00, 0x02, 0x00, 0x01, 0x04, 0x05, + 0xff, 0xfb, 0xfd, 0xff, 0xfe, 0xfc, 0xfb, 0xfc, 0x02, 0x01, 0x00, 0x06, 0x00, 0xfb, 0xfb, 0xfd, 0x01, 0x03, 0x05, 0x06, 0x06, 0x04, + 0xff, 0x00, 0xfe, 0xfa, 0xff, 0x01, 0xff, 0xfc, 0x00, 0x04, 0x05, 0x05, 0x01, 0xfc, 0xfa, 0xfb, 0xfe, 0x00, 0xff, 0x02, 0x02, 0x00, + 0x04, 0x03, 0x00, 0xfd, 0x01, 0x01, 0xff, 0xff, 0x05, 0x04, 0xff, 0xfe, 0xfb, 0xf9, 0xfc, 0xfd, 0xfe, 0x00, 0x04, 0x02, 0x01, 0x01, + 0xfe, 0xfd, 0xfd, 0xff, 0xfd, 0xff, 0x01, 0xfc, 0x01, 0x02, 0xff, 0xfd, 0xff, 0x02, 0x01, 0xfb, 0xfd, 0x02, 0xff, 0xfc, 0xfc, 0x00, + 0x00, 0xfd, 0xfb, 0xfe, 0xff, 0xff, 0x00, 0x01, 0x03, 0x02, 0x00, 0xff, 0xfe, 0xff, 0xff, 0x03, 0x01, 0xfd, 0x00, 0x03, 0x02, 0xfe, + 0xfe, 0x01, 0x03, 0x00, 0xfe, 0x03, 0x08, 0xfe, 0xfc, 0xff, 0xfe, 0x00, 0x02, 0x01, 0xff, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0xff, + 0x01, 0x01, 0x00, 0xfc, 0xfd, 0xfd, 0xfd, 0x02, 0x04, 0x01, 0xff, 0xfc, 0xfd, 0x01, 0x00, 0xff, 0xff, 0x01, 0x02, 0xff, 0xfd, 0xfd, + 0xfb, 0xfe, 0x02, 0x01, 0xfc, 0xfa, 0xff, 0x02, 0x03, 0x00, 0xfc, 0xfc, 0xfe, 0xff, 0x02, 0x00, 0xff, 0x01, 0x01, 0x00, 0xff, 0x00, + 0x01, 0x00, 0xfe, 0xfe, 0xfd, 0xfe, 0x02, 0x03, 0xff, 0xfc, 0xff, 0xfe, 0xff, 0x01, 0x01, 0x00, 0xfe, 0xfd, 0xfc, 0xfe, 0x04, 0x08, + 0x03, 0xff, 0x01, 0xff, 0xfe, 0xfe, 0xfe, 0x00, 0x02, 0x01, 0x02, 0xfe, 0xfe, 0x01, 0xff, 0xfc, 0xfd, 0xfe, 0x03, 0x03, 0x00, 0x02, + 0xfe, 0xfc, 0x01, 0x05, 0x03, 0xfd, 0xfa, 0xfc, 0xff, 0x01, 0x04, 0x05, 0x02, 0xfe, 0xfd, 0xfc, 0xf9, 0xf6, 0xfc, 0x00, 0xff, 0x01, + 0xff, 0xfe, 0x00, 0xff, 0x01, 0x03, 0x01, 0xff, 0x00, 0x02, 0x00, 0xfb, 0xfa, 0x00, 0x04, 0x06, 0x04, 0xfe, 0xfc, 0xfb, 0xfa, 0xfe, + 0x02, 0x03, 0x03, 0x02, 0xff, 0xfc, 0xfa, 0xfe, 0x02, 0x01, 0x02, 0x02, 0x02, 0x02, 0x03, 0x01, 0xff, 0x02, 0xff, 0xfb, 0xf9, 0xfc, + 0x00, 0x01, 0xfd, 0xff, 0x04, 0x05, 0x02, 0xfd, 0xfc, 0xff, 0xff, 0xff, 0x00, 0x04, 0x05, 0x01, 0xfc, 0xfd, 0x02, 0x03, 0xfd, 0x00, + 0x00, 0xfd, 0xfe, 0x00, 0xff, 0xfd, 0x00, 0x01, 0xff, 0xfa, 0xf9, 0xfb, 0xfc, 0xfc, 0x01, 0x03, 0x00, 0x01, 0x04, 0x05, 0x02, 0xfd, + 0xfc, 0xfe, 0x03, 0x01, 0xfe, 0xfe, 0x02, 0x00, 0xfc, 0xfd, 0x02, 0x03, 0xff, 0x01, 0x00, 0xfe, 0xfd, 0x04, 0x03, 0xfe, 0x00, 0x03, + 0x02, 0xff, 0x00, 0x01, 0x00, 0x00, 0x03, 0x06, 0x03, 0xfd, 0xfa, 0xfd, 0x01, 0xfe, 0xfe, 0xff, 0xfd, 0xfe, 0xfc, 0xfc, 0x01, 0x04, + 0x04, 0x03, 0x03, 0xfd, 0xf8, 0xfa, 0xfb, 0xff, 0x02, 0x02, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xfe, 0xff, 0xfe, 0x04, + 0x04, 0xfd, 0xf9, 0xfe, 0x03, 0x00, 0xfe, 0xff, 0x02, 0xfd, 0xfc, 0x02, 0x08, 0x02, 0xfe, 0xfd, 0xf9, 0xf8, 0xfb, 0xfe, 0x03, 0x07, + 0x06, 0xff, 0x01, 0x00, 0xff, 0x01, 0x00, 0xfc, 0xfc, 0x00, 0x08, 0x09, 0x00, 0x00, 0x01, 0x00, 0xfb, 0x00, 0x02, 0xfc, 0xff, 0x01, + 0x03, 0x08, 0x08, 0x01, 0xfa, 0xfc, 0xfd, 0xfb, 0xf9, 0x01, 0x05, 0x04, 0x04, 0x03, 0x00, 0xfd, 0xfd, 0xfd, 0xfe, 0x00, 0xfd, 0xfd, + 0xff, 0xfd, 0xff, 0x00, 0xfd, 0xfa, 0xfd, 0x00, 0xfe, 0xff, 0xfe, 0xfe, 0x04, 0x04, 0x01, 0xfe, 0xfc, 0xfb, 0xfd, 0x01, 0xfe, 0x00, + 0x03, 0x00, 0xff, 0xfe, 0xfa, 0xfd, 0xfc, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xfa, 0xfe, 0x02, 0x01, 0x01, 0x03, 0x03, 0x02, 0x02, 0x00, + 0xfd, 0x00, 0x02, 0x02, 0x03, 0x02, 0x00, 0xfe, 0xfe, 0xff, 0x00, 0x01, 0x06, 0x04, 0xfc, 0xf8, 0xff, 0x03, 0x02, 0x02, 0x04, 0x01, + 0xfc, 0xfe, 0x01, 0x03, 0x06, 0x00, 0x00, 0x05, 0x02, 0xff, 0xff, 0x01, 0xfe, 0xfb, 0xfb, 0x00, 0x01, 0xfe, 0xfc, 0x01, 0x01, 0xfc, + 0xfa, 0xfd, 0x00, 0x01, 0x01, 0xfe, 0xfc, 0xfc, 0x01, 0x02, 0x01, 0xff, 0xfd, 0xfc, 0xfd, 0xfe, 0xfe, 0xff, 0xff, 0xf8, 0xfd, 0x04, + 0x00, 0xff, 0xff, 0xfe, 0xfd, 0xfc, 0xfe, 0x01, 0xfe, 0xff, 0x03, 0x03, 0x01, 0xff, 0x00, 0x03, 0x01, 0xfe, 0xfe, 0x00, 0x01, 0x01, + 0x01, 0xfe, 0xfe, 0x01, 0x04, 0x02, 0x00, 0x00, 0xfe, 0xfe, 0xff, 0x01, 0xff, 0x03, 0x08, 0xfe, 0xfe, 0x03, 0x04, 0xff, 0xfc, 0xfe, + 0x04, 0x02, 0xff, 0x01, 0x04, 0x00, 0xfd, 0xfe, 0xfe, 0xfe, 0xfd, 0xfc, 0xff, 0x02, 0x02, 0x04, 0x01, 0xfd, 0xfb, 0x00, 0xff, 0xfa, + 0xfe, 0x00, 0x01, 0x03, 0x00, 0x00, 0xfe, 0xf7, 0xfa, 0xfc, 0xfc, 0x00, 0x01, 0x00, 0x01, 0x03, 0xff, 0xfc, 0x02, 0x02, 0xfe, 0xfb, + 0xff, 0xff, 0x01, 0x04, 0xff, 0xfd, 0xff, 0xff, 0xfe, 0xfc, 0xfb, 0x02, 0x02, 0xff, 0xff, 0x00, 0x01, 0x01, 0x01, 0x01, 0xff, 0xfe, + 0x02, 0x04, 0x03, 0x00, 0x00, 0x00, 0x00, 0x07, 0x01, 0xfa, 0xf9, 0xf9, 0xfd, 0x00, 0x01, 0x04, 0x03, 0xff, 0xfd, 0x01, 0x01, 0xfd, + 0x02, 0x03, 0x02, 0x02, 0x01, 0xfe, 0xfe, 0x01, 0x02, 0x00, 0xfe, 0x03, 0x02, 0xff, 0x00, 0xfd, 0xfb, 0xfe, 0x00, 0xfd, 0xfb, 0xfd, + 0xfd, 0x00, 0x02, 0xfe, 0x01, 0x01, 0xfd, 0xff, 0xff, 0xfe, 0xfd, 0x03, 0x00, 0xfa, 0x00, 0x01, 0xfe, 0xfd, 0xff, 0xfd, 0xfc, 0xfe, + 0x00, 0x01, 0x01, 0xfe, 0xfc, 0xfd, 0x01, 0x02, 0x05, 0x04, 0x00, 0xfd, 0x00, 0x03, 0x02, 0x00, 0x01, 0x05, 0x04, 0xff, 0xfc, 0xfe, + 0xfc, 0xfe, 0x02, 0x02, 0xfe, 0xfc, 0xfd, 0xff, 0x00, 0x00, 0xff, 0x02, 0x02, 0x00, 0x02, 0x05, 0x04, 0xfe, 0xfd, 0xff, 0x00, 0x00, + 0xfe, 0xfe, 0x01, 0x06, 0x02, 0xfc, 0xfc, 0xff, 0xfd, 0xfb, 0x01, 0x01, 0x01, 0x04, 0xfc, 0xfe, 0x00, 0xf9, 0xfd, 0x01, 0xff, 0xfc, + 0x01, 0x03, 0xff, 0xfd, 0x01, 0x03, 0xfb, 0xfb, 0xfe, 0x00, 0xfc, 0xfd, 0x00, 0x01, 0x00, 0x01, 0x01, 0xf8, 0xfd, 0x03, 0x04, 0x01, + 0x00, 0xff, 0xfe, 0x02, 0x03, 0x01, 0xfd, 0x02, 0x02, 0xfc, 0x00, 0xff, 0xff, 0x03, 0x05, 0x00, 0xfc, 0xfe, 0x01, 0x01, 0xff, 0x02, + 0x00, 0xfe, 0x01, 0xff, 0x01, 0x05, 0x01, 0xfe, 0xfe, 0x00, 0xff, 0xfe, 0xfe, 0xfd, 0xfe, 0xff, 0x00, 0xff, 0xfd, 0xfd, 0x00, 0x01, + 0x01, 0x01, 0x02, 0x01, 0x00, 0x02, 0x00, 0x00, 0xfe, 0xfb, 0xfc, 0x00, 0x02, 0xff, 0xfd, 0xff, 0x01, 0xfc, 0xfa, 0xfd, 0x03, 0x02, + 0x00, 0xff, 0x00, 0xfd, 0xfc, 0xfe, 0xfe, 0x02, 0x04, 0x02, 0x00, 0x02, 0x03, 0xfc, 0xfc, 0xff, 0x01, 0xfe, 0xfc, 0xfc, 0xfb, 0xff, + 0x02, 0x02, 0x00, 0x03, 0x02, 0xfc, 0xff, 0x01, 0x01, 0xfe, 0x02, 0x04, 0x03, 0x00, 0x00, 0xff, 0xfc, 0x00, 0x00, 0xff, 0x05, 0x05, + 0x02, 0xff, 0xfd, 0xfd, 0xfd, 0xfd, 0xfd, 0xff, 0x01, 0x03, 0xfd, 0xfb, 0x01, 0x03, 0x04, 0x05, 0x04, 0xfe, 0xfc, 0xff, 0xfd, 0xfe, + 0x01, 0x01, 0xfc, 0xfc, 0xfe, 0xfb, 0xff, 0x00, 0xfd, 0xff, 0x01, 0x01, 0xff, 0xfd, 0xfd, 0x00, 0x04, 0x06, 0x02, 0xfd, 0xfd, 0xff, + 0x01, 0x02, 0xfe, 0x00, 0x03, 0xff, 0xfc, 0xfc, 0xfd, 0xfd, 0xfa, 0xf9, 0xfd, 0xfd, 0x01, 0x03, 0xfe, 0x01, 0x04, 0x02, 0x00, 0xff, + 0x00, 0x01, 0x01, 0xff, 0xfe, 0xff, 0x03, 0x04, 0x02, 0x00, 0xff, 0xfd, 0xfa, 0xfd, 0x02, 0x04, 0xff, 0x02, 0x03, 0xfe, 0x00, 0xfb, + 0xf7, 0xfc, 0x03, 0x04, 0x01, 0x04, 0x04, 0x01, 0xfd, 0x01, 0x01, 0xff, 0xfe, 0xfc, 0xfa, 0xfb, 0x01, 0x03, 0x05, 0x07, 0x00, 0xfb, + 0xfb, 0xfb, 0xfd, 0xff, 0x03, 0x01, 0x06, 0x07, 0xfd, 0xf8, 0xfa, 0xfd, 0x00, 0x00, 0x00, 0x01, 0xfe, 0xfd, 0x00, 0x05, 0x01, 0xfc, + 0xfc, 0xfe, 0xff, 0xfe, 0xff, 0x00, 0x00, 0x01, 0x05, 0x02, 0xfe, 0xfd, 0xfd, 0xff, 0xfe, 0xfb, 0xff, 0x04, 0x06, 0x02, 0x02, 0xfd, + 0xf5, 0xf7, 0xff, 0x05, 0x06, 0x01, 0xfd, 0xfd, 0x01, 0xfd, 0xfd, 0x02, 0x00, 0xff, 0xff, 0xfd, 0xff, 0xfe, 0xfb, 0xff, 0x02, 0x04, + 0x03, 0xfa, 0xfa, 0xfe, 0x00, 0x00, 0x01, 0x03, 0x02, 0x02, 0xff, 0xfc, 0xfc, 0x01, 0x04, 0x02, 0x01, 0x00, 0x00, 0x01, 0xff, 0xfd, + 0xfe, 0xfd, 0x00, 0x03, 0x00, 0x01, 0xff, 0xfb, 0xfc, 0xff, 0x01, 0xff, 0x00, 0x00, 0x00, 0x02, 0x03, 0x02, 0x00, 0x02, 0x01, 0xfe, + 0xfd, 0xff, 0x02, 0x04, 0x03, 0x04, 0x03, 0xfe, 0xfb, 0xf9, 0xf9, 0xfc, 0x01, 0x03, 0x02, 0x03, 0x00, 0xfd, 0xfd, 0xfa, 0xfe, 0x03, + 0x04, 0x01, 0xff, 0xff, 0xfd, 0x00, 0x02, 0x01, 0x00, 0xfe, 0xfc, 0xfa, 0xfa, 0xfc, 0xfe, 0x02, 0x04, 0x02, 0xfc, 0xfd, 0xfa, 0xf8, + 0xfe, 0x03, 0x04, 0x03, 0x01, 0x00, 0x00, 0x00, 0xfe, 0xfe, 0x00, 0xfd, 0x03, 0x04, 0xfe, 0xfc, 0x01, 0x03, 0xff, 0x01, 0x00, 0xfd, + 0xfd, 0xfd, 0xfc, 0xfc, 0xfe, 0x03, 0x06, 0x05, 0x04, 0x00, 0xfc, 0xfa, 0xfe, 0x01, 0x00, 0x01, 0x02, 0x02, 0x03, 0xff, 0xfd, 0xff, + 0xfd, 0xfe, 0x03, 0x04, 0xfd, 0xfb, 0xff, 0xff, 0x03, 0x02, 0xfe, 0x01, 0xff, 0xfe, 0x01, 0x00, 0x02, 0x04, 0x00, 0xff, 0x00, 0x00, + 0xfe, 0xfd, 0xfd, 0xfe, 0x03, 0x01, 0xfb, 0xfb, 0xfb, 0xfe, 0x03, 0x00, 0x01, 0x02, 0xfe, 0xfa, 0xfc, 0x01, 0xfd, 0xfe, 0x01, 0x02, + 0x00, 0x00, 0x00, 0xfc, 0xfc, 0xfd, 0xff, 0x02, 0x01, 0xff, 0x02, 0xfe, 0xff, 0x01, 0xff, 0xfb, 0xfd, 0x02, 0x02, 0xfe, 0xfd, 0x01, + 0x02, 0x01, 0x00, 0x02, 0x01, 0xff, 0xfd, 0xfc, 0x01, 0x03, 0x00, 0xfd, 0xfd, 0x00, 0x01, 0x00, 0xff, 0xff, 0x02, 0x00, 0xfd, 0xfe, + 0x01, 0x01, 0xff, 0x01, 0x00, 0xfe, 0xff, 0xfe, 0x00, 0x01, 0xff, 0x02, 0x03, 0x02, 0x01, 0xff, 0xff, 0x00, 0xfa, 0xfc, 0x02, 0x03, + 0x00, 0x02, 0x05, 0x00, 0xfc, 0xfe, 0x05, 0x03, 0x00, 0xfe, 0xfe, 0xfd, 0xfc, 0xfd, 0xff, 0xfd, 0xfb, 0xfe, 0x00, 0x01, 0x00, 0xfe, + 0xfd, 0xfe, 0x00, 0x00, 0xfe, 0xfd, 0xff, 0x01, 0x02, 0x01, 0xfe, 0xfd, 0xfe, 0xfe, 0xfd, 0xff, 0xff, 0xfc, 0x02, 0x03, 0xff, 0xfe, + 0xfd, 0xfc, 0xfd, 0x00, 0x01, 0x01, 0x01, 0x02, 0x03, 0x03, 0x02, 0x01, 0xff, 0xfe, 0x03, 0x01, 0xfc, 0xfb, 0xfe, 0x01, 0x02, 0xff, + 0xfd, 0xfc, 0xfe, 0x00, 0x01, 0x00, 0x00, 0x01, 0x01, 0x00, 0x06, 0x00, 0xfa, 0x01, 0x02, 0x01, 0xff, 0x03, 0xff, 0xff, 0x04, 0x07, + 0x01, 0xfc, 0xfc, 0xff, 0xfe, 0xfa, 0xfb, 0xff, 0x03, 0x04, 0x01, 0xfe, 0xfe, 0xfe, 0xfb, 0xfb, 0xff, 0x02, 0x03, 0x03, 0x02, 0x01, + 0x00, 0xfe, 0xfa, 0xfc, 0xfe, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xfa, 0xfc, 0xfe, 0xfc, 0xfa, 0xfd, 0x02, 0x04, 0x05, + 0x01, 0xfd, 0xfe, 0x00, 0x00, 0xfc, 0x00, 0x01, 0x00, 0xfe, 0x00, 0x02, 0x01, 0xfd, 0xfc, 0xff, 0x02, 0x02, 0xff, 0xff, 0x03, 0x03, + 0x01, 0x00, 0xff, 0x00, 0x01, 0x00, 0xfe, 0xfe, 0xff, 0xff, 0x02, 0x03, 0x02, 0x00, 0xff, 0xfd, 0xfe, 0x03, 0x07, 0x05, 0xfd, 0xfc, + 0x01, 0x04, 0xfe, 0xfd, 0xff, 0x01, 0x00, 0x01, 0x02, 0xff, 0xfc, 0xfc, 0x00, 0x03, 0x04, 0x01, 0xfd, 0xfc, 0x00, 0x02, 0xf9, 0xfd, + 0x03, 0x02, 0xff, 0xfd, 0xfe, 0xff, 0x01, 0x00, 0xff, 0xfe, 0xfd, 0xfb, 0xfa, 0xfd, 0xff, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0xff, + 0xfc, 0xfb, 0xfd, 0x02, 0x04, 0xff, 0xff, 0x00, 0xff, 0xfc, 0xfe, 0x02, 0x02, 0x00, 0xfe, 0xfd, 0xff, 0x02, 0x02, 0x00, 0xff, 0xff, + 0xff, 0xfe, 0xfc, 0xfd, 0xff, 0x03, 0x04, 0x05, 0x06, 0x02, 0x00, 0xff, 0xfc, 0xff, 0x02, 0x01, 0x01, 0x00, 0x01, 0x01, 0x03, 0xfd, + 0xf9, 0xff, 0x03, 0x01, 0xfc, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x02, 0xff, 0xfc, 0xfe, 0x00, 0x02, 0x03, 0x03, 0x01, 0x00, + 0xff, 0xfe, 0xff, 0xff, 0xfd, 0xfb, 0xfd, 0x00, 0x00, 0xff, 0xfd, 0xff, 0x02, 0x01, 0xff, 0xfe, 0xfd, 0xfe, 0xfe, 0xfc, 0xfd, 0x02, + 0x07, 0x01, 0xfc, 0xfd, 0x01, 0x00, 0x00, 0x02, 0x04, 0x03, 0xff, 0xfb, 0xfd, 0xfe, 0xfe, 0xfc, 0xfe, 0xff, 0xff, 0x00, 0xff, 0xff, + 0xff, 0x01, 0x04, 0x05, 0x02, 0x01, 0xfd, 0xfb, 0xfd, 0x01, 0x03, 0x02, 0x04, 0x05, 0x02, 0xfd, 0xfb, 0xfe, 0x01, 0x01, 0xfe, 0xfd, + 0xfd, 0xfe, 0x01, 0x02, 0x00, 0xfd, 0xfe, 0x01, 0x00, 0xfe, 0xff, 0x01, 0xfe, 0xfc, 0xff, 0x05, 0xff, 0xfc, 0xfd, 0xfd, 0xfc, 0xfd, + 0x01, 0x00, 0x01, 0x03, 0x02, 0xfe, 0xfb, 0xfb, 0x01, 0x01, 0x01, 0x04, 0xfe, 0xfe, 0x00, 0x00, 0xfd, 0xfe, 0x01, 0x06, 0x02, 0xfe, + 0x03, 0x00, 0xfd, 0xfd, 0xff, 0x02, 0x03, 0x01, 0xfc, 0xfc, 0x00, 0x04, 0x00, 0xfd, 0xff, 0x03, 0x00, 0xfe, 0x01, 0xff, 0xff, 0x01, + 0x03, 0x00, 0xfe, 0x00, 0xfe, 0xff, 0x02, 0x03, 0xff, 0x00, 0x01, 0xff, 0xfe, 0xfe, 0xff, 0x00, 0xff, 0xfd, 0xfe, 0xfe, 0xff, 0xff, + 0xff, 0xfd, 0xff, 0x01, 0x01, 0xfe, 0xfa, 0xfb, 0xff, 0x01, 0x03, 0x04, 0x02, 0xfe, 0xfb, 0xfb, 0xfc, 0xfe, 0xfe, 0x01, 0x02, 0x01, + 0x02, 0xfd, 0xfc, 0xff, 0xfc, 0xfc, 0xff, 0x02, 0x01, 0x00, 0x01, 0x02, 0x00, 0xfe, 0xff, 0x00, 0x01, 0x01, 0x01, 0xfe, 0xfe, 0x02, + 0x08, 0x04, 0xff, 0xff, 0xf9, 0xfa, 0xfe, 0x01, 0x01, 0x02, 0x03, 0x01, 0xfe, 0xff, 0x03, 0xfe, 0xfe, 0x00, 0xff, 0xff, 0x01, 0x02, + 0x00, 0xfe, 0x00, 0x02, 0x02, 0xfe, 0xfb, 0xff, 0x01, 0x00, 0xff, 0xfe, 0x02, 0x05, 0xff, 0xfc, 0xfc, 0xfd, 0xfd, 0x00, 0x01, 0x01, + 0x01, 0x01, 0x00, 0xfe, 0xff, 0xff, 0xfe, 0xfe, 0x00, 0x00, 0xfe, 0x00, 0xff, 0xfd, 0x01, 0x02, 0x00, 0xfd, 0x00, 0x00, 0xfd, 0xfb, + 0xfe, 0x01, 0x00, 0xfd, 0xfe, 0xff, 0xff, 0xfe, 0xff, 0x01, 0x02, 0x00, 0x00, 0x02, 0x02, 0xfe, 0xfb, 0xff, 0x04, 0x02, 0xfe, 0xfe, + 0xfe, 0xff, 0x01, 0x00, 0xfe, 0xff, 0x01, 0x02, 0x02, 0xff, 0xfc, 0xfc, 0xff, 0x01, 0x01, 0x01, 0x01, 0x02, 0x00, 0x01, 0x03, 0x00, + 0x00, 0x02, 0x04, 0x00, 0xfd, 0xfe, 0x02, 0x03, 0x00, 0xfd, 0xfe, 0x00, 0xff, 0xfe, 0xfe, 0xfe, 0xfd, 0xfd, 0xfd, 0x00, 0x02, 0x01, + 0xfd, 0xfc, 0xff, 0x03, 0x02, 0xff, 0xfe, 0xff, 0x01, 0x02, 0xfd, 0xfe, 0x01, 0x01, 0xfe, 0xfe, 0xfe, 0xfb, 0xfe, 0xff, 0xfe, 0xff, + 0x00, 0x00, 0x01, 0x00, 0xff, 0xfe, 0xff, 0x02, 0x04, 0x02, 0xff, 0xff, 0x00, 0xff, 0xfe, 0x00, 0x03, 0x00, 0x03, 0x02, 0xfe, 0xfc, + 0x01, 0x03, 0xfe, 0xfd, 0x00, 0x01, 0xfe, 0xfd, 0x01, 0x05, 0x03, 0xff, 0xfd, 0xff, 0x02, 0x04, 0x02, 0xfd, 0xfe, 0x01, 0x00, 0xfd, + 0xfe, 0x01, 0x02, 0x00, 0xfd, 0xfc, 0xfc, 0xfe, 0xfe, 0xfe, 0xfd, 0xfe, 0x00, 0xff, 0x00, 0x02, 0x02, 0xfe, 0xfc, 0xfd, 0xff, 0xff, + 0x00, 0x01, 0x01, 0x01, 0x02, 0x01, 0xff, 0xfd, 0xfd, 0xfe, 0xff, 0x01, 0x01, 0xff, 0xfd, 0xff, 0x04, 0x02, 0x00, 0x00, 0xff, 0xff, + 0x00, 0x01, 0x01, 0x01, 0xff, 0xfe, 0x00, 0x01, 0x00, 0xff, 0x00, 0x01, 0x01, 0x02, 0x02, 0x01, 0x01, 0x01, 0x00, 0xff, 0xff, 0xfe, + 0xfd, 0xfd, 0xff, 0x00, 0x01, 0x00, 0xff, 0xfe, 0xfe, 0xfc, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x01, 0x03, 0x02, 0xfe, 0xfc, + 0xfd, 0x01, 0x03, 0x02, 0x01, 0x04, 0xff, 0xfb, 0xfb, 0xfb, 0xfd, 0xff, 0x00, 0x00, 0xff, 0x00, 0x02, 0xff, 0xfc, 0xfe, 0x00, 0x00, + 0xff, 0xff, 0xfd, 0xfe, 0x01, 0x01, 0x01, 0x02, 0x01, 0xfc, 0xfd, 0xff, 0x01, 0x00, 0xff, 0xfe, 0xfe, 0xfe, 0x00, 0x01, 0xff, 0xfc, + 0xfd, 0xff, 0x04, 0x04, 0x01, 0x01, 0x02, 0x01, 0xfe, 0x00, 0x00, 0x03, 0x06, 0x02, 0xfe, 0xff, 0xff, 0x00, 0xfe, 0xfd, 0xfe, 0x00, + 0x00, 0xff, 0x00, 0x03, 0x04, 0x00, 0xfb, 0xfa, 0xfe, 0x01, 0x01, 0x02, 0x04, 0x05, 0x03, 0x01, 0x00, 0xfe, 0xfb, 0xfb, 0xfd, 0x00, + 0x00, 0xfe, 0x01, 0x02, 0xfe, 0xfc, 0xfb, 0xfc, 0xfe, 0xfe, 0xfe, 0x00, 0x01, 0x03, 0x02, 0xff, 0xfa, 0xfa, 0xfe, 0xff, 0xfb, 0xfc, + 0x02, 0x04, 0xff, 0xfe, 0x02, 0xfd, 0xfd, 0xfe, 0xfd, 0xfb, 0xfc, 0xff, 0xff, 0x03, 0x03, 0xfe, 0xfb, 0xfd, 0x00, 0xff, 0xfe, 0x01, + 0x04, 0x05, 0x05, 0x04, 0x03, 0x01, 0xff, 0xff, 0x01, 0x01, 0x00, 0xff, 0xff, 0x00, 0x03, 0x04, 0x01, 0xfd, 0xfc, 0x01, 0xff, 0xfb, + 0xfd, 0x01, 0x04, 0x04, 0x02, 0x00, 0xfe, 0xfe, 0x01, 0x00, 0xfe, 0xfe, 0x03, 0x01, 0xff, 0x02, 0xff, 0xfd, 0xff, 0xff, 0xfe, 0xff, + 0xff, 0xfe, 0xfd, 0xfe, 0x02, 0x03, 0x00, 0xfd, 0x03, 0x03, 0xfe, 0xf9, 0xfc, 0xfe, 0xfe, 0xff, 0x01, 0x01, 0x00, 0x04, 0x00, 0xfc, + 0xfc, 0x03, 0x02, 0xfd, 0xfe, 0xfc, 0xfe, 0x02, 0xfd, 0xfe, 0xff, 0xfe, 0xff, 0xfe, 0xfd, 0xfc, 0xff, 0x01, 0x01, 0xfd, 0x00, 0x02, + 0xfb, 0xf9, 0xfc, 0x00, 0x00, 0x03, 0x03, 0x01, 0xfe, 0x01, 0x05, 0x02, 0x00, 0x00, 0x01, 0xff, 0xfc, 0xfd, 0x02, 0x01, 0x04, 0x07, + 0x04, 0xfb, 0xfa, 0xfe, 0xfd, 0xfe, 0x00, 0x03, 0x02, 0x04, 0x04, 0xff, 0xfd, 0xfa, 0xfa, 0x04, 0x06, 0x04, 0x05, 0x02, 0x00, 0x00, + 0xfe, 0xfe, 0xff, 0x00, 0xff, 0xfc, 0xfb, 0xfe, 0xfe, 0x01, 0x04, 0x00, 0x00, 0x00, 0xfe, 0xfe, 0xff, 0x00, 0x01, 0x04, 0x03, 0xff, + 0xff, 0xff, 0xfe, 0xfb, 0x00, 0x00, 0xff, 0xff, 0x01, 0xfe, 0xf9, 0xf9, 0x01, 0x04, 0xff, 0xfc, 0xff, 0x03, 0xfe, 0xfa, 0xfd, 0x04, + 0x02, 0x01, 0x01, 0x02, 0xfc, 0xfc, 0x00, 0xfe, 0xff, 0x01, 0x02, 0xfc, 0xfd, 0xff, 0xfb, 0x01, 0x01, 0xff, 0xff, 0x02, 0x03, 0xff, + 0xfb, 0xfe, 0x02, 0x01, 0x01, 0x02, 0x02, 0xff, 0x00, 0x02, 0x00, 0xfa, 0x00, 0x06, 0xff, 0xff, 0xff, 0xfe, 0xfe, 0x03, 0x03, 0xfd, + 0xfe, 0xff, 0xfe, 0xff, 0x00, 0x03, 0x06, 0x06, 0x05, 0x00, 0xfa, 0xff, 0x01, 0xff, 0xff, 0x06, 0x06, 0xff, 0xfd, 0xfc, 0xf9, 0xf8, + 0xfd, 0x01, 0x02, 0xff, 0x01, 0xff, 0xfc, 0xff, 0x03, 0x02, 0xfd, 0x01, 0x00, 0xfc, 0xfd, 0xfe, 0xff, 0x02, 0x02, 0x00, 0x00, 0x01, + 0xfd, 0xfc, 0xfe, 0xfb, 0xfc, 0xff, 0x02, 0xfc, 0xff, 0x01, 0xf9, 0xfe, 0x02, 0x02, 0x00, 0x02, 0x02, 0xfd, 0x00, 0xfe, 0xfd, 0x03, + 0x03, 0xfe, 0xfc, 0x00, 0xfe, 0xfe, 0x03, 0x01, 0x02, 0x05, 0x01, 0xfd, 0xfe, 0x01, 0xf8, 0xfd, 0x04, 0x00, 0x01, 0x03, 0x03, 0xfb, + 0xff, 0x02, 0x00, 0x09, 0x05, 0xfe, 0x02, 0xff, 0xfe, 0xff, 0xfe, 0xfd, 0x00, 0x03, 0xff, 0xfe, 0xff, 0x00, 0x02, 0x03, 0x00, 0xfd, + 0xff, 0xff, 0xfc, 0xfc, 0xff, 0x01, 0x00, 0xfe, 0xff, 0x02, 0x00, 0xfd, 0xfc, 0x00, 0x01, 0x03, 0x03, 0xfe, 0xfb, 0xff, 0x03, 0xff, + 0xfd, 0xff, 0x04, 0x01, 0xfe, 0xfe, 0xfc, 0xff, 0x01, 0xff, 0xff, 0xfb, 0xf9, 0xfc, 0xfe, 0xfd, 0xfd, 0x03, 0x05, 0x01, 0xfd, 0xff, + 0x02, 0x01, 0xfd, 0xfd, 0x02, 0x06, 0x04, 0xfe, 0xfd, 0x01, 0xfd, 0xfa, 0xfc, 0x00, 0x04, 0x02, 0xfe, 0x00, 0xff, 0xfd, 0xfc, 0x03, + 0x02, 0xfd, 0xfe, 0x03, 0x02, 0xfd, 0x01, 0x01, 0x01, 0x04, 0x01, 0xff, 0xff, 0xf9, 0xff, 0x02, 0xfe, 0x01, 0x03, 0xff, 0xf6, 0xfd, + 0xff, 0xfd, 0x03, 0x05, 0x02, 0xfc, 0x02, 0x00, 0xfd, 0x01, 0x03, 0x01, 0xff, 0x03, 0x03, 0x03, 0x03, 0xff, 0xff, 0x00, 0xfc, 0xff, + 0xfe, 0xfc, 0x00, 0xff, 0xff, 0x01, 0x02, 0xff, 0xfc, 0xfb, 0xfe, 0xff, 0xff, 0x00, 0xfe, 0xff, 0x04, 0x03, 0xfe, 0xfc, 0x03, 0x01, + 0x00, 0x02, 0xfe, 0xfe, 0xfe, 0xfd, 0xfd, 0xfd, 0xfd, 0xfc, 0xfe, 0x00, 0x00, 0x01, 0x00, 0xfe, 0xfc, 0x02, 0x01, 0xfd, 0x01, 0xff, + 0xfc, 0xfd, 0x01, 0x03, 0x03, 0x04, 0x01, 0xfe, 0xff, 0x02, 0x00, 0xfe, 0x00, 0xff, 0x00, 0xfe, 0xf9, 0xfb, 0xfe, 0xff, 0xff, 0x02, + 0x01, 0xfe, 0x01, 0x04, 0x02, 0xfd, 0xfc, 0xfe, 0x00, 0x00, 0xff, 0x01, 0x06, 0xff, 0x00, 0x06, 0x01, 0xfe, 0xfe, 0x00, 0x03, 0x01, + 0xfd, 0xfc, 0x00, 0x01, 0xfe, 0x00, 0x00, 0xff, 0xff, 0x00, 0x02, 0x04, 0x03, 0x01, 0xff, 0xff, 0xfd, 0xfc, 0xfd, 0x01, 0xfe, 0xfd, + 0xff, 0x01, 0x02, 0xff, 0xfc, 0x01, 0xfd, 0xfb, 0x00, 0x06, 0xff, 0xf8, 0xff, 0x02, 0xfe, 0xf9, 0xfd, 0xfe, 0xfe, 0x00, 0x00, 0x00, + 0x01, 0xfe, 0xfe, 0xfd, 0xfd, 0xff, 0x03, 0x03, 0xfb, 0xff, 0xfe, 0xfc, 0x00, 0x03, 0x03, 0x01, 0x00, 0xfe, 0xfe, 0x02, 0x01, 0xfe, + 0xfd, 0xfb, 0xff, 0x00, 0xff, 0x00, 0x05, 0x08, 0x02, 0x03, 0x01, 0xfc, 0xfc, 0x01, 0x01, 0xfd, 0x01, 0x04, 0x03, 0x02, 0xfe, 0xfd, + 0x00, 0x04, 0x01, 0xfd, 0xfe, 0xff, 0xfe, 0xff, 0x05, 0x00, 0xfe, 0x02, 0xfd, 0xfc, 0xfe, 0x00, 0x02, 0x03, 0x03, 0xfe, 0x01, 0x02, + 0xfd, 0xfa, 0xfc, 0xff, 0xfd, 0xfc, 0xfc, 0xfe, 0x02, 0x01, 0xfc, 0xfa, 0xfa, 0x00, 0x03, 0xff, 0xfe, 0xff, 0x00, 0xfe, 0x01, 0x04, + 0x02, 0xfd, 0xfd, 0x00, 0xfe, 0xfd, 0xff, 0x03, 0x00, 0x01, 0x01, 0xff, 0xf9, 0xfa, 0xff, 0x01, 0x00, 0x02, 0x06, 0x02, 0xff, 0xff, + 0x02, 0xff, 0xff, 0x02, 0x03, 0x02, 0x01, 0x00, 0xfc, 0xff, 0x02, 0x01, 0xfd, 0xfe, 0x01, 0xff, 0xfd, 0xfd, 0xfe, 0xfc, 0x01, 0x06, + 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x01, 0x01, 0x01, 0x04, 0x02, 0x00, 0x00, 0xfc, 0xfd, 0xff, + 0xff, 0xff, 0x00, 0x01, 0xfe, 0xff, 0xff, 0xfc, 0x00, 0x01, 0x00, 0xff, 0x01, 0x00, 0xfb, 0xfd, 0x00, 0x00, 0xff, 0x01, 0xff, 0xfd, + 0xff, 0x00, 0xff, 0x00, 0xfe, 0xfe, 0x00, 0x01, 0xfc, 0xfd, 0x03, 0x01, 0xfd, 0xfe, 0x02, 0x01, 0x00, 0x00, 0x02, 0x03, 0x01, 0xff, + 0x01, 0x02, 0xff, 0xfc, 0xff, 0x01, 0x01, 0x04, 0x01, 0xff, 0x02, 0x02, 0x00, 0xfd, 0xfd, 0xfe, 0x00, 0x00, 0x01, 0xfe, 0xfd, 0xfe, + 0xfd, 0x00, 0x02, 0x00, 0xff, 0xfe, 0xfd, 0x00, 0x03, 0x02, 0xfe, 0x03, 0x02, 0xff, 0xff, 0xff, 0xfa, 0xf8, 0x02, 0x05, 0x03, 0x02, + 0xfe, 0xfd, 0xfd, 0xfc, 0xfa, 0xfc, 0x01, 0xff, 0x00, 0x02, 0x02, 0x00, 0xfe, 0xfe, 0xfe, 0x01, 0x01, 0xfe, 0xff, 0x00, 0x01, 0x03, + 0xff, 0xfd, 0x00, 0x00, 0xfd, 0xfa, 0xfc, 0xff, 0x02, 0x04, 0x03, 0x03, 0x01, 0xfe, 0xf8, 0xfe, 0x01, 0xff, 0x03, 0x03, 0x02, 0x03, + 0x04, 0x00, 0xfc, 0xff, 0x02, 0x02, 0x01, 0x01, 0x00, 0xfe, 0xfc, 0xfe, 0x01, 0x03, 0xff, 0xfe, 0xfe, 0xfc, 0xfb, 0xfc, 0x00, 0x02, + 0x01, 0x00, 0xff, 0xff, 0x01, 0x01, 0xfe, 0xfe, 0x01, 0x04, 0x03, 0xfe, 0xfc, 0xfe, 0x00, 0xfe, 0xfb, 0xfc, 0x04, 0x04, 0xfe, 0xfc, + 0x01, 0x03, 0xff, 0x01, 0xff, 0xfd, 0x00, 0xff, 0xfd, 0xfe, 0x01, 0xff, 0xfe, 0x00, 0x00, 0x00, 0x00, 0xff, 0xfd, 0xfe, 0x01, 0x00, + 0xfc, 0xfc, 0x00, 0xfe, 0xff, 0x01, 0x00, 0x03, 0x02, 0xfc, 0xfe, 0xfd, 0xfb, 0xfd, 0x08, 0x05, 0xfc, 0x00, 0xfe, 0xfe, 0x00, 0x03, + 0x00, 0xfe, 0x02, 0x02, 0x03, 0x04, 0xfe, 0xfe, 0xff, 0xfe, 0xfd, 0xfd, 0xfe, 0x00, 0x00, 0xfd, 0xfe, 0x06, 0x04, 0x00, 0x02, 0xfd, + 0xfd, 0xff, 0x01, 0x01, 0x00, 0x00, 0x00, 0xfb, 0xfc, 0x06, 0x01, 0xff, 0x00, 0xfe, 0xff, 0x00, 0xfe, 0xfa, 0xfb, 0xfe, 0x00, 0x03, + 0xff, 0xfb, 0x01, 0x01, 0xfd, 0xfb, 0x03, 0x02, 0x01, 0x04, 0x03, 0xff, 0xfc, 0xfe, 0xfd, 0xff, 0x02, 0x03, 0xff, 0xfd, 0x00, 0x01, + 0xff, 0xfd, 0xfb, 0x01, 0x01, 0xfa, 0xfe, 0xfd, 0xfb, 0x00, 0x03, 0x03, 0x02, 0x04, 0xfc, 0xfa, 0x02, 0x04, 0x00, 0xfe, 0x05, 0xff, + 0xfe, 0x01, 0xfd, 0xfc, 0xfe, 0x00, 0xfe, 0x02, 0x07, 0x05, 0xfd, 0xfd, 0x04, 0x02, 0xff, 0xfe, 0xfe, 0xfd, 0xfe, 0x00, 0x06, 0x04, + 0x02, 0x02, 0xff, 0xfc, 0xfa, 0xfa, 0xff, 0x01, 0xff, 0xfb, 0x00, 0x01, 0xfc, 0xfe, 0xff, 0xfd, 0xfb, 0xfe, 0x00, 0x01, 0x00, 0xff, + 0xfd, 0xfb, 0xfe, 0xfd, 0xfd, 0x04, 0x02, 0x00, 0x01, 0x02, 0x01, 0x02, 0x04, 0xff, 0x00, 0x01, 0xfa, 0xfd, 0x01, 0x02, 0x00, 0x01, + 0x02, 0x02, 0x01, 0xfe, 0xfc, 0xfd, 0xfe, 0xfe, 0xfe, 0x03, 0x01, 0xfe, 0xff, 0x01, 0x02, 0x01, 0x00, 0xff, 0x01, 0x04, 0xff, 0x00, + 0x01, 0xfd, 0xff, 0x01, 0x00, 0xfe, 0x00, 0xff, 0xfd, 0x03, 0x02, 0x00, 0x02, 0xfe, 0xff, 0x03, 0x00, 0xfd, 0x00, 0x08, 0xfe, 0xfc, + 0x00, 0xfc, 0xff, 0x03, 0x04, 0x02, 0x01, 0x00, 0xfd, 0xf6, 0xf8, 0xff, 0x01, 0xfc, 0xfb, 0x00, 0x00, 0xfe, 0xfe, 0x00, 0xfe, 0xfe, + 0xfd, 0xfd, 0xfd, 0xff, 0x02, 0x03, 0x00, 0xfe, 0xff, 0xfe, 0x00, 0x02, 0x00, 0xfe, 0xfe, 0x00, 0x02, 0x00, 0xfe, 0xfe, 0xff, 0x00, + 0x00, 0xfd, 0xff, 0x02, 0x01, 0xfe, 0x03, 0x07, 0xfe, 0xfd, 0xff, 0x01, 0x01, 0x02, 0x02, 0x01, 0xfd, 0xfd, 0xff, 0x02, 0xfe, 0xff, + 0x06, 0x00, 0xff, 0x00, 0x01, 0xfd, 0xfd, 0x00, 0x05, 0xfd, 0xfa, 0x01, 0x00, 0xff, 0x01, 0x06, 0x01, 0xff, 0x00, 0xfe, 0xfc, 0xfd, + 0x01, 0x01, 0xff, 0x01, 0x04, 0xfd, 0xf9, 0xfc, 0x02, 0xff, 0xfc, 0xfe, 0xfd, 0x00, 0x03, 0x00, 0xfc, 0xfb, 0xfd, 0xfc, 0xfe, 0x01, + 0x03, 0x05, 0x03, 0x00, 0xfe, 0xfe, 0xfc, 0xf9, 0xfc, 0x00, 0x01, 0x00, 0xfe, 0xff, 0x01, 0x00, 0x00, 0x00, 0x01, 0xff, 0xfd, 0xfe, + 0x03, 0x01, 0x03, 0x06, 0x02, 0xff, 0xfd, 0xfd, 0x02, 0x01, 0x00, 0x03, 0x01, 0xff, 0x00, 0x03, 0x01, 0xfd, 0xfc, 0xff, 0x00, 0xff, + 0xfe, 0xff, 0xff, 0x00, 0x02, 0x00, 0xfe, 0xfe, 0xfd, 0x00, 0x02, 0x00, 0xfe, 0xfe, 0xff, 0x03, 0x02, 0xff, 0xff, 0xfe, 0xfd, 0xfd, + 0x02, 0x00, 0xfe, 0xfe, 0x00, 0x02, 0x00, 0xfc, 0xfd, 0x00, 0x00, 0xfe, 0x00, 0xff, 0xfb, 0xfe, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, + 0xfd, 0xfd, 0xfe, 0xfe, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0x03, 0x00, 0xfe, 0xfe, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, + 0xff, 0xfe, 0xfe, 0xfe, 0xff, 0x01, 0x03, 0x04, 0x04, 0x03, 0x02, 0xfe, 0xfd, 0xfe, 0xfe, 0xfe, 0xff, 0x00, 0x00, 0x01, 0x01, 0xff, + 0xfd, 0xfe, 0xff, 0x00, 0xff, 0xfd, 0xfd, 0xfc, 0xfe, 0xff, 0xfd, 0x01, 0x02, 0x01, 0xfe, 0xff, 0xff, 0xfe, 0xff, 0xff, 0x01, 0x05, + 0xff, 0xfc, 0xfe, 0xff, 0xfe, 0xfd, 0xfd, 0x01, 0x03, 0xff, 0xfb, 0xfd, 0xff, 0x01, 0x03, 0x04, 0x01, 0xfe, 0xfd, 0xfc, 0xfe, 0x02, + 0x03, 0x03, 0x03, 0x03, 0x03, 0x00, 0xfd, 0xfd, 0x01, 0x02, 0xfc, 0xfa, 0xfe, 0x03, 0xff, 0xfc, 0xfe, 0x03, 0x01, 0x01, 0x01, 0xff, + 0x00, 0x04, 0x05, 0x02, 0x01, 0x01, 0x01, 0xfb, 0xfc, 0x00, 0x00, 0xfd, 0xfd, 0x01, 0x01, 0x03, 0x01, 0xfc, 0xfa, 0xfa, 0xfc, 0xfd, + 0xff, 0x00, 0xff, 0x00, 0x00, 0x01, 0x01, 0x01, 0xff, 0xfe, 0x03, 0x00, 0xfe, 0x00, 0x01, 0x00, 0xfd, 0xfc, 0xfc, 0xfa, 0xfa, 0x00, + 0x01, 0x01, 0x03, 0x01, 0x03, 0x05, 0xff, 0xfe, 0xfe, 0xfe, 0xff, 0x04, 0x04, 0x00, 0xfe, 0xff, 0x01, 0x02, 0x02, 0x03, 0x03, 0xfe, + 0xfb, 0xfd, 0x00, 0xff, 0x00, 0x01, 0xfe, 0x01, 0x02, 0x00, 0x00, 0xff, 0xfe, 0xff, 0x03, 0x01, 0xfd, 0xfe, 0xfd, 0xfd, 0xff, 0x00, + 0x01, 0x01, 0x01, 0x00, 0xfd, 0xfa, 0xfb, 0xff, 0x02, 0x02, 0x03, 0x01, 0xff, 0x00, 0xfc, 0xfc, 0x01, 0x01, 0x00, 0x00, 0x02, 0x01, + 0xfd, 0xfb, 0xfe, 0x00, 0x00, 0x00, 0x01, 0xfc, 0xfb, 0xff, 0xff, 0x00, 0x01, 0x01, 0x01, 0x00, 0xfe, 0xfe, 0x00, 0x02, 0x00, 0x02, + 0x02, 0x00, 0x01, 0xff, 0xfe, 0xfe, 0xfb, 0xfe, 0x03, 0x03, 0x03, 0x00, 0xfd, 0x00, 0xff, 0xff, 0x01, 0x03, 0x01, 0x00, 0x03, 0x00, + 0x00, 0x02, 0xfc, 0xff, 0x02, 0xfe, 0xfb, 0xfc, 0x00, 0x02, 0xfe, 0xfd, 0x00, 0xff, 0x00, 0x00, 0xfe, 0x00, 0x02, 0x03, 0x02, 0xfe, + 0xfc, 0xfe, 0xfc, 0xff, 0x02, 0x04, 0xff, 0xfd, 0xfe, 0xfd, 0xfc, 0xfe, 0x01, 0x00, 0xfe, 0xfd, 0xfd, 0x01, 0x03, 0xff, 0xf8, 0xfb, + 0x01, 0x02, 0xfd, 0xff, 0x03, 0x01, 0x01, 0x01, 0x01, 0xfd, 0xff, 0x00, 0xfd, 0xfc, 0x00, 0x03, 0x02, 0x02, 0x02, 0x00, 0xfc, 0xfd, + 0xff, 0xfe, 0xff, 0x00, 0x03, 0x05, 0x07, 0x02, 0xfb, 0x00, 0x00, 0xff, 0x04, 0x03, 0x03, 0x04, 0x01, 0xfb, 0xfb, 0x01, 0x02, 0x00, + 0xfe, 0xfd, 0xfd, 0xff, 0x00, 0xff, 0x00, 0x01, 0x01, 0xfe, 0xfd, 0xfd, 0xfd, 0xff, 0x01, 0x02, 0x04, 0x02, 0xfd, 0xfc, 0xfd, 0xff, + 0xff, 0xfb, 0xfb, 0xff, 0x02, 0xfe, 0xfe, 0xfe, 0xfd, 0xff, 0xfe, 0xfc, 0xfd, 0x00, 0x00, 0xff, 0x01, 0x00, 0x00, 0x01, 0xff, 0x00, + 0x03, 0x02, 0xfe, 0xfd, 0xff, 0xfd, 0xff, 0x01, 0xff, 0x02, 0x00, 0xfd, 0x03, 0xff, 0xfc, 0x00, 0x04, 0x01, 0xfd, 0xfb, 0x01, 0x04, + 0x01, 0x01, 0x03, 0x03, 0x00, 0x01, 0xfe, 0xff, 0x06, 0x02, 0x00, 0x01, 0x00, 0x00, 0xfe, 0xfb, 0xfd, 0xfe, 0xff, 0x01, 0x02, 0x02, + 0x01, 0x00, 0x03, 0x04, 0xfd, 0xfe, 0xfd, 0xfc, 0xfd, 0x01, 0x03, 0x01, 0x00, 0x01, 0xff, 0xfd, 0xfc, 0xfd, 0xfe, 0xfd, 0xfd, 0x00, + 0x03, 0x00, 0xfc, 0xfc, 0x01, 0xfd, 0xfc, 0xfe, 0xff, 0x00, 0x00, 0xfe, 0x04, 0x03, 0xfd, 0xfb, 0xfa, 0xfd, 0x00, 0xfe, 0xff, 0x00, + 0x00, 0x02, 0x06, 0x06, 0x00, 0xff, 0xfe, 0xfd, 0xff, 0x00, 0x01, 0x01, 0xff, 0x00, 0x00, 0xfe, 0xff, 0x01, 0x02, 0x00, 0x00, 0xfe, + 0xfb, 0xfb, 0x01, 0x04, 0xfd, 0x04, 0x04, 0xfb, 0x00, 0x00, 0xfe, 0xfe, 0xfe, 0x02, 0x05, 0x01, 0x03, 0x02, 0xfe, 0x00, 0xfc, 0xf9, + 0xfd, 0xfe, 0xfd, 0xfe, 0x04, 0x06, 0x03, 0xff, 0xfe, 0x00, 0x02, 0x00, 0xfd, 0xfb, 0xfc, 0x05, 0x03, 0xff, 0xff, 0x03, 0x01, 0xfc, + 0xfb, 0xff, 0xfe, 0xfb, 0x00, 0xff, 0x00, 0x05, 0xfd, 0xfa, 0xfe, 0xfe, 0xfd, 0xfc, 0xfe, 0x07, 0x09, 0x04, 0x01, 0x00, 0x03, 0x03, + 0xfe, 0xf9, 0xfb, 0xff, 0xfe, 0x01, 0x02, 0xff, 0x02, 0x02, 0xff, 0xfc, 0xfb, 0xfd, 0xff, 0xfe, 0xfe, 0x01, 0x04, 0x02, 0x00, 0xff, + 0x00, 0xfe, 0xfe, 0x01, 0x02, 0x00, 0xff, 0x01, 0x03, 0x00, 0xf9, 0xfa, 0xfc, 0xfe, 0xff, 0xfd, 0xfe, 0x00, 0xfe, 0xff, 0xff, 0x00, + 0x02, 0x02, 0x00, 0xff, 0x00, 0x01, 0x00, 0xff, 0xfe, 0x00, 0x03, 0x03, 0x03, 0x02, 0xff, 0x00, 0xfc, 0xf9, 0xfe, 0xfe, 0xfe, 0x00, + 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0x02, 0x02, 0x02, 0x02, 0x01, 0x00, 0xfd, 0xfc, 0x00, 0xfe, 0xff, 0x04, + 0xff, 0xfe, 0x00, 0x01, 0x02, 0x02, 0x00, 0xfe, 0xff, 0xff, 0xfe, 0xfc, 0xfe, 0x02, 0x04, 0x02, 0xff, 0xfd, 0xfc, 0xfe, 0xfe, 0xfb, + 0xff, 0x02, 0x01, 0xfe, 0xff, 0xfe, 0xfd, 0xff, 0x01, 0x01, 0xff, 0x01, 0x00, 0xfd, 0xff, 0x03, 0x01, 0xfc, 0xfd, 0xfc, 0xfa, 0xfc, + 0x00, 0x01, 0xff, 0xfe, 0x02, 0x04, 0x02, 0x03, 0xfd, 0xf9, 0xfe, 0x02, 0x03, 0x00, 0x00, 0x00, 0x01, 0x03, 0x01, 0xfe, 0xff, 0x02, + 0x01, 0xfe, 0xfc, 0x01, 0x00, 0xfe, 0x01, 0x03, 0x03, 0x02, 0x02, 0xfe, 0xfb, 0xfa, 0xfb, 0x01, 0x06, 0x05, 0x06, 0x02, 0xfe, 0xfe, + 0xfd, 0xfe, 0x00, 0xff, 0xff, 0xff, 0x00, 0x01, 0x00, 0x00, 0x01, 0xff, 0xfb, 0xfb, 0xff, 0x00, 0xff, 0x01, 0x02, 0x04, 0x04, 0x01, + 0xfb, 0xf9, 0xfd, 0xfe, 0xff, 0x00, 0xfe, 0x02, 0x03, 0x01, 0xff, 0xfc, 0xfb, 0xfd, 0xfb, 0xfc, 0x00, 0x07, 0x00, 0xfd, 0x01, 0x00, + 0xfe, 0xfe, 0x01, 0x00, 0xfe, 0xfd, 0x01, 0x02, 0x04, 0x05, 0xfe, 0xfc, 0xfd, 0xfd, 0xfd, 0xfe, 0x00, 0x03, 0x03, 0x01, 0x00, 0x01, + 0xfe, 0xfb, 0xfb, 0x01, 0x03, 0x01, 0x00, 0xff, 0x00, 0x02, 0x00, 0xff, 0x00, 0x03, 0x01, 0xfe, 0xfb, 0xfc, 0xff, 0x03, 0x05, 0x03, + 0xfe, 0xfb, 0xfd, 0xfb, 0xfe, 0x03, 0xff, 0xfd, 0xff, 0x00, 0xff, 0xff, 0x00, 0x04, 0x03, 0x02, 0x01, 0x01, 0xfd, 0xfb, 0x00, 0xff, + 0xff, 0xff, 0x02, 0xfe, 0xff, 0x04, 0xfe, 0xf9, 0xfa, 0xff, 0x01, 0x01, 0xff, 0xff, 0x00, 0x01, 0x01, 0x02, 0x00, 0xfe, 0x02, 0xff, + 0xfd, 0xfe, 0x00, 0x00, 0xfe, 0xfd, 0x03, 0x01, 0xfb, 0xfa, 0xfd, 0xff, 0xff, 0x02, 0x03, 0x03, 0x01, 0xfd, 0xfc, 0xfd, 0xfd, 0x01, + 0x03, 0x03, 0x03, 0x00, 0xfd, 0xff, 0x02, 0x00, 0xfd, 0x01, 0x02, 0x01, 0x00, 0xfd, 0xfc, 0xff, 0x02, 0x00, 0xfe, 0xff, 0x00, 0xfe, + 0xfd, 0x00, 0x03, 0x03, 0x00, 0x00, 0xfe, 0xfd, 0xfd, 0x00, 0x01, 0x01, 0x01, 0x01, 0x00, 0xfe, 0xfe, 0x02, 0x02, 0x00, 0x00, 0x01, + 0x01, 0xff, 0xff, 0xff, 0xff, 0x02, 0x00, 0x00, 0x02, 0xff, 0xfe, 0x00, 0xff, 0xfb, 0xfc, 0x01, 0x01, 0xfe, 0xfe, 0x02, 0x01, 0xfe, + 0xfc, 0xfd, 0x00, 0x01, 0xff, 0xfc, 0xfc, 0x00, 0x05, 0x04, 0x03, 0x01, 0xfb, 0xfa, 0xfb, 0xfd, 0xfd, 0xff, 0xff, 0xff, 0xff, 0x01, + 0x02, 0xff, 0xfd, 0xff, 0x02, 0xff, 0xfe, 0x00, 0x03, 0x02, 0x00, 0x00, 0x00, 0xff, 0xff, 0xfe, 0xfc, 0xfc, 0xff, 0x02, 0x04, 0x03, + 0x00, 0xfd, 0xfd, 0xfb, 0xf9, 0xfc, 0x01, 0x03, 0x01, 0x04, 0x06, 0x03, 0xfd, 0xfd, 0xff, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x01, + 0x05, 0x04, 0xfd, 0xfb, 0x00, 0xfd, 0xfe, 0x00, 0x02, 0xff, 0xff, 0x02, 0x01, 0x00, 0x00, 0xfe, 0xfd, 0xfc, 0xfd, 0x03, 0x04, 0x02, + 0xff, 0x00, 0xfd, 0xfb, 0xff, 0xfd, 0xff, 0x00, 0xfc, 0xf9, 0xfb, 0x00, 0xfe, 0xff, 0x01, 0xfe, 0xff, 0xff, 0xfe, 0x01, 0x00, 0xff, + 0x00, 0x00, 0x04, 0x04, 0xfe, 0xfe, 0xff, 0xff, 0x01, 0xff, 0xfe, 0xff, 0x01, 0xff, 0xfe, 0x01, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xfe, + 0xfe, 0x00, 0x02, 0x02, 0x02, 0x02, 0x01, 0x00, 0x02, 0xfe, 0xfd, 0x02, 0x02, 0xfe, 0xfd, 0x06, 0xff, 0xfc, 0x02, 0x01, 0xff, 0xff, + 0x00, 0xff, 0x00, 0x02, 0x03, 0xfe, 0xfd, 0x01, 0x03, 0xff, 0xfc, 0xff, 0x01, 0xff, 0xfe, 0x00, 0xfe, 0xfe, 0x00, 0x00, 0x00, 0xfe, + 0xfe, 0xfc, 0xfd, 0x00, 0xff, 0x00, 0x00, 0xfe, 0xfc, 0xff, 0x02, 0xfe, 0xfc, 0xff, 0x02, 0xfe, 0xfc, 0xfe, 0x01, 0xfd, 0xff, 0x04, + 0x02, 0xfd, 0xfd, 0x01, 0x00, 0xfe, 0xfd, 0x00, 0x04, 0x04, 0x01, 0xfd, 0x02, 0x04, 0xfe, 0xff, 0xff, 0xfd, 0xfa, 0xfe, 0x04, 0x06, + 0x02, 0xff, 0xff, 0xff, 0xfd, 0xff, 0x01, 0x00, 0xff, 0xff, 0x00, 0x03, 0x03, 0x00, 0xff, 0xfe, 0xfe, 0xff, 0x00, 0xff, 0x00, 0x02, + 0xff, 0xff, 0xff, 0xfe, 0xff, 0x01, 0x01, 0xfe, 0xff, 0x02, 0x03, 0x00, 0xfe, 0xff, 0x01, 0x01, 0x01, 0x01, 0xfe, 0xfc, 0xfc, 0xfe, + 0x01, 0x01, 0xff, 0xfd, 0xfd, 0xff, 0x01, 0x01, 0xff, 0xfe, 0xff, 0xfc, 0xfc, 0xff, 0x01, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xfe, + 0x00, 0x00, 0xff, 0xff, 0xfe, 0x00, 0x03, 0xfd, 0xfe, 0xff, 0xfd, 0xfe, 0x01, 0x01, 0xfb, 0x01, 0x03, 0xff, 0xfd, 0x01, 0x03, 0xfe, + 0xff, 0xff, 0xfe, 0x01, 0x00, 0x00, 0x03, 0x01, 0x03, 0x03, 0xff, 0xfd, 0xff, 0x00, 0xfc, 0xfc, 0x00, 0x03, 0x03, 0x00, 0xfe, 0xff, + 0xfc, 0xfb, 0xfe, 0x00, 0x02, 0x01, 0xff, 0x05, 0x02, 0xfb, 0xfe, 0x02, 0x01, 0xfc, 0xfe, 0x00, 0x02, 0x03, 0x02, 0x01, 0x01, 0x02, + 0xfb, 0xfa, 0xfe, 0x00, 0xfe, 0xfd, 0x00, 0x00, 0xfe, 0xfd, 0x02, 0xff, 0xfc, 0xff, 0x02, 0x01, 0xff, 0x00, 0xfd, 0xff, 0x01, 0xfe, + 0xfc, 0xfd, 0x02, 0x01, 0x01, 0x00, 0xff, 0xfd, 0xff, 0x02, 0xfe, 0xfe, 0xff, 0xff, 0xfc, 0x00, 0x05, 0x05, 0x00, 0x00, 0x03, 0x01, + 0x00, 0x01, 0x00, 0xfe, 0x00, 0x01, 0xff, 0xff, 0x00, 0x00, 0xfc, 0xfb, 0xfd, 0xff, 0x03, 0x02, 0xff, 0xfc, 0xff, 0xfe, 0xfb, 0x01, + 0x03, 0x00, 0xfe, 0xff, 0x00, 0xff, 0xfe, 0xff, 0xff, 0xfe, 0xfd, 0x01, 0x03, 0xfe, 0x00, 0x00, 0xfe, 0x01, 0x00, 0xfe, 0xfd, 0x01, + 0xff, 0xfd, 0x04, 0x04, 0x02, 0x00, 0xfe, 0xfd, 0xfe, 0x00, 0x01, 0x00, 0xff, 0x01, 0x00, 0xff, 0xfe, 0xfd, 0xfe, 0x00, 0x00, 0x00, + 0x01, 0x02, 0x00, 0x00, 0xff, 0xfd, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xfe, 0xff, 0x01, 0x02, 0x00, 0x00, 0x01, 0xff, 0xfc, + 0xfd, 0x00, 0x00, 0x01, 0x00, 0xfd, 0xff, 0x00, 0x00, 0x01, 0x03, 0x03, 0xff, 0xfc, 0x00, 0x00, 0xfb, 0xfb, 0xff, 0x03, 0x04, 0xff, + 0xfd, 0x00, 0xfe, 0xff, 0xff, 0xfe, 0xff, 0x01, 0x01, 0xff, 0xfd, 0x00, 0x04, 0x01, 0x00, 0xff, 0xfe, 0xfe, 0xfe, 0xff, 0x01, 0x02, + 0x01, 0xfe, 0xff, 0xfe, 0xfd, 0xff, 0xfc, 0xfd, 0x03, 0x06, 0x03, 0x00, 0xff, 0xfd, 0xfe, 0xff, 0x00, 0x02, 0x01, 0xff, 0x00, 0x00, + 0xff, 0xfd, 0xfd, 0xfe, 0x00, 0x01, 0xfc, 0xfd, 0x02, 0x00, 0xff, 0x02, 0x04, 0x00, 0xfc, 0xfc, 0xff, 0xfe, 0xff, 0x02, 0x03, 0x02, + 0x02, 0x02, 0xfe, 0xfe, 0x01, 0x02, 0x00, 0xff, 0xff, 0xff, 0xfe, 0xfe, 0x00, 0xfe, 0xfe, 0x00, 0x02, 0x00, 0xfe, 0xff, 0xfd, 0x00, + 0x04, 0x04, 0xff, 0xff, 0x00, 0xfd, 0xfb, 0xfc, 0x00, 0x04, 0x01, 0xfd, 0xfd, 0xfe, 0xfc, 0xfa, 0xfe, 0x00, 0x01, 0x00, 0xfc, 0xfb, + 0xfe, 0x00, 0x01, 0x00, 0xff, 0x01, 0x04, 0x02, 0xfd, 0x00, 0x01, 0x00, 0xfd, 0xff, 0x01, 0x01, 0x00, 0x00, 0xff, 0xfe, 0x00, 0x01, + 0x01, 0x06, 0x00, 0xfb, 0xfd, 0x01, 0x02, 0x00, 0xff, 0x00, 0x01, 0x01, 0xff, 0xff, 0x00, 0x00, 0x02, 0x01, 0xff, 0xff, 0x00, 0xfd, + 0xfa, 0x01, 0x02, 0x02, 0x02, 0xff, 0xfe, 0xfe, 0xfe, 0xfd, 0xfd, 0x00, 0x04, 0x03, 0xfe, 0xfa, 0xff, 0x00, 0xfe, 0x00, 0x02, 0x01, + 0xfd, 0xfa, 0xfe, 0x01, 0xff, 0xfe, 0xff, 0x01, 0x00, 0xfe, 0xfc, 0xfc, 0xfe, 0x01, 0x02, 0x00, 0x00, 0xfe, 0xfd, 0xfc, 0x02, 0x03, + 0xfe, 0xfd, 0x01, 0x02, 0xfb, 0x00, 0x02, 0x00, 0xfe, 0x00, 0x02, 0x01, 0x01, 0x01, 0x00, 0xff, 0xff, 0x01, 0x02, 0x00, 0xff, 0x00, + 0x02, 0x00, 0xff, 0xff, 0x02, 0xff, 0xfe, 0x00, 0x02, 0x01, 0x01, 0x01, 0xfe, 0xfe, 0x01, 0x02, 0x02, 0x01, 0xff, 0xff, 0x01, 0x03, + 0x04, 0x01, 0xfe, 0xfc, 0xf8, 0xfc, 0x00, 0x01, 0x00, 0x04, 0x04, 0xfb, 0xfb, 0xff, 0x00, 0xfd, 0xff, 0xff, 0xfb, 0xfd, 0xff, 0x00, + 0x04, 0xfe, 0xfd, 0x02, 0x00, 0x02, 0xff, 0xf9, 0xfe, 0x01, 0x00, 0x01, 0xfd, 0xfd, 0x01, 0xfa, 0xfc, 0xff, 0xfd, 0xfc, 0x01, 0x04, + 0xfe, 0xfd, 0x01, 0x03, 0xff, 0xfe, 0x00, 0xff, 0xff, 0x00, 0x01, 0x02, 0x06, 0x04, 0xff, 0x00, 0x03, 0x02, 0xfc, 0xfb, 0xfd, 0xfe, + 0xfe, 0x01, 0x03, 0x02, 0x02, 0x01, 0xff, 0xfd, 0x00, 0x02, 0x03, 0x03, 0x04, 0x02, 0xff, 0x01, 0x01, 0xff, 0xfe, 0xfe, 0xff, 0xff, + 0xfd, 0xfd, 0xfe, 0x01, 0x01, 0x03, 0x01, 0xfb, 0xfc, 0xfe, 0xfe, 0xfd, 0xfe, 0x01, 0x03, 0x03, 0x00, 0xfc, 0xff, 0x01, 0xff, 0xfc, + 0xfe, 0xfc, 0xfc, 0x01, 0xfe, 0xfc, 0xfd, 0xfd, 0xfd, 0xfe, 0xfd, 0x01, 0xff, 0xfe, 0x04, 0x03, 0x00, 0xff, 0xff, 0xfd, 0xfc, 0xfe, + 0x00, 0xff, 0xfe, 0xfe, 0x01, 0x03, 0x04, 0x01, 0xfe, 0xfd, 0xfe, 0xfb, 0xff, 0x05, 0x01, 0x01, 0x02, 0x00, 0xfe, 0x00, 0x04, 0x05, + 0x00, 0x00, 0x02, 0x02, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0xfc, 0xfb, 0xff, 0x03, 0x00, 0xfe, 0x00, 0x04, 0xfd, 0xfc, 0xff, 0xff, + 0x02, 0x04, 0x02, 0xfe, 0xfe, 0x01, 0x02, 0xfb, 0xf9, 0xfe, 0x05, 0x00, 0xfd, 0x01, 0xfe, 0xfe, 0x00, 0xff, 0xfd, 0xfb, 0xfd, 0x02, + 0xff, 0xfe, 0x01, 0x00, 0x00, 0xff, 0x00, 0xfd, 0xfc, 0xfe, 0xfe, 0x00, 0x00, 0xfd, 0x00, 0xfe, 0xfd, 0x02, 0x00, 0xfd, 0xfc, 0xfe, + 0x03, 0x06, 0x03, 0xfc, 0xfd, 0x02, 0x03, 0xff, 0xfc, 0xfc, 0x02, 0x03, 0x01, 0x00, 0x01, 0xfe, 0xfc, 0x02, 0x03, 0x03, 0x02, 0xfc, + 0xfd, 0x01, 0x02, 0x01, 0x02, 0x02, 0xff, 0x00, 0x02, 0x01, 0x00, 0x02, 0x04, 0x04, 0xfd, 0xfd, 0x01, 0xfb, 0xfc, 0xfd, 0xfc, 0x00, + 0x01, 0xff, 0xfd, 0xfc, 0xfd, 0xfe, 0xfa, 0x02, 0x06, 0x01, 0xfc, 0xfd, 0x00, 0xfe, 0xfe, 0x01, 0x04, 0xfd, 0x03, 0x05, 0xfd, 0x01, + 0xfd, 0xfb, 0x03, 0xfe, 0xfa, 0xfd, 0xfe, 0xfe, 0xff, 0x01, 0x00, 0x00, 0xff, 0xfe, 0xff, 0xff, 0xff, 0x04, 0x01, 0x00, 0x05, 0x00, + 0xfc, 0xfe, 0x00, 0x01, 0xff, 0xfd, 0x01, 0x01, 0xff, 0x00, 0xff, 0xff, 0x00, 0x01, 0xff, 0xff, 0x00, 0xff, 0xff, 0x01, 0x03, 0x03, + 0x00, 0xfe, 0xfe, 0x02, 0x04, 0x00, 0xfd, 0xfc, 0xfe, 0x03, 0x03, 0xfe, 0xfb, 0xfc, 0xfc, 0xff, 0x03, 0xfe, 0xfe, 0x02, 0xff, 0xfe, + 0xfd, 0xfd, 0xff, 0x00, 0xff, 0xff, 0x00, 0x01, 0xff, 0xfc, 0x01, 0x02, 0xfd, 0xfe, 0xfe, 0xff, 0xfe, 0x02, 0x00, 0xfd, 0xfb, 0x04, + 0x06, 0xfd, 0xfb, 0xfc, 0xff, 0x01, 0x04, 0x04, 0x01, 0xfd, 0x00, 0x01, 0xfc, 0xfd, 0x00, 0x03, 0x02, 0x04, 0x02, 0xfc, 0xfd, 0xfe, + 0x00, 0x00, 0xff, 0x02, 0x03, 0xff, 0xfd, 0x01, 0x04, 0xfe, 0xff, 0x01, 0x01, 0xff, 0xff, 0x00, 0x00, 0x02, 0x01, 0xfc, 0xff, 0xff, + 0xfe, 0x00, 0xfc, 0xfd, 0x03, 0x02, 0x04, 0x01, 0xfb, 0xfe, 0x01, 0x00, 0xfd, 0xfc, 0xfe, 0x01, 0x01, 0x01, 0x00, 0xff, 0xff, 0xfe, + 0xfd, 0xfe, 0x00, 0x00, 0xfe, 0xfe, 0xff, 0xfe, 0xfd, 0x01, 0x03, 0x01, 0xff, 0xfd, 0xff, 0x00, 0xfc, 0x00, 0x04, 0x02, 0xff, 0xfd, + 0xfd, 0xfe, 0x04, 0x03, 0xfd, 0xff, 0x02, 0x01, 0xff, 0xfe, 0x00, 0x03, 0x00, 0xff, 0x00, 0x02, 0xfe, 0x02, 0x04, 0x01, 0x03, 0x03, + 0x01, 0x00, 0xff, 0x01, 0x02, 0xfe, 0xfc, 0xfd, 0xfe, 0x03, 0x03, 0xfe, 0xf9, 0xfd, 0x01, 0x01, 0x01, 0x00, 0xff, 0xfe, 0xff, 0x01, + 0x02, 0x02, 0xff, 0xfe, 0x01, 0xfe, 0xfd, 0xfe, 0xfe, 0xfe, 0xff, 0x00, 0x00, 0xfd, 0xfb, 0xfd, 0xfd, 0xfd, 0xff, 0xff, 0xff, 0xff, + 0xfe, 0xfd, 0xff, 0x02, 0x05, 0x00, 0xff, 0x01, 0xfe, 0xfe, 0xff, 0x01, 0x01, 0x00, 0xff, 0xff, 0xfd, 0xff, 0x01, 0xff, 0xfc, 0xfe, + 0x01, 0x04, 0x03, 0xff, 0xfe, 0xff, 0x00, 0x01, 0x04, 0x03, 0x00, 0x01, 0x01, 0x02, 0x02, 0xff, 0x01, 0x02, 0x01, 0x02, 0x00, 0xfd, + 0xfb, 0xfc, 0xfe, 0x00, 0xff, 0x04, 0x03, 0xfd, 0xfc, 0xff, 0x01, 0x00, 0x01, 0x03, 0x02, 0xff, 0xfd, 0xfd, 0xff, 0x00, 0x00, 0xff, + 0xfe, 0xff, 0xfe, 0xfc, 0xfd, 0xfe, 0x00, 0x02, 0xfe, 0xfd, 0xfd, 0xfc, 0xfe, 0x01, 0x03, 0x01, 0xfe, 0xfd, 0xff, 0xff, 0xff, 0xff, + 0x01, 0xfd, 0xfd, 0x01, 0x02, 0x00, 0xfd, 0xfe, 0xfe, 0xfd, 0xfd, 0x00, 0x02, 0x02, 0x01, 0x01, 0x00, 0xff, 0x00, 0x02, 0x03, 0x01, + 0xfe, 0xfd, 0xfe, 0xff, 0x01, 0xfd, 0xfc, 0x03, 0x05, 0x02, 0xff, 0x01, 0xfd, 0xfd, 0x03, 0x03, 0x00, 0xfd, 0xfd, 0x01, 0x03, 0x01, + 0x02, 0xff, 0xff, 0x01, 0x01, 0xff, 0xff, 0x01, 0xff, 0xfd, 0xff, 0x03, 0xfe, 0xf9, 0xfc, 0x03, 0x06, 0x02, 0xfc, 0xfd, 0x01, 0x01, + 0x00, 0xff, 0x00, 0x01, 0x01, 0xff, 0xfc, 0xfa, 0xff, 0x00, 0xfd, 0x03, 0x00, 0xfc, 0xfe, 0x00, 0xfd, 0xfa, 0xfd, 0x00, 0x00, 0x00, + 0x01, 0x02, 0x00, 0xfc, 0xff, 0x01, 0xff, 0x01, 0x01, 0xff, 0xfe, 0x03, 0x02, 0xfe, 0xfd, 0xfb, 0xfd, 0x00, 0xfd, 0xfc, 0xff, 0x05, + 0x03, 0x01, 0x01, 0x00, 0xff, 0xff, 0xff, 0xfd, 0xfe, 0x02, 0x04, 0x02, 0x01, 0x01, 0xfe, 0x00, 0x00, 0xfe, 0xff, 0xff, 0x00, 0x02, + 0x02, 0x00, 0xff, 0xff, 0xff, 0x00, 0x02, 0x02, 0xfe, 0xfb, 0xfd, 0x02, 0x05, 0x04, 0x02, 0x00, 0xfe, 0xfc, 0xff, 0xfd, 0xfa, 0xfd, + 0x04, 0x03, 0xfc, 0xff, 0x00, 0xff, 0xfe, 0x00, 0xff, 0xfd, 0xfe, 0x02, 0x00, 0xfa, 0xfe, 0x00, 0xff, 0xff, 0x03, 0x04, 0x01, 0xff, + 0xfe, 0x00, 0x02, 0x00, 0xff, 0xff, 0x00, 0xff, 0xfc, 0xfb, 0xff, 0xff, 0xfe, 0xff, 0x03, 0x01, 0xff, 0x01, 0xff, 0x01, 0x02, 0xfd, + 0xfd, 0xfe, 0xfe, 0xff, 0x04, 0x05, 0x00, 0xff, 0x00, 0x00, 0xff, 0xfd, 0xfc, 0xfc, 0xff, 0x01, 0x01, 0x00, 0x02, 0x01, 0xfe, 0x01, + 0xff, 0xfd, 0xfe, 0xfe, 0x00, 0x02, 0x02, 0x03, 0x03, 0x01, 0xfd, 0xfc, 0xfd, 0xff, 0x00, 0x02, 0x02, 0xff, 0xfe, 0xff, 0x01, 0x01, + 0xff, 0xfe, 0x00, 0xfc, 0xfb, 0xff, 0x05, 0x02, 0x00, 0x03, 0xff, 0xfe, 0xff, 0xff, 0xfe, 0x00, 0x04, 0x02, 0xff, 0xfe, 0xfe, 0x00, + 0xff, 0xfd, 0xfd, 0x02, 0x00, 0xfa, 0xfd, 0x00, 0x01, 0x01, 0x01, 0xff, 0xfd, 0xfd, 0xff, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0xfe, + 0xfe, 0xff, 0x01, 0x03, 0x03, 0x02, 0x00, 0xff, 0xfe, 0xfd, 0xff, 0x01, 0x01, 0xff, 0xff, 0x00, 0x02, 0x00, 0xff, 0xff, 0xfe, 0xfe, + 0xff, 0x01, 0x00, 0xfe, 0xfe, 0x00, 0xfc, 0xff, 0x04, 0x04, 0x01, 0xfe, 0xfc, 0xfd, 0x01, 0x03, 0x03, 0x01, 0x01, 0x00, 0xfd, 0xfa, + 0xfc, 0x02, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0xff, 0xfb, 0xfb, 0xfe, 0x02, 0x02, 0x03, 0x01, 0xfd, 0xfe, 0xfe, 0xfe, 0x01, 0x03, + 0x01, 0xfd, 0xfc, 0xff, 0x03, 0x04, 0x01, 0xfe, 0xff, 0x00, 0xfd, 0xfb, 0xfc, 0xfe, 0x02, 0x05, 0x05, 0xff, 0xfb, 0xfe, 0x02, 0x00, + 0xfe, 0x01, 0x02, 0x00, 0x00, 0x02, 0x01, 0x00, 0x01, 0x00, 0xff, 0xff, 0xff, 0xfc, 0xfc, 0xfe, 0xff, 0x00, 0x00, 0x00, 0xff, 0xfd, + 0xfd, 0xff, 0x01, 0x02, 0x01, 0x01, 0xff, 0xfe, 0xff, 0x01, 0x03, 0x02, 0xfe, 0xfd, 0xfb, 0xfc, 0x02, 0x00, 0xfe, 0x01, 0xff, 0xff, + 0x00, 0xfe, 0xfd, 0xff, 0xff, 0xfe, 0xfd, 0x01, 0x05, 0x03, 0xff, 0xff, 0x03, 0xfb, 0xfb, 0x03, 0x04, 0x01, 0xff, 0x00, 0xfc, 0xfe, + 0x01, 0x00, 0xff, 0xfe, 0xfe, 0xff, 0xfe, 0xfe, 0x00, 0x03, 0x03, 0x01, 0x02, 0xfe, 0xfa, 0xfc, 0xff, 0x01, 0x01, 0x01, 0x02, 0x02, + 0x02, 0x04, 0xff, 0xfb, 0xfc, 0xff, 0xff, 0xff, 0x03, 0x02, 0xfe, 0xfd, 0x03, 0x03, 0xfe, 0xfa, 0xfe, 0xff, 0xfe, 0xfe, 0xff, 0x00, + 0x00, 0x01, 0x02, 0x00, 0xfd, 0xfe, 0xfd, 0xfc, 0xff, 0xfd, 0xff, 0x04, 0x04, 0x01, 0xfe, 0xfc, 0xfc, 0xfd, 0x00, 0x04, 0x01, 0xff, + 0xff, 0xff, 0x00, 0x01, 0x00, 0xfe, 0xfe, 0xfe, 0xfe, 0x02, 0x03, 0x00, 0xff, 0x03, 0x04, 0x00, 0xfe, 0xfd, 0xff, 0x00, 0x00, 0xff, + 0x00, 0x02, 0x03, 0x00, 0xfa, 0xfc, 0xff, 0xff, 0xff, 0x01, 0x03, 0x02, 0xff, 0x00, 0x01, 0x00, 0xff, 0xff, 0xff, 0x00, 0xfe, 0xfe, + 0x01, 0x02, 0x00, 0xfe, 0xff, 0x00, 0xfe, 0xfb, 0x00, 0x00, 0xfd, 0xfd, 0x00, 0x01, 0x01, 0xff, 0xfe, 0xfd, 0xfd, 0x02, 0x02, 0xff, + 0x00, 0xfe, 0xfd, 0xfe, 0x01, 0xfe, 0xfd, 0x01, 0xff, 0xfd, 0xfc, 0xfe, 0x02, 0x03, 0x00, 0x01, 0x00, 0xfd, 0xfc, 0xfd, 0x00, 0x02, + 0x02, 0x00, 0xff, 0x00, 0x02, 0x00, 0xfe, 0x00, 0x02, 0x02, 0x03, 0x03, 0xfd, 0xfa, 0xff, 0x03, 0x03, 0x00, 0xff, 0xff, 0x02, 0x03, + 0xfe, 0xfd, 0xfe, 0xff, 0xff, 0x00, 0x01, 0xfe, 0xfe, 0xfd, 0xfe, 0x01, 0x03, 0x02, 0x00, 0xff, 0x00, 0xff, 0xfc, 0xff, 0x01, 0x01, + 0x00, 0x01, 0xff, 0xfc, 0xfd, 0x00, 0x00, 0xfe, 0xff, 0x01, 0x01, 0xff, 0xfd, 0xfc, 0xfd, 0xfd, 0x01, 0x03, 0xff, 0xff, 0x00, 0x00, + 0x00, 0x01, 0x01, 0xff, 0xff, 0x01, 0x00, 0xfd, 0xfe, 0x02, 0x04, 0xfd, 0xfd, 0x00, 0x00, 0xfe, 0xfb, 0xfb, 0xff, 0x00, 0x01, 0x03, + 0x04, 0x02, 0x00, 0xfe, 0x00, 0x02, 0x02, 0xfe, 0xff, 0x01, 0x00, 0xff, 0x00, 0x00, 0xfd, 0xff, 0x00, 0x00, 0xfe, 0xfe, 0x00, 0x00, + 0x00, 0xfd, 0xfd, 0x01, 0x02, 0x01, 0x01, 0xfe, 0x00, 0x02, 0xff, 0xfe, 0x00, 0x04, 0x02, 0x01, 0xff, 0xfd, 0xfd, 0xfe, 0xfd, 0xfb, + 0xff, 0x00, 0xff, 0xfe, 0x01, 0x02, 0xff, 0xff, 0xff, 0xff, 0x00, 0xfe, 0xfe, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x02, 0x01, 0xff, + 0xfe, 0xff, 0x00, 0x00, 0x00, 0x00, 0xfe, 0x01, 0xff, 0xfc, 0xfe, 0xfd, 0xfc, 0xfe, 0x01, 0x02, 0x04, 0x05, 0x00, 0xfe, 0xff, 0xfd, + 0xfc, 0xfe, 0x01, 0xff, 0x01, 0x03, 0x01, 0xfd, 0xfd, 0xff, 0xff, 0x00, 0x01, 0x00, 0xff, 0xfc, 0xfe, 0x05, 0x05, 0x00, 0xfe, 0x01, + 0xfe, 0xfc, 0xff, 0xff, 0x00, 0x02, 0x05, 0x02, 0x00, 0xff, 0xfe, 0xfb, 0xfb, 0xfd, 0x00, 0x00, 0x00, 0x02, 0x02, 0x02, 0x00, 0x00, + 0xff, 0xff, 0xfe, 0xfe, 0xff, 0x00, 0xfe, 0x01, 0x02, 0xff, 0xfb, 0xfd, 0x02, 0x05, 0x01, 0xff, 0x00, 0x00, 0x00, 0x01, 0x03, 0x00, + 0xfe, 0xfe, 0xfd, 0xfd, 0xfe, 0x02, 0x05, 0x04, 0x01, 0xfe, 0xfb, 0xfc, 0xfe, 0xfe, 0xfe, 0xff, 0x01, 0xff, 0xfe, 0xff, 0x00, 0x00, + 0x01, 0x01, 0x00, 0x01, 0x02, 0x01, 0xfe, 0xfd, 0xfe, 0xfe, 0xff, 0xfd, 0xfd, 0x00, 0x04, 0x00, 0xfa, 0xfd, 0x01, 0x00, 0xfb, 0xfc, + 0xff, 0x00, 0x02, 0x00, 0xfe, 0xfe, 0x00, 0x00, 0x01, 0x03, 0x03, 0x00, 0xfd, 0xfe, 0xff, 0x01, 0x02, 0xfe, 0xfd, 0xff, 0x00, 0xfd, + 0xfc, 0xff, 0x02, 0x02, 0x01, 0x01, 0x01, 0xff, 0x00, 0x04, 0x03, 0xff, 0xfe, 0x03, 0x04, 0x02, 0xff, 0x01, 0x00, 0xfe, 0xfe, 0xff, + 0xff, 0xfe, 0xff, 0xff, 0xff, 0xfd, 0x00, 0xfd, 0xfb, 0xff, 0x02, 0x01, 0xfe, 0xfe, 0x00, 0x01, 0xff, 0x02, 0x00, 0xfc, 0xff, 0x00, + 0x00, 0xff, 0xff, 0xfe, 0xff, 0x01, 0x01, 0xfd, 0xfb, 0xfc, 0x00, 0x01, 0xfd, 0xfd, 0xfe, 0x00, 0x01, 0x00, 0xfe, 0xfd, 0xff, 0x01, + 0x02, 0x01, 0x02, 0x02, 0x00, 0x00, 0xfd, 0xfd, 0xff, 0xff, 0x00, 0x03, 0x04, 0x01, 0xfd, 0xfc, 0x00, 0x01, 0x00, 0xff, 0x00, 0xfe, + 0xfe, 0x01, 0xff, 0x01, 0x03, 0x01, 0x01, 0x00, 0xfd, 0xfe, 0xfe, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0xfe, 0xfc, 0xfb, 0x00, + 0x04, 0x02, 0x01, 0xfe, 0xfc, 0xff, 0x01, 0x00, 0xfe, 0x01, 0x03, 0x01, 0xfd, 0x00, 0x01, 0xff, 0xfd, 0x01, 0x02, 0xfe, 0xfd, 0xff, + 0x02, 0x01, 0xff, 0xfe, 0x00, 0x02, 0x03, 0x01, 0xfd, 0x00, 0xff, 0xfd, 0x00, 0x02, 0x01, 0xff, 0xfe, 0xfe, 0xfe, 0xfe, 0x03, 0x04, + 0x00, 0xfa, 0x00, 0x02, 0xfd, 0xfe, 0x00, 0x01, 0x00, 0x02, 0x00, 0xfb, 0xff, 0x03, 0x03, 0xfe, 0xfc, 0xfe, 0x01, 0x00, 0x00, 0xfe, + 0xfc, 0x00, 0x00, 0xfc, 0xfa, 0xfd, 0xff, 0x00, 0x00, 0x03, 0x04, 0x01, 0xfd, 0xfb, 0xfd, 0x00, 0x03, 0x02, 0x01, 0x02, 0xfe, 0xfd, + 0x01, 0xfd, 0xff, 0x01, 0xfe, 0xfc, 0xfc, 0xfe, 0x01, 0xfe, 0xff, 0x04, 0x00, 0xfe, 0x00, 0x03, 0xfe, 0xff, 0x04, 0x03, 0x02, 0x01, + 0x02, 0x00, 0x00, 0xff, 0xfe, 0xfe, 0xff, 0xff, 0xfd, 0x01, 0x02, 0xfe, 0xfd, 0x00, 0x03, 0x00, 0x00, 0x02, 0x03, 0x02, 0xff, 0xff, + 0x02, 0x00, 0x02, 0x05, 0x02, 0xff, 0xfd, 0xfd, 0xfd, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xfc, 0xfb, 0xfb, 0xfd, 0x00, 0x01, 0x00, + 0x00, 0x02, 0x01, 0xfe, 0xfd, 0xff, 0xff, 0xfe, 0x02, 0xff, 0xfb, 0xfe, 0x01, 0xff, 0xfc, 0xfb, 0xfc, 0xfd, 0xfc, 0xfd, 0xfd, 0xfe, + 0x01, 0x00, 0xfe, 0xfe, 0x02, 0x03, 0x02, 0x01, 0xff, 0x01, 0x03, 0x00, 0xff, 0xff, 0x00, 0xfe, 0x00, 0x00, 0xfe, 0xfd, 0x00, 0x02, + 0x00, 0xfd, 0x00, 0x04, 0x01, 0xfe, 0xff, 0x04, 0x04, 0x03, 0x03, 0x02, 0x00, 0x02, 0x05, 0x03, 0xff, 0xfd, 0x02, 0x01, 0x00, 0xff, + 0xff, 0xff, 0xfd, 0xfc, 0xff, 0x01, 0x01, 0xff, 0x00, 0xff, 0xfe, 0x04, 0xfe, 0xfa, 0x00, 0x00, 0xfe, 0xfd, 0xfc, 0x01, 0x02, 0xfd, + 0xfd, 0xff, 0xff, 0xfc, 0x02, 0x00, 0xf9, 0xf7, 0xfc, 0x00, 0x00, 0x00, 0x03, 0x01, 0xf8, 0xfe, 0x02, 0x01, 0x00, 0x00, 0x01, 0xff, + 0xfd, 0xfc, 0xfc, 0xfe, 0x02, 0x02, 0x00, 0x00, 0xfd, 0xfc, 0x00, 0x04, 0x03, 0x00, 0x00, 0x00, 0xff, 0xff, 0x02, 0x01, 0x00, 0x00, + 0xff, 0xfd, 0xff, 0x06, 0x01, 0xfd, 0x00, 0x05, 0xfe, 0xfa, 0xff, 0x00, 0x00, 0x00, 0x03, 0xfe, 0xfe, 0x03, 0x04, 0x01, 0x00, 0x03, + 0x02, 0x00, 0xff, 0xff, 0x00, 0x01, 0x02, 0xff, 0xfb, 0xf9, 0xf8, 0xfd, 0x00, 0x00, 0xfe, 0x00, 0x01, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfe, 0xfe, 0x01, 0x03, 0x03, 0x01, 0xfd, 0xfb, 0xfe, 0xfd, 0xfd, 0xfd, 0xff, 0xff, 0xfd, 0xfb, 0xff, 0xff, 0xfe, 0x00, + 0x02, 0x01, 0xff, 0x03, 0x00, 0xff, 0x03, 0x06, 0x02, 0xfb, 0xfd, 0xfe, 0xff, 0x01, 0x05, 0x00, 0xfc, 0x00, 0x00, 0xfe, 0xfd, 0xfe, + 0xff, 0xff, 0xfe, 0x01, 0x01, 0xfe, 0xff, 0x02, 0x03, 0x01, 0xff, 0xff, 0x01, 0x02, 0x03, 0x03, 0x02, 0x00, 0xfc, 0xfc, 0xff, 0x00, + 0xfe, 0xfe, 0x01, 0x00, 0xff, 0xff, 0x00, 0xfe, 0xfe, 0x00, 0xfd, 0xff, 0x01, 0x00, 0x02, 0x01, 0xff, 0x00, 0xfe, 0xfd, 0xff, 0x00, + 0x00, 0xfe, 0xfe, 0xfe, 0xff, 0x00, 0x00, 0xfb, 0xfa, 0xff, 0x01, 0x00, 0xff, 0x00, 0x03, 0x05, 0x03, 0xfd, 0xfc, 0x00, 0x03, 0x00, + 0x01, 0x03, 0x01, 0x00, 0xfe, 0xfb, 0xfe, 0x01, 0x02, 0x01, 0x00, 0x01, 0x02, 0xfe, 0x00, 0x01, 0xfe, 0xfd, 0xff, 0x01, 0x01, 0xfe, + 0xfd, 0x00, 0x03, 0x02, 0x00, 0xff, 0x01, 0xfd, 0xfb, 0xfe, 0x05, 0x02, 0xfb, 0x00, 0x00, 0xfe, 0xfc, 0x02, 0x01, 0xfc, 0xfe, 0x02, + 0x02, 0xff, 0xfd, 0xff, 0x01, 0xfe, 0xfe, 0xfe, 0xff, 0x03, 0xff, 0xfe, 0x01, 0x00, 0xff, 0x00, 0x02, 0xff, 0xfd, 0xfd, 0xfe, 0x00, + 0x02, 0x03, 0xfd, 0xfe, 0x02, 0x02, 0xfe, 0xff, 0x02, 0x01, 0xfe, 0x00, 0x04, 0xff, 0xfe, 0xfe, 0xfc, 0xff, 0x01, 0x01, 0x01, 0xff, + 0xff, 0x03, 0x00, 0xff, 0x00, 0x00, 0xfe, 0xff, 0x03, 0x01, 0xff, 0xfe, 0xfe, 0xff, 0xff, 0xff, 0x01, 0xfe, 0xfd, 0xff, 0x02, 0x00, + 0xfd, 0xfd, 0xfe, 0xfe, 0xfe, 0x02, 0x01, 0x01, 0x02, 0x02, 0x02, 0x00, 0xfe, 0xfa, 0xfc, 0x01, 0x02, 0x01, 0xff, 0xfe, 0xfc, 0xfd, + 0xfe, 0xfd, 0xfe, 0xfd, 0xfc, 0xff, 0x00, 0x00, 0xff, 0x01, 0x01, 0x00, 0xff, 0xfd, 0xfe, 0x01, 0x04, 0x02, 0x00, 0x01, 0x04, 0x02, + 0xff, 0x00, 0xfc, 0xfd, 0xff, 0xfd, 0xfe, 0x02, 0x05, 0xfe, 0xfc, 0xff, 0x02, 0x00, 0xfe, 0x00, 0x04, 0x04, 0x02, 0x02, 0x01, 0x00, + 0x00, 0x01, 0xfd, 0xff, 0x03, 0x00, 0xfd, 0xff, 0x02, 0x00, 0xff, 0xff, 0xfe, 0xfc, 0xfd, 0xff, 0xfe, 0xff, 0x02, 0x03, 0x02, 0x02, + 0x03, 0x00, 0xff, 0xfe, 0xfd, 0xff, 0x00, 0xff, 0x00, 0xfe, 0xfc, 0xfd, 0xfd, 0xfd, 0xfd, 0xfe, 0x01, 0xff, 0xfc, 0xfc, 0xff, 0xff, + 0xff, 0x01, 0x01, 0xff, 0xff, 0xfe, 0xff, 0x00, 0x02, 0x01, 0x01, 0x03, 0xff, 0xfb, 0xfb, 0x00, 0x01, 0x00, 0x00, 0x02, 0xff, 0xfc, + 0xfc, 0x03, 0x04, 0x01, 0xfe, 0x00, 0x01, 0x00, 0x02, 0x01, 0xff, 0xff, 0x00, 0xff, 0x00, 0x03, 0xfe, 0xfe, 0x02, 0x03, 0xff, 0xfe, + 0x01, 0xff, 0x00, 0x01, 0xfe, 0xfd, 0xfe, 0x00, 0x02, 0x02, 0x00, 0xff, 0xff, 0xfe, 0xfd, 0x00, 0x03, 0x03, 0xff, 0xfd, 0xfd, 0xfe, + 0xff, 0xfd, 0xfd, 0x00, 0x01, 0xff, 0xfd, 0xfe, 0xff, 0x04, 0x05, 0x00, 0xfe, 0xfd, 0xfd, 0xfc, 0xfe, 0x02, 0x04, 0xff, 0x00, 0x00, + 0xfc, 0xfc, 0xfd, 0x00, 0x02, 0x00, 0xff, 0x01, 0x01, 0xfe, 0xff, 0x03, 0x00, 0xff, 0x00, 0xff, 0x00, 0x01, 0x02, 0x01, 0xff, 0xfe, + 0xfd, 0xfc, 0xfc, 0xfe, 0xfe, 0xff, 0x00, 0x01, 0x01, 0x01, 0x01, 0x03, 0xff, 0xfc, 0xfd, 0x03, 0x01, 0xfd, 0x00, 0x05, 0x03, 0xfe, + 0xff, 0xfd, 0xfd, 0x00, 0x01, 0x01, 0x00, 0xfd, 0xfa, 0xfd, 0x01, 0x01, 0x01, 0x00, 0xfe, 0xfd, 0xff, 0x00, 0xff, 0x03, 0x05, 0x03, + 0x02, 0x00, 0xfd, 0xfb, 0x00, 0x02, 0x00, 0xfe, 0xff, 0x00, 0xfe, 0x00, 0xff, 0xfe, 0x00, 0xfe, 0xff, 0x00, 0xfe, 0xfd, 0xff, 0x02, + 0x00, 0x01, 0x01, 0xff, 0x01, 0x03, 0x02, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xff, 0x01, 0x01, 0xfd, 0xfc, 0xfd, 0xfe, 0xfd, 0xfe, 0x01, + 0xfd, 0xff, 0x04, 0x04, 0xff, 0xff, 0x01, 0x01, 0xfd, 0xfc, 0x00, 0x01, 0x01, 0x01, 0x02, 0x01, 0x00, 0x00, 0xfa, 0xfb, 0xfe, 0xff, + 0x02, 0x00, 0xff, 0x03, 0x00, 0xfe, 0xff, 0xfe, 0xfc, 0xfd, 0x00, 0x01, 0x01, 0x02, 0x03, 0x01, 0xff, 0xff, 0x00, 0xfe, 0xfd, 0xfd, + 0x00, 0x02, 0x02, 0x02, 0x02, 0x03, 0x01, 0xfc, 0xfa, 0xfd, 0x01, 0x00, 0x01, 0x03, 0x00, 0xff, 0x00, 0x01, 0x00, 0xff, 0xff, 0x00, + 0xff, 0x01, 0x06, 0x00, 0x00, 0x00, 0xfe, 0xfc, 0xff, 0x01, 0xfb, 0xfe, 0x02, 0x03, 0x02, 0x01, 0xfe, 0xfc, 0xfd, 0xfe, 0xfe, 0xff, + 0xff, 0xfe, 0xff, 0x02, 0x02, 0xff, 0xfd, 0xfc, 0xfe, 0x01, 0xff, 0x00, 0x02, 0x01, 0xfe, 0xff, 0x01, 0x00, 0xff, 0xfe, 0xfe, 0xff, + 0x00, 0x00, 0xfe, 0x01, 0x02, 0x00, 0xfe, 0xfe, 0xfe, 0xff, 0xff, 0x01, 0x02, 0x02, 0x00, 0x00, 0xff, 0xfe, 0xfe, 0x01, 0x03, 0x05, + 0x00, 0xfe, 0x03, 0x00, 0xfc, 0xfc, 0x02, 0x00, 0xfd, 0xfd, 0xfe, 0x01, 0x02, 0x01, 0x01, 0xff, 0xfd, 0xfe, 0x00, 0x01, 0x00, 0x02, + 0x01, 0x00, 0x02, 0x00, 0xfe, 0xff, 0x00, 0xff, 0xff, 0x01, 0x01, 0xff, 0xfe, 0xff, 0x00, 0xff, 0xfe, 0xfc, 0xfd, 0xff, 0x01, 0x01, + 0x00, 0xff, 0x00, 0xfd, 0xfe, 0xff, 0xfe, 0xff, 0x02, 0x03, 0x00, 0xfe, 0xff, 0x00, 0x00, 0xfe, 0xfd, 0xff, 0x01, 0x00, 0xfe, 0x00, + 0x01, 0x01, 0xff, 0xfc, 0xfd, 0x01, 0x01, 0x00, 0x00, 0x03, 0x01, 0x01, 0x02, 0x01, 0xfe, 0xfd, 0x00, 0x02, 0xfe, 0xfc, 0x01, 0x01, + 0x00, 0xff, 0xfe, 0xff, 0xfe, 0xfd, 0xfc, 0x00, 0x03, 0x00, 0xff, 0x00, 0x01, 0xff, 0x00, 0x00, 0x00, 0xfd, 0x00, 0x03, 0x00, 0xff, + 0xff, 0xff, 0xfe, 0xff, 0x01, 0x01, 0xfe, 0xfd, 0xff, 0xff, 0x00, 0xff, 0xfd, 0xfd, 0xfe, 0x01, 0x02, 0x00, 0xff, 0xff, 0x01, 0x01, + 0xff, 0xff, 0x00, 0xfe, 0xff, 0x03, 0x03, 0x00, 0xfd, 0xfe, 0x01, 0x01, 0xfc, 0xfd, 0x00, 0x01, 0xff, 0x01, 0x01, 0xff, 0x00, 0x00, + 0xff, 0xfe, 0x01, 0x01, 0xff, 0xff, 0x01, 0x01, 0xff, 0xfe, 0x01, 0x02, 0xfd, 0xfe, 0xff, 0xff, 0xfc, 0x01, 0x03, 0xff, 0xfc, 0xfe, + 0x00, 0xfd, 0x00, 0x00, 0xfe, 0x00, 0x00, 0x00, 0x01, 0x01, 0xff, 0xfe, 0xfe, 0xfc, 0xfe, 0x01, 0x01, 0x00, 0xff, 0xff, 0x00, 0x01, + 0x01, 0x00, 0xfe, 0xfd, 0xfe, 0xfe, 0xff, 0x01, 0x00, 0x00, 0xfe, 0xfd, 0xff, 0xfe, 0xfe, 0x00, 0x02, 0x03, 0x01, 0xfe, 0x01, 0x01, + 0x01, 0x03, 0x01, 0xff, 0xff, 0xff, 0x01, 0x02, 0x01, 0x01, 0x01, 0x00, 0xff, 0xff, 0xfe, 0xfe, 0xfd, 0xfe, 0xff, 0xfe, 0x00, 0x01, + 0x01, 0x01, 0x01, 0xff, 0xfc, 0xfe, 0x01, 0x02, 0x00, 0x00, 0xff, 0xfe, 0x00, 0x01, 0x01, 0xff, 0xfe, 0xff, 0x00, 0x00, 0xfd, 0xfd, + 0xff, 0xff, 0x01, 0x01, 0xfc, 0xfe, 0xfe, 0xfd, 0xff, 0x05, 0x04, 0xfe, 0xfd, 0xfd, 0xff, 0x03, 0xff, 0xfd, 0xff, 0xff, 0xfe, 0xff, + 0x00, 0xfd, 0xff, 0x01, 0x00, 0xff, 0xfe, 0xfe, 0xfe, 0x00, 0x01, 0x00, 0xff, 0x01, 0x02, 0x01, 0x02, 0x03, 0x02, 0xfe, 0x00, 0x02, + 0x01, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x01, 0x02, 0xff, 0xfd, 0xff, 0xff, 0xfe, 0x00, 0x01, 0x02, 0x01, 0xff, 0xfd, 0xfd, 0xff, + 0x00, 0xff, 0xfe, 0x00, 0x03, 0xff, 0xfe, 0x01, 0x00, 0x00, 0x00, 0xff, 0xfe, 0xff, 0x00, 0xff, 0xff, 0xff, 0xfe, 0x01, 0x01, 0xfd, + 0xf9, 0xfd, 0x00, 0x00, 0x02, 0x00, 0xff, 0xff, 0x00, 0xff, 0xfe, 0x00, 0x00, 0xff, 0xfe, 0x00, 0x03, 0x02, 0xff, 0xff, 0xfe, 0xfd, + 0xfd, 0x00, 0x01, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x01, 0x02, 0xff, 0xfe, 0xff, 0x00, 0x00, 0x01, 0x02, 0x01, 0x00, 0xff, + 0xfe, 0x01, 0x03, 0x01, 0x01, 0xfe, 0xfe, 0x00, 0xfe, 0xfd, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x02, 0x01, 0xff, 0xfe, + 0x01, 0x01, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0xff, 0x00, 0x00, 0xfd, 0xfe, 0x00, 0x00, 0xfe, 0xfe, 0xfe, 0xfc, 0xfc, 0xff, 0x02, + 0x00, 0x00, 0x00, 0x01, 0x02, 0x01, 0xff, 0xfe, 0xff, 0x00, 0x00, 0x01, 0x01, 0x01, 0x00, 0xfe, 0xfd, 0xfe, 0xfe, 0x00, 0x01, 0x00, + 0xfe, 0xfd, 0xff, 0x00, 0x01, 0x00, 0x00, 0x00, 0xfe, 0xfd, 0xff, 0x02, 0x02, 0x00, 0x01, 0x01, 0xff, 0xfe, 0xff, 0xfe, 0xfe, 0x00, + 0x02, 0x01, 0xff, 0xfd, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x01, 0x01, 0x01, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x02, 0x02, 0x00, + 0xfe, 0xff, 0x01, 0x00, 0x00, 0x00, 0xff, 0xfc, 0xfd, 0xff, 0xfe, 0xff, 0x01, 0x02, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xff, 0x00, 0x03, + 0x01, 0xfe, 0xfe, 0xfe, 0xfd, 0xfe, 0x01, 0x02, 0x02, 0x00, 0xff, 0xff, 0xff, 0xfd, 0x02, 0xff, 0xfd, 0x00, 0x02, 0x00, 0xfd, 0xfe, + 0x00, 0x00, 0xfe, 0x00, 0xff, 0xfe, 0xfe, 0x03, 0x01, 0xfc, 0xfe, 0x02, 0x03, 0x00, 0xfd, 0xfe, 0x02, 0x04, 0x03, 0x00, 0xff, 0xff, + 0xff, 0xff, 0x00, 0x01, 0xff, 0xfe, 0x00, 0xfe, 0xfd, 0xfe, 0xff, 0xff, 0xff, 0xff, 0x00, 0x01, 0x01, 0xfd, 0x00, 0x03, 0x01, 0xff, + 0xfe, 0xfe, 0x00, 0x00, 0xff, 0xff, 0xff, 0x03, 0x02, 0xfd, 0xff, 0xfe, 0xfd, 0xfe, 0xfe, 0x00, 0x02, 0x01, 0xff, 0xfe, 0xff, 0xff, + 0xff, 0xff, 0xfc, 0x00, 0x03, 0x03, 0xff, 0xfd, 0xff, 0x01, 0xfd, 0xfe, 0x00, 0xfd, 0xfe, 0xfe, 0xfe, 0xff, 0x00, 0x01, 0x01, 0xfe, + 0xfe, 0x00, 0xfe, 0xfd, 0x00, 0x03, 0x03, 0x02, 0x01, 0x00, 0x01, 0xff, 0xfd, 0x01, 0x04, 0x03, 0x00, 0x02, 0xfe, 0xfc, 0xff, 0xff, + 0xfd, 0xfc, 0xff, 0x01, 0x01, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x01, 0x00, 0xff, 0x03, 0x04, 0xff, 0x00, 0xfe, 0xfd, 0x02, 0x02, + 0x00, 0xfe, 0xfe, 0xff, 0x01, 0x02, 0x00, 0xfe, 0xff, 0x01, 0xfc, 0xfc, 0xff, 0xff, 0x00, 0x01, 0x02, 0xff, 0xff, 0xff, 0x00, 0xfe, + 0xfd, 0xfe, 0x01, 0x01, 0xff, 0xfe, 0x00, 0x01, 0xfe, 0xfb, 0xfd, 0xff, 0x00, 0xfe, 0xff, 0x01, 0x02, 0xff, 0xff, 0xff, 0xfb, 0xff, + 0x01, 0xff, 0x01, 0x03, 0x03, 0x01, 0x00, 0x00, 0x00, 0xfe, 0x00, 0x00, 0xfe, 0xfd, 0x01, 0x03, 0xff, 0x00, 0x02, 0x02, 0xff, 0xff, + 0x00, 0x00, 0x00, 0x01, 0x03, 0x02, 0x00, 0x01, 0x02, 0x00, 0xfe, 0xfe, 0x00, 0xfc, 0xfd, 0x03, 0x05, 0x01, 0xff, 0x00, 0xfd, 0xfd, + 0xff, 0x01, 0xfe, 0xff, 0x01, 0xff, 0xfd, 0xff, 0x02, 0x00, 0xff, 0xff, 0x00, 0xff, 0xfb, 0xfa, 0x02, 0x02, 0x00, 0x01, 0xff, 0xff, + 0x00, 0xfd, 0xfe, 0xff, 0xff, 0xff, 0x01, 0x01, 0xff, 0xfb, 0xfe, 0x01, 0x00, 0xfe, 0xff, 0x01, 0xff, 0x00, 0x00, 0xfe, 0xff, 0x02, + 0x02, 0xfd, 0xfe, 0x00, 0x00, 0xff, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0xfe, 0xfe, 0x01, 0x03, 0xfd, 0xfe, 0x02, 0xff, 0xfe, 0xff, + 0x01, 0xfe, 0xff, 0x00, 0xff, 0x02, 0x01, 0xff, 0xff, 0xff, 0xff, 0xff, 0x01, 0x01, 0x01, 0x02, 0xff, 0xfe, 0xff, 0x00, 0xfd, 0xfd, + 0x00, 0x01, 0xff, 0xfc, 0xfa, 0xfe, 0x00, 0x00, 0xfe, 0xfe, 0xfd, 0xfd, 0x02, 0x03, 0x02, 0x01, 0x03, 0x01, 0xfd, 0xfd, 0xff, 0x01, + 0x02, 0x01, 0x00, 0xff, 0xfd, 0xfe, 0xff, 0xff, 0x01, 0xfe, 0xfc, 0xfe, 0x00, 0xff, 0xfe, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x01, 0x01, 0x00, 0x02, 0x00, 0xfe, 0xfe, 0xff, 0xff, 0xff, 0x00, 0x00, 0xfe, 0xfe, 0x00, 0x02, 0x00, 0xfe, 0xfd, 0x00, 0x02, + 0xff, 0xfe, 0x02, 0x03, 0xfc, 0xfd, 0x00, 0x02, 0x00, 0x00, 0x00, 0xfc, 0xfe, 0xff, 0xfd, 0xfd, 0x00, 0x01, 0xfd, 0xfc, 0xfd, 0xfe, + 0xfd, 0x01, 0x02, 0x00, 0x00, 0x00, 0xff, 0xff, 0x01, 0x00, 0xff, 0x02, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x01, 0xff, 0xfe, 0xfe, + 0x01, 0x01, 0xff, 0xfe, 0xff, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x02, 0xfe, 0xfe, 0x01, 0x01, 0x00, 0xff, 0x00, 0x00, 0x01, 0x01, + 0xff, 0xfe, 0xfe, 0x00, 0xff, 0x01, 0x02, 0xfd, 0x00, 0x04, 0x04, 0x00, 0xfe, 0xfd, 0xfe, 0xfc, 0xfd, 0x00, 0x01, 0xff, 0x01, 0x03, + 0xfc, 0xfe, 0x00, 0xfd, 0xff, 0xff, 0xfe, 0xfc, 0x01, 0x03, 0x00, 0x00, 0xff, 0xfd, 0xfc, 0xfc, 0xff, 0x02, 0xfc, 0xff, 0x03, 0x01, + 0xff, 0xfe, 0xfd, 0xfc, 0xfc, 0xfe, 0x00, 0xff, 0x01, 0x02, 0x02, 0x02, 0x01, 0xfe, 0xfc, 0xff, 0x00, 0x00, 0x01, 0x03, 0x03, 0x01, + 0xff, 0x00, 0x00, 0xfe, 0xfe, 0x00, 0x01, 0xff, 0xff, 0x01, 0x02, 0x02, 0x00, 0xfe, 0xfe, 0x00, 0x01, 0x00, 0x00, 0x01, 0x03, 0x04, + 0x01, 0x00, 0x00, 0xff, 0xfe, 0xff, 0x00, 0xff, 0xfe, 0xfd, 0xfe, 0xff, 0x00, 0xff, 0xff, 0xfc, 0xfd, 0x02, 0x02, 0x00, 0x00, 0x01, + 0x00, 0xff, 0x00, 0xff, 0xff, 0x01, 0x02, 0xfe, 0xfd, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xfe, 0xfb, 0xfc, 0x00, 0xfe, 0xfe, 0xff, 0x00, + 0xfe, 0xfd, 0xfe, 0x02, 0x01, 0xff, 0xff, 0x03, 0x01, 0xfc, 0xfe, 0x00, 0x01, 0x00, 0xfe, 0xff, 0x01, 0x01, 0xff, 0xff, 0xff, 0xff, + 0x00, 0x00, 0xff, 0x02, 0x01, 0xfe, 0xfe, 0x02, 0x03, 0x01, 0x01, 0x02, 0x03, 0x01, 0x00, 0x02, 0x02, 0xfc, 0x00, 0x01, 0xfe, 0xff, + 0xfe, 0xfe, 0x00, 0xfd, 0xfe, 0x01, 0x02, 0xff, 0xfe, 0xff, 0xff, 0xfe, 0x00, 0x02, 0x02, 0xff, 0xfd, 0x00, 0x00, 0x01, 0x02, 0x00, + 0xfe, 0xfe, 0xff, 0xfd, 0xff, 0x01, 0x00, 0xfe, 0xfe, 0xfe, 0x00, 0xfe, 0xfd, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xfd, + 0xfe, 0xff, 0xff, 0x01, 0x01, 0x00, 0xfe, 0xfd, 0xfe, 0x01, 0x03, 0x01, 0x00, 0x01, 0x01, 0xfe, 0xfd, 0xfe, 0x00, 0x01, 0xff, 0x01, + 0x00, 0xfe, 0xfe, 0x01, 0x03, 0x01, 0xfe, 0xff, 0x00, 0x00, 0xfc, 0xfe, 0x03, 0x04, 0x02, 0xff, 0xfe, 0x00, 0xff, 0xfe, 0x00, 0x01, + 0x00, 0xff, 0x01, 0xff, 0xfd, 0xfe, 0xfc, 0xff, 0x01, 0xfd, 0x00, 0x02, 0x00, 0xff, 0xfe, 0xff, 0x01, 0x00, 0xfe, 0xfe, 0x01, 0xff, + 0xff, 0x00, 0xff, 0x01, 0x02, 0x02, 0x01, 0x00, 0xfe, 0xfd, 0xfc, 0xff, 0x02, 0xff, 0x00, 0x00, 0xfe, 0xfd, 0xff, 0x01, 0x01, 0xff, + 0xff, 0x00, 0x01, 0x01, 0x01, 0x02, 0x04, 0x00, 0xfd, 0xff, 0xfe, 0xfd, 0xff, 0xff, 0x02, 0x03, 0xff, 0xfe, 0xfd, 0xfd, 0xff, 0xfe, + 0xfe, 0xfe, 0xfe, 0xff, 0x00, 0x02, 0x01, 0x02, 0x03, 0xff, 0xfe, 0xfe, 0xff, 0x00, 0x00, 0x01, 0x01, 0x01, 0x00, 0xff, 0xfd, 0xfd, + 0xfe, 0xff, 0xfd, 0xfe, 0x00, 0x00, 0x00, 0x00, 0xff, 0xfe, 0xfd, 0xfd, 0x00, 0x00, 0x00, 0x02, 0x02, 0x01, 0xff, 0xfe, 0xfe, 0x01, + 0x01, 0xfe, 0xff, 0xfd, 0xfc, 0x00, 0x00, 0xff, 0x00, 0x01, 0xfe, 0xfc, 0xfe, 0x00, 0x01, 0x01, 0x04, 0x02, 0xff, 0xff, 0x00, 0x00, + 0x01, 0x01, 0x00, 0x00, 0x00, 0xfe, 0x01, 0x01, 0xfd, 0xfd, 0x01, 0x03, 0xfe, 0xfc, 0xfe, 0x00, 0x00, 0x01, 0x02, 0x02, 0xfe, 0xfe, + 0x02, 0x03, 0x01, 0xff, 0xff, 0xfd, 0xff, 0x01, 0xff, 0x00, 0x01, 0x00, 0xfd, 0xfd, 0xff, 0x01, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, + 0xff, 0x02, 0x01, 0xfe, 0xfd, 0x01, 0xff, 0xfc, 0xfe, 0x00, 0x00, 0x01, 0x00, 0x00, 0xfe, 0xfb, 0xfe, 0x01, 0x01, 0xff, 0xfe, 0xff, + 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xfe, 0xfe, 0xff, 0xff, 0x00, 0x01, 0x02, 0x01, 0xff, 0xfe, 0xff, 0x00, 0x01, 0x00, 0x02, 0x03, + 0x02, 0xff, 0xff, 0x01, 0x01, 0xfe, 0xff, 0x02, 0x02, 0xff, 0xff, 0x03, 0xff, 0xff, 0x00, 0xfe, 0xff, 0x00, 0xff, 0xfd, 0x00, 0x02, + 0xff, 0xff, 0x01, 0x02, 0xfd, 0xff, 0x00, 0xff, 0xfe, 0x01, 0x02, 0x00, 0xff, 0xfe, 0xfd, 0xfe, 0xff, 0xfe, 0xfc, 0xfe, 0x00, 0x00, + 0xff, 0xff, 0xff, 0xff, 0xfe, 0xff, 0xff, 0xff, 0x01, 0x01, 0x00, 0xff, 0xfe, 0x01, 0x03, 0x02, 0xfe, 0xfd, 0xff, 0x00, 0x00, 0x00, + 0xff, 0xff, 0xfe, 0xfd, 0xfd, 0xfe, 0x00, 0x00, 0x01, 0x01, 0x01, 0x00, 0xfe, 0xff, 0x00, 0xff, 0x00, 0x01, 0x01, 0x00, 0x00, 0x01, + 0x01, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x01, 0x02, 0x01, 0xff, 0xfe, 0xfe, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x01, + 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xfe, 0xfe, 0xff, 0xfe, 0xff, 0xff, 0xff, 0xff, 0x00, 0x01, + 0xff, 0xff, 0xfe, 0xfd, 0x00, 0xff, 0xfe, 0x01, 0x01, 0x00, 0xff, 0x00, 0xfe, 0xfd, 0xfe, 0x00, 0xff, 0xfe, 0xff, 0x01, 0x00, 0xfe, + 0xff, 0x00, 0x00, 0x00, 0xfd, 0xfe, 0xff, 0xff, 0xff, 0xff, 0x00, 0x01, 0x01, 0xff, 0xff, 0xff, 0x00, 0x00, 0x01, 0x00, 0xff, 0xff, + 0x00, 0x00, 0x00, 0x02, 0x00, 0xfe, 0xff, 0x00, 0x00, 0xff, 0xff, 0x01, 0x01, 0x01, 0x01, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xff, 0x03, + 0x01, 0xff, 0xff, 0x00, 0x02, 0x01, 0xff, 0xff, 0xfd, 0xfd, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xfe, 0x01, 0x00, 0xfe, 0xfd, 0xfe, + 0x00, 0x02, 0x01, 0x00, 0x00, 0xff, 0xfc, 0xfe, 0x00, 0x00, 0xfe, 0x00, 0x00, 0xfe, 0xfd, 0x00, 0x02, 0xff, 0xfd, 0xfd, 0xff, 0xff, + 0xfe, 0xff, 0x00, 0x02, 0x01, 0x00, 0x00, 0x01, 0xff, 0xfd, 0xfd, 0x00, 0x03, 0x03, 0x01, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xfd, + 0xfe, 0x00, 0x01, 0xff, 0xfe, 0xff, 0x02, 0xff, 0xfd, 0xff, 0x03, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x02, 0x01, 0x00, 0x00, 0xff, + 0xff, 0x00, 0x01, 0x00, 0xff, 0xff, 0x02, 0xff, 0xfe, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xfd, 0xff, 0x01, 0x01, 0x00, 0xfd, + 0xfe, 0x01, 0x00, 0xff, 0x00, 0x01, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x01, 0x02, 0xff, 0xfc, 0xfd, 0x00, 0x00, 0xff, 0xff, 0xff, + 0x00, 0xff, 0xfc, 0xff, 0x01, 0x01, 0xfe, 0x00, 0x00, 0xfe, 0xff, 0x00, 0x01, 0x02, 0x00, 0xff, 0xff, 0xfe, 0xfe, 0xff, 0x01, 0x00, + 0xfe, 0xfd, 0xfe, 0x01, 0x01, 0xfe, 0xff, 0xff, 0xff, 0xfe, 0x00, 0x02, 0x02, 0x01, 0x01, 0x00, 0x01, 0x00, 0xff, 0xff, 0x01, 0x00, + 0x00, 0x01, 0x02, 0x00, 0xfe, 0xff, 0xff, 0xff, 0xfe, 0xfe, 0xff, 0x00, 0xff, 0x00, 0x01, 0x01, 0x00, 0xff, 0xfe, 0xfe, 0x00, 0xff, + 0xff, 0x00, 0x00, 0x00, 0x00, 0x02, 0xfe, 0xfe, 0xfe, 0xfd, 0xfd, 0x00, 0x01, 0x01, 0xff, 0xff, 0x00, 0xff, 0xfe, 0xfe, 0x00, 0x00, + 0x00, 0x01, 0xff, 0x00, 0x01, 0x00, 0x00, 0xff, 0x00, 0x01, 0x01, 0xff, 0xfd, 0xfe, 0x01, 0x02, 0x00, 0xff, 0xff, 0xfe, 0xfd, 0x00, + 0x02, 0xff, 0xff, 0x01, 0x01, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xff, 0x01, 0x00, 0x02, 0x00, 0xfe, 0xff, 0x00, 0x00, 0xfe, 0x00, 0x00, + 0xff, 0xfe, 0xff, 0xff, 0xff, 0xfe, 0xff, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x01, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, + 0x01, 0x01, 0x00, 0xff, 0xfe, 0xfe, 0xff, 0xff, 0xff, 0xfe, 0xff, 0xff, 0xfe, 0xfe, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, + 0x01, 0x00, 0x00, 0x00, 0x00, 0xfe, 0x00, 0x01, 0xff, 0x00, 0x01, 0x00, 0xfe, 0xfe, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, + 0x01, 0x01, 0x00, 0xff, 0xff, 0x00, 0x02, 0x01, 0x00, 0x00, 0xfe, 0xfd, 0x00, 0x01, 0xff, 0xfd, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, + 0xfe, 0xfd, 0xff, 0x01, 0xff, 0xfd, 0xfd, 0x00, 0x02, 0x00, 0x00, 0x02, 0xff, 0xfe, 0xfd, 0xfd, 0x00, 0x02, 0x01, 0x00, 0x00, 0xff, + 0xff, 0xff, 0xfd, 0xfd, 0xff, 0xfe, 0xff, 0x01, 0x00, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xfe, 0x01, 0x00, 0xff, 0xff, 0x00, 0x00, 0x01, + 0x00, 0xfe, 0x00, 0x02, 0x01, 0xfe, 0xff, 0x02, 0x02, 0x00, 0xff, 0x01, 0xff, 0xfe, 0xfe, 0x01, 0x00, 0x01, 0x02, 0x01, 0xff, 0xfe, + 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x01, 0x01, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x02, 0x00, 0xfe, 0xfd, 0xfe, 0x00, 0xff, 0xfd, + 0xfd, 0xfd, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xfd, + 0xfe, 0x00, 0xff, 0xfe, 0x00, 0x01, 0xff, 0xfe, 0x00, 0x00, 0xfd, 0xfd, 0xff, 0x00, 0x00, 0x03, 0x01, 0xff, 0x00, 0x02, 0x00, 0xfe, + 0x00, 0xff, 0xff, 0x01, 0x00, 0x01, 0x01, 0x00, 0x00, 0xfe, 0xfd, 0xfd, 0x00, 0x01, 0xff, 0x01, 0x00, 0x00, 0x01, 0xff, 0x00, 0x01, + 0x00, 0x01, 0x01, 0x00, 0xff, 0xff, 0x00, 0x02, 0x01, 0x00, 0xff, 0xfe, 0xfe, 0xfe, 0xfe, 0x00, 0x02, 0x02, 0xfd, 0xfd, 0xff, 0x00, + 0xff, 0x00, 0x01, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xfe, 0xfe, 0x00, 0xff, 0xfe, 0xff, 0x00, 0xff, 0xfd, 0xfd, 0xff, 0xff, 0xfe, + 0x00, 0x00, 0xff, 0xfe, 0x02, 0x02, 0x00, 0xfe, 0xff, 0x01, 0x00, 0x00, 0x00, 0x00, 0xfe, 0x00, 0x01, 0x00, 0xff, 0xff, 0xfd, 0xfd, + 0x00, 0x01, 0x00, 0xff, 0x01, 0x00, 0xfe, 0x00, 0xff, 0xff, 0x01, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0xfe, 0xfe, 0x00, + 0xff, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0xff, 0xff, 0xff, 0xfd, 0xff, 0x00, 0x00, 0xff, 0xff, 0x01, 0x01, 0x00, 0xfe, 0xfe, 0x00, + 0x00, 0xfe, 0xfe, 0xff, 0x01, 0x01, 0x00, 0xff, 0xff, 0xff, 0xfe, 0x00, 0x00, 0xff, 0xff, 0x01, 0x01, 0x01, 0xff, 0x00, 0x01, 0xfe, + 0xfd, 0xff, 0x01, 0x00, 0xfe, 0xfe, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x01, 0x01, 0x00, 0xff, + 0xfe, 0xff, 0x00, 0xff, 0xfc, 0xfd, 0x01, 0x01, 0xff, 0xfe, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x01, 0x01, 0x00, 0x02, + 0x01, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xfe, 0xff, 0xff, 0x00, 0x00, 0xff, 0xfe, 0xfe, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, + 0xff, 0x00, 0x01, 0x01, 0x00, 0x00, 0xff, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0xff, 0xff, 0xfd, 0xfb, 0xfc, 0x01, 0x00, + 0x01, 0x01, 0xfe, 0xff, 0x00, 0x00, 0xfc, 0xfe, 0x01, 0x01, 0xff, 0x01, 0x02, 0x00, 0xff, 0xfe, 0xfe, 0x00, 0x00, 0xff, 0xff, 0xfe, + 0xfe, 0xff, 0x01, 0x00, 0xff, 0xfe, 0xfe, 0xfe, 0xfe, 0x00, 0x01, 0x02, 0x01, 0xff, 0xff, 0x00, 0x01, 0xff, 0xfe, 0xfe, 0xff, 0x00, + 0x01, 0x00, 0xff, 0x00, 0xff, 0xfe, 0x01, 0xff, 0xfd, 0xff, 0x01, 0x00, 0xfe, 0x00, 0x00, 0xff, 0xff, 0xfe, 0x00, 0x02, 0x01, 0xff, + 0xff, 0x00, 0x01, 0x00, 0xff, 0x00, 0xff, 0xfe, 0xff, 0x00, 0x01, 0x01, 0x00, 0xff, 0xff, 0xfe, 0xfe, 0xff, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xfe, 0x00, 0x01, 0xff, 0xff, 0x00, 0x01, 0x01, 0xff, 0xfe, 0xfe, 0xff, 0x00, 0x01, 0x00, 0x00, + 0x00, 0x00, 0xfe, 0xff, 0x00, 0xfe, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xfe, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, + 0x00, 0xff, 0x00, 0xff, 0xfd, 0x00, 0x00, 0x00, 0xff, 0xfe, 0xfe, 0xff, 0xff, 0x01, 0xff, 0xfd, 0xff, 0x00, 0xff, 0xff, 0x01, 0x01, + 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0x01, 0x00, 0xff, 0xff, 0xfe, 0xfd, 0xfe, 0xff, 0x00, 0x00, 0x01, 0xff, 0xfe, 0xff, 0xfe, 0xfc, + 0xfe, 0x03, 0x01, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0xfe, 0xfd, 0xff, 0x02, 0x01, 0xff, 0xff, 0x00, 0xff, + 0xfe, 0xff, 0xfe, 0xfe, 0x00, 0x02, 0x02, 0xff, 0xfe, 0xfe, 0xff, 0xff, 0xfe, 0x02, 0x03, 0x00, 0x01, 0x01, 0x00, 0x00, 0xff, 0xfe, + 0xff, 0x01, 0xff, 0xfd, 0xfe, 0xff, 0x00, 0x01, 0x01, 0x00, 0xfe, 0xfe, 0xff, 0xff, 0xff, 0x00, 0x02, 0x02, 0xff, 0xfe, 0xfe, 0xff, + 0xff, 0xff, 0xfe, 0xfe, 0x00, 0x01, 0x00, 0xff, 0xff, 0xfe, 0xfc, 0xfc, 0xff, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x00, 0xff, 0xfd, + 0xfe, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xfe, 0xff, 0x02, 0x01, 0xff, 0x00, 0xfe, 0xfe, 0xfe, + 0x00, 0x01, 0x00, 0x00, 0x00, 0xff, 0x00, 0x01, 0x00, 0x01, 0x01, 0xff, 0xfe, 0xff, 0x00, 0x00, 0x00, 0x01, 0x00, 0xff, 0x00, 0x00, + 0xfd, 0xfe, 0x00, 0x01, 0xfe, 0x00, 0x01, 0x01, 0xff, 0xff, 0xff, 0xfc, 0xff, 0x01, 0x00, 0xfd, 0x00, 0x02, 0x01, 0xff, 0xff, 0x00, + 0xfe, 0xff, 0xff, 0xfe, 0xff, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0xff, 0xfe, 0xfd, 0xfd, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x01, + 0x00, 0xfd, 0xfe, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xfe, 0xfe, 0xff, 0xff, 0xff, 0xfe, 0x00, 0x01, 0x01, + 0x00, 0xff, 0xff, 0xfe, 0xfe, 0xff, 0x00, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0xff, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xfe, + 0xff, 0xfe, 0xfe, 0x00, 0x01, 0xff, 0xfd, 0xff, 0x00, 0x01, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, + 0x01, 0x01, 0xff, 0xfe, 0xfe, 0xff, 0x00, 0x00, 0xfe, 0xfe, 0x00, 0xff, 0x00, 0x02, 0x02, 0xff, 0xff, 0xff, 0xfe, 0xfe, 0x00, 0x03, + 0x01, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xfe, 0xff, 0xff, 0xff, 0xff, 0x01, 0xfe, 0xfe, 0x01, 0x00, 0xfd, 0xfe, 0x01, + 0x00, 0xff, 0x01, 0x01, 0xff, 0xfe, 0xff, 0x00, 0xff, 0xfe, 0x00, 0xff, 0xfe, 0xfe, 0x00, 0xff, 0xfe, 0xff, 0xff, 0xfe, 0xfe, 0x00, + 0x00, 0x00, 0x00, 0xff, 0xfe, 0xff, 0xff, 0x01, 0x00, 0x00, 0x02, 0x00, 0x00, 0x01, 0x00, 0x02, 0x01, 0xfe, 0xfe, 0x00, 0x01, 0xfd, + 0xff, 0x02, 0x02, 0x00, 0xff, 0xff, 0xff, 0xfe, 0x00, 0x01, 0xff, 0x01, 0x02, 0x00, 0xfe, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x01, + 0x01, 0x00, 0xff, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xff, 0x00, 0x00, 0x01, 0xff, 0xfd, 0xfe, 0x00, 0x00, 0xff, 0x01, + 0x01, 0x00, 0xff, 0xff, 0xfe, 0xfe, 0xfe, 0x00, 0x01, 0xff, 0xfe, 0x00, 0x02, 0x00, 0xfd, 0xfc, 0xfd, 0xfe, 0x00, 0x00, 0x00, 0x02, + 0x01, 0xff, 0xfe, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x01, 0x01, 0x00, 0x00, 0xff, 0xfe, 0xff, 0x00, 0x00, 0x01, 0x02, 0x00, + 0xff, 0xfe, 0xfe, 0x00, 0xff, 0xfe, 0x01, 0x01, 0x01, 0x00, 0xff, 0xff, 0xff, 0x01, 0x00, 0x00, 0xff, 0x00, 0x01, 0x01, 0x00, 0xff, + 0xff, 0x00, 0x00, 0x00, 0xff, 0xfe, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xfd, 0xfd, 0xfe, 0xfe, 0xff, 0x03, 0x03, 0xff, 0xff, + 0x00, 0x00, 0xfd, 0xff, 0x01, 0x01, 0x00, 0xff, 0xff, 0xfe, 0xfe, 0xff, 0x00, 0xfe, 0xfe, 0xff, 0xff, 0x00, 0xff, 0xfe, 0x00, 0x01, + 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x01, 0x00, 0xfe, 0xfd, 0xfd, 0xff, 0x01, 0x01, 0x00, 0x00, 0xff, 0x00, + 0xfe, 0xfd, 0x00, 0x02, 0x02, 0x01, 0x01, 0x00, 0x00, 0xff, 0x00, 0x01, 0xff, 0x00, 0xff, 0xfe, 0x01, 0x01, 0x00, 0x00, 0x02, 0xff, + 0xfd, 0xfe, 0xff, 0xfe, 0xfe, 0x00, 0x01, 0x01, 0xff, 0xfe, 0xfe, 0x00, 0x02, 0x00, 0xff, 0xff, 0xff, 0x00, 0x01, 0x00, 0xfe, 0x01, + 0x01, 0xfd, 0xfe, 0xff, 0xff, 0x00, 0x01, 0x00, 0xfd, 0xff, 0x00, 0xff, 0xfc, 0xff, 0x00, 0xff, 0x01, 0x02, 0x00, 0xfd, 0xff, 0xff, + 0xff, 0x00, 0xff, 0xff, 0x00, 0x02, 0x01, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0x00, 0x01, 0x00, 0xff, 0x00, 0x00, 0xff, 0xfe, + 0xff, 0x02, 0xfe, 0xfe, 0x01, 0x01, 0xff, 0xff, 0x01, 0x01, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x01, 0xff, 0xfe, 0xff, 0x00, 0x00, + 0xff, 0x00, 0xff, 0xff, 0xff, 0xfe, 0xfe, 0xff, 0xff, 0xfe, 0xfe, 0x01, 0x03, 0x01, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, + 0x00, 0xfe, 0xff, 0x00, 0x00, 0xfe, 0xff, 0xff, 0xfd, 0xfe, 0xff, 0xff, 0xff, 0x00, 0x00, 0xfe, 0xfe, 0x00, 0x00, 0xfe, 0x00, 0x00, + 0xff, 0x00, 0x02, 0x02, 0xff, 0x00, 0x00, 0xfe, 0xff, 0xff, 0xff, 0xff, 0x00, 0x01, 0x01, 0x00, 0xff, 0xff, 0xff, 0xfe, 0xfe, 0x00, + 0x01, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x01, 0xff, 0x00, 0x00, 0xff, 0xff, 0x01, 0x01, 0xfe, 0x00, 0x00, 0xfe, 0xfe, 0xfe, 0xff, + 0xfe, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0xff, 0xff, 0x00, 0xff, 0xfe, 0xff, 0xff, 0x00, 0x02, 0x01, 0xfe, 0xfd, 0x00, 0x00, 0xff, + 0xff, 0xfd, 0xfd, 0xff, 0x01, 0xfe, 0xfe, 0x02, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x01, 0x01, + 0xff, 0xfe, 0xff, 0x01, 0xff, 0xff, 0x00, 0x01, 0x00, 0xff, 0xff, 0x00, 0x02, 0x00, 0xfd, 0xff, 0xfe, 0xfe, 0xff, 0xff, 0xff, 0x00, + 0x00, 0x00, 0x01, 0x00, 0x00, 0xff, 0xff, 0x00, 0x01, 0x01, 0x00, 0xff, 0xff, 0xff, 0x00, 0x01, 0x00, 0xff, 0xfe, 0xff, 0xff, 0x00, + 0x01, 0x02, 0x00, 0xfc, 0xfe, 0xff, 0xfe, 0x00, 0x00, 0x01, 0x01, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, + 0x01, 0xff, 0xff, 0x02, 0xfe, 0xfe, 0xff, 0xfe, 0xff, 0x00, 0x01, 0x00, 0x01, 0x02, 0x01, 0xfd, 0xfe, 0x01, 0x02, 0x01, 0x00, 0x01, + 0xff, 0x00, 0x01, 0x00, 0xfd, 0xfd, 0xfe, 0x00, 0xff, 0xfe, 0xff, 0x01, 0xff, 0xfd, 0x00, 0x00, 0x01, 0x01, 0xff, 0x00, 0x00, 0xfe, + 0x01, 0x02, 0x00, 0xfe, 0xff, 0xff, 0xfe, 0x00, 0xff, 0xfe, 0xfe, 0x01, 0x00, 0xfe, 0xfe, 0xfe, 0xfe, 0xff, 0x00, 0x01, 0x01, 0x00, + 0x00, 0x00, 0xff, 0xfe, 0x00, 0x01, 0xff, 0xfe, 0xff, 0x00, 0x00, 0x02, 0x01, 0xff, 0xfe, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, + 0xff, 0xff, 0x00, 0xff, 0xfe, 0xfe, 0x00, 0x00, 0x02, 0x02, 0x00, 0x00, 0xff, 0xfe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0xff, + 0xff, 0x00, 0x00, 0xfe, 0xff, 0x00, 0x00, 0xff, 0x00, 0x01, 0x00, 0xff, 0xff, 0xff, 0xfc, 0xfd, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, + 0xfe, 0xfe, 0x00, 0xff, 0xff, 0xff, 0x00, 0x01, 0x00, 0xff, 0xfd, 0xff, 0x00, 0xff, 0xff, 0x00, 0x01, 0xff, 0xfe, 0xfe, 0xfe, 0x00, + 0xff, 0xfe, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x02, 0x01, 0xfe, 0xfe, + 0xff, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0xff, 0xff, 0x01, 0x02, 0x02, 0x01, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, + 0x00, 0xff, 0xfe, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x02, 0xff, 0xfe, 0x00, 0xff, 0x00, 0xff, 0xfe, 0xfe, + 0x00, 0x00, 0xff, 0x00, 0x01, 0x00, 0xfd, 0xfe, 0xff, 0xfd, 0xfe, 0x00, 0xff, 0xfd, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, + 0xff, 0xff, 0x00, 0x01, 0x01, 0x01, 0xff, 0xfe, 0xff, 0xfe, 0xfe, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xfe, 0x00, 0xff, + 0xff, 0x00, 0x02, 0x02, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x01, 0x01, 0xff, 0xfe, 0xff, 0x01, 0x00, 0x00, 0xff, 0xfe, 0xff, 0x00, + 0xff, 0xfe, 0x00, 0x01, 0x01, 0x01, 0xfe, 0xfc, 0xfd, 0xff, 0x01, 0x01, 0x01, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, + 0xff, 0xff, 0xfe, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xfe, 0xff, 0x00, 0xfe, 0x00, 0x01, 0xff, 0xfd, 0xfe, + 0xff, 0x01, 0x01, 0xff, 0xfe, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x01, 0x00, 0xfd, 0xfe, 0xff, 0x00, 0x00, 0x00, 0x01, + 0x01, 0x00, 0x01, 0x01, 0xff, 0xfe, 0x00, 0x01, 0x00, 0xfe, 0xff, 0x01, 0x02, 0x01, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x01, 0x00, + 0xff, 0x01, 0x00, 0xfe, 0xfe, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x01, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, + 0x00, 0x00, 0x01, 0x00, 0xfe, 0xfe, 0xff, 0xff, 0xfe, 0xfe, 0xff, 0x00, 0xff, 0x00, 0x00, 0xfd, 0xfd, 0x00, 0x02, 0x00, 0xff, 0xff, + 0x01, 0x01, 0x00, 0x00, 0x00, 0xfe, 0xff, 0x00, 0xfe, 0xff, 0xff, 0xff, 0x01, 0x01, 0x01, 0x01, 0xfe, 0xfd, 0xfe, 0xfe, 0xfe, 0x00, + 0x01, 0x02, 0x01, 0x00, 0x01, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0xfe, 0xfe, 0xff, 0x00, 0xfe, 0xff, 0xff, 0x00, + 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x01, 0x00, 0xff, 0xff, 0xff, 0x02, 0x02, 0x00, 0x01, 0x00, 0xfe, 0xfd, 0xfe, 0xff, + 0x01, 0xff, 0xff, 0x00, 0xff, 0xfe, 0xff, 0x01, 0xff, 0xfe, 0xff, 0x01, 0x01, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0xfe, + 0xfd, 0x00, 0x01, 0x00, 0x00, 0xff, 0xfe, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x01, 0x01, 0x00, 0xff, 0x00, 0x00, + 0x00, 0x00, 0xff, 0xff, 0xff, 0x01, 0x01, 0xff, 0xfe, 0xff, 0xff, 0xff, 0xff, 0x00, 0x01, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, + 0x01, 0x00, 0xff, 0xfe, 0xff, 0x00, 0x01, 0x00, 0x01, 0x02, 0x01, 0xff, 0xff, 0xfe, 0xfe, 0xfe, 0x00, 0x02, 0x01, 0x00, 0xff, 0xff, + 0x01, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xfd, 0xff, 0x01, 0x00, 0xff, 0xff, 0x00, 0x01, 0xff, 0xff, 0x01, 0x02, + 0x00, 0xfe, 0xfe, 0xff, 0x00, 0x00, 0xff, 0x00, 0x01, 0x00, 0xff, 0xff, 0xfd, 0xfd, 0xfe, 0x00, 0x02, 0x01, 0xff, 0x00, 0x00, 0xff, + 0x00, 0xff, 0xfe, 0xff, 0x00, 0x01, 0x01, 0x00, 0xff, 0xff, 0x00, 0xff, 0xfe, 0xfd, 0xfd, 0xff, 0x00, 0xff, 0xff, 0x01, 0x00, 0xfe, + 0xfe, 0x00, 0x00, 0xfe, 0x00, 0x01, 0x00, 0x00, 0x00, 0xff, 0xff, 0x01, 0x00, 0xfe, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xfe, + 0xfd, 0xfe, 0x00, 0xfe, 0xff, 0x01, 0x01, 0xff, 0xff, 0x00, 0xff, 0xfe, 0xff, 0x01, 0x01, 0x00, 0x01, 0x01, 0x00, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xfe, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0xff, + 0xff, 0xfe, 0xfe, 0x00, 0x00, 0xfe, 0xff, 0x00, 0x00, 0xff, 0xfc, 0xfe, 0x00, 0x01, 0xff, 0x00, 0x01, 0xff, 0xff, 0x00, 0x00, 0xfe, + 0xff, 0x01, 0x01, 0x00, 0x00, 0x01, 0xff, 0x00, 0x00, 0xfe, 0xfe, 0xff, 0xff, 0xff, 0xfe, 0xff, 0x00, 0xfe, 0x01, 0x02, 0x01, 0xfe, + 0xfe, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xfe, 0xfe, 0x01, 0x01, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, + 0x00, 0x00, 0x00, 0xff, 0xff, 0x01, 0x01, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x01, 0x02, 0xff, 0xfd, 0xff, 0xff, 0xff, 0xff, 0x01, + 0x01, 0x00, 0x01, 0xff, 0xfe, 0xff, 0xff, 0xff, 0x00, 0x01, 0x00, 0xff, 0x00, 0x00, 0xff, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xff, + 0x00, 0x00, 0xff, 0x00, 0xff, 0xfe, 0xfe, 0xff, 0x00, 0x00, 0x00, 0x00, 0x01, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xfe, 0xff, 0x00, 0x02, + 0x01, 0xfe, 0xfe, 0x01, 0x02, 0x00, 0xff, 0xff, 0xff, 0xff, 0x01, 0x01, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xfe, 0xff, 0x00, + 0x00, 0xff, 0x01, 0x00, 0xff, 0xfe, 0x00, 0xff, 0xfe, 0xff, 0x00, 0x01, 0x01, 0x00, 0x01, 0x01, 0xff, 0x00, 0x00, 0xff, 0xfe, 0xfe, + 0xff, 0x01, 0x01, 0x00, 0x00, 0x01, 0xff, 0xfd, 0xfe, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x01, 0x01, 0x00, 0xfd, 0xff, + 0x00, 0xff, 0xfe, 0x00, 0x01, 0xff, 0x00, 0x00, 0xff, 0xfe, 0xfd, 0xfd, 0xff, 0xff, 0xff, 0xfe, 0x00, 0x00, 0x00, 0xfe, 0xfe, 0xff, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xfe, 0xfe, 0xff, 0x01, 0x01, 0xff, 0x00, 0xff, + 0xfe, 0xff, 0x00, 0xff, 0x00, 0x02, 0x02, 0x01, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x01, + 0x01, 0x00, 0xff, 0xfe, 0xfe, 0xff, 0x01, 0x01, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x01, 0x00, 0xff, + 0xfe, 0xff, 0x00, 0x00, 0xfe, 0xfe, 0xfe, 0xff, 0xff, 0x00, 0x01, 0x00, 0xfe, 0xfe, 0xff, 0x00, 0xfe, 0xfe, 0xff, 0x00, 0xff, 0x00, + 0x01, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xfe, 0xff, 0x01, 0x01, 0x01, 0x00, 0xfe, 0xff, 0x00, 0xff, 0xfe, 0xff, 0x02, + 0x02, 0x00, 0xfe, 0xff, 0xff, 0xfe, 0xff, 0x00, 0x01, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x01, 0x01, 0x00, 0xff, 0xff, 0xff, + 0xfe, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x01, 0x01, 0x01, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x01, 0x02, + 0xff, 0xfe, 0xff, 0x00, 0xfd, 0xfe, 0x00, 0x01, 0xff, 0xfe, 0xfe, 0xff, 0xfd, 0xfe, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0x01, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xfd, 0xff, 0x01, 0x01, 0x01, 0x00, 0xff, 0xff, + 0xfe, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0xff, 0xff, 0x00, 0x00, 0xfd, 0xfe, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0xff, 0xfe, + 0x00, 0xfe, 0xfd, 0xff, 0x01, 0x01, 0x00, 0x00, 0x01, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x01, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x00, 0xfe, 0xfd, 0xff, 0x01, 0x01, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xfe, 0xff, 0x00, 0x01, 0x00, 0xff, 0x00, 0x00, 0x00, + 0xff, 0xfe, 0xfe, 0xff, 0xff, 0xff, 0x01, 0x02, 0x00, 0xfe, 0xff, 0xfe, 0xff, 0x01, 0x00, 0x00, 0x00, 0x01, 0xfe, 0xff, 0x00, 0x00, + 0xff, 0x01, 0x02, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, + 0x00, 0xff, 0xff, 0xff, 0x01, 0x01, 0xfe, 0xff, 0x00, 0xfe, 0xfd, 0xff, 0x01, 0x01, 0x00, 0x00, 0x00, 0xff, 0xff, 0xfe, 0xfe, 0x00, + 0x01, 0x01, 0x00, 0xfe, 0xfe, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0xff, 0x00, 0xfe, 0xfe, 0xff, + 0x01, 0x01, 0x01, 0x00, 0x00, 0xff, 0xfe, 0xff, 0x00, 0x00, 0xfe, 0xff, 0x00, 0x01, 0xff, 0x00, 0x01, 0x01, 0x00, 0x00, 0xff, 0xff, + 0xff, 0x01, 0x02, 0x01, 0x00, 0xff, 0xfe, 0x01, 0x00, 0xfe, 0xff, 0x01, 0x00, 0xfd, 0xfd, 0xff, 0x00, 0xfe, 0xfe, 0xff, 0xff, 0xfd, + 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x01, 0x00, 0xfe, 0xfd, 0xff, 0xff, 0xff, 0xfe, 0x00, 0x00, 0xfe, 0xfe, + 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x01, 0x00, 0xff, 0x00, 0x03, 0x02, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0x01, 0x00, 0xfe, 0x01, + 0x01, 0xff, 0xff, 0xfe, 0xfe, 0xff, 0x00, 0xff, 0x00, 0x01, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x01, 0x02, 0x00, + 0xff, 0x00, 0x00, 0x00, 0xff, 0xfe, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xfd, 0xfd, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, + 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xfe, 0x00, 0x01, 0xfe, 0xff, 0x01, 0x00, 0xfe, 0xfc, 0xfe, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, + 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x01, 0x01, 0x00, 0xff, 0x00, 0x01, 0x01, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x01, 0x00, 0xff, + 0x00, 0x00, 0xfe, 0xfe, 0xff, 0x02, 0x01, 0xff, 0xfe, 0x01, 0x01, 0x01, 0x01, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0x02, 0x01, + 0xff, 0xff, 0xfe, 0xfe, 0xff, 0x02, 0x00, 0xfe, 0xfe, 0xff, 0x00, 0xff, 0xfe, 0x00, 0x00, 0xfe, 0xfe, 0xff, 0x00, 0x00, 0x00, 0x00, + 0x01, 0x00, 0xfe, 0xfe, 0xff, 0xff, 0xfe, 0xfd, 0xfe, 0x01, 0x01, 0x00, 0xff, 0xfe, 0xfe, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x01, + 0x01, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0xff, 0x00, 0xff, 0xfe, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xfe, 0x00, 0x00, 0x00, + 0x00, 0x00, 0xff, 0xfe, 0xfd, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x01, 0xff, 0xff, 0x00, 0x01, 0xff, 0xfe, + 0xff, 0x00, 0xfe, 0xff, 0x01, 0x00, 0xff, 0xff, 0xff, 0xfe, 0xfe, 0xff, 0x00, 0x00, 0xfe, 0xfe, 0xff, 0x00, 0x01, 0x02, 0xff, 0xfe, + 0x01, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x02, 0x01, 0x01, 0x00, 0xfe, 0xfe, 0x00, 0x00, 0xff, 0x01, 0x02, 0x01, 0xfe, 0xff, 0xff, + 0xfe, 0xff, 0x00, 0x01, 0xff, 0xff, 0x00, 0x01, 0x01, 0x00, 0xff, 0x00, 0x00, 0xff, 0xfe, 0xff, 0x01, 0x00, 0xff, 0xff, 0x00, 0xff, + 0xfd, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xfe, 0xfe, 0x00, 0x00, 0xff, 0x00, 0x01, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, + 0xff, 0xff, 0xfe, 0xfe, 0x00, 0x01, 0x00, 0xfe, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x01, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, + 0xff, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xfe, 0xfe, 0x00, 0x00, 0xff, 0xff, + 0x00, 0x00, 0x00, 0x00, 0x02, 0x02, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x01, 0x01, 0x00, 0xff, 0xff, 0xff, 0xfe, 0xfe, 0xff, + 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x01, 0xff, 0xfd, 0xfd, 0xfe, 0xff, + 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xfd, 0xfd, 0xff, 0xff, 0x00, 0x01, 0x01, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xfe, 0xfe, 0x00, 0xff, 0xfe, 0xff, 0xff, 0xff, 0x00, 0x00, 0x01, 0x00, 0xff, 0x00, 0xff, 0xfe, 0xff, 0x02, + 0x00, 0x00, 0x01, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0x01, 0x00, 0xff, 0xff, + 0x02, 0x00, 0xfd, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xfe, 0x00, 0x01, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x01, 0x01, 0xff, 0xfd, 0xfe, 0xff, 0xfe, 0xff, 0x00, 0x00, 0xfe, 0xff, 0xff, 0xff, 0xfe, 0xfe, 0x00, 0x01, 0xff, 0xff, 0xff, 0x00, + 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x01, 0x00, 0xff, 0xff, 0xff, 0xfe, 0xfe, 0x00, 0x00, 0x02, 0x03, 0x00, + 0xff, 0xff, 0x01, 0x00, 0xff, 0xff, 0x00, 0x01, 0x01, 0x00, 0x01, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xfe, 0xff, 0x00, 0x00, + 0x01, 0x01, 0xff, 0xfe, 0xff, 0xff, 0x00, 0x00, 0x01, 0x01, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xfd, + 0xfe, 0x00, 0x00, 0xfe, 0xff, 0x00, 0xff, 0xfe, 0xff, 0x01, 0x01, 0x00, 0x00, 0x02, 0x00, 0xfe, 0xfe, 0x00, 0x00, 0x01, 0x00, 0x00, + 0xff, 0xfe, 0xff, 0x00, 0x00, 0xfe, 0xfc, 0xfe, 0x01, 0x01, 0xff, 0x00, 0x00, 0xfe, 0xff, 0x00, 0x01, 0xff, 0xff, 0x00, 0x00, 0x01, + 0x00, 0xff, 0x01, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x01, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xfe, 0xfe, 0xff, + 0x01, 0x01, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xfe, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfe, 0xfe, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x01, 0xff, 0xfd, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x01, + 0x00, 0xff, 0xff, 0xff, 0x00, 0x01, 0x00, 0xff, 0xff, 0x01, 0x00, 0xff, 0xff, 0x01, 0xff, 0xfe, 0x00, 0x00, 0xff, 0x00, 0x02, 0x01, + 0xff, 0xfe, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xfe, 0xfe, 0x01, 0x01, 0xff, 0xfe, 0xff, + 0x01, 0x00, 0xff, 0xff, 0xff, 0xfe, 0x00, 0x02, 0x01, 0xff, 0xff, 0x00, 0xff, 0xfe, 0xff, 0x00, 0xff, 0xfe, 0xff, 0x00, 0x00, 0xff, + 0xff, 0x01, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x01, 0x00, 0xff, 0xff, 0x01, 0x01, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0xff, 0xff, + 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0xff, 0xfe, 0xfe, 0xff, 0xff, 0x00, 0x01, 0x01, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, + 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xfe, 0xff, 0x00, 0xff, 0xff, 0xff, 0xfe, 0x00, 0x02, 0x01, 0xff, 0xff, 0xff, + 0x00, 0xff, 0x00, 0x00, 0x00, 0xfe, 0xff, 0x00, 0xff, 0xff, 0xfe, 0xfe, 0x00, 0x01, 0x00, 0xff, 0xff, 0x00, 0xff, 0xfe, 0xff, 0x00, + 0x00, 0xff, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xfe, 0xfe, 0x00, 0x00, + 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x01, 0x01, 0xff, 0xff, 0x00, 0xfe, 0xfe, + 0xff, 0x01, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xfe, 0xfe, 0xff, 0x01, 0x00, 0x00, 0x00, 0x01, 0xfe, 0xfd, 0xfe, 0xff, 0x00, 0x00, + 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0xfe, 0xfe, 0xff, + 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xfe, 0xff, 0x00, 0x01, 0x00, 0x01, 0x01, 0x00, 0x01, 0x00, 0xfe, 0xff, 0xff, 0x00, 0x00, + 0x00, 0x00, 0xfe, 0xfe, 0x00, 0x00, 0x00, 0x01, 0x00, 0xff, 0xff, 0x01, 0x01, 0x00, 0xfe, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x01, + 0x00, 0x00, 0xff, 0xfe, 0xff, 0x00, 0xff, 0xfe, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x01, + 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xff, 0x00, 0x00, 0xff, 0xfe, 0xfe, 0xff, 0xff, 0xff, 0x00, 0x00, 0x01, 0x01, + 0x00, 0x00, 0xff, 0xfd, 0x01, 0x01, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x01, + 0x02, 0x01, 0x00, 0xff, 0xff, 0x00, 0x01, 0x00, 0x01, 0x01, 0xff, 0xff, 0x00, 0x00, 0xfe, 0xff, 0x01, 0x01, 0xff, 0xfe, 0xff, 0x00, + 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x01, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, + 0xfe, 0xff, 0x00, 0x00, 0xfe, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0xff, 0xfe, + 0xfe, 0xff, 0x00, 0x01, 0xff, 0xfe, 0x01, 0x00, 0xff, 0xfe, 0xff, 0xff, 0xfe, 0xff, 0x00, 0x00, 0xff, 0x00, 0x01, 0x00, 0xff, 0xfe, + 0x00, 0x00, 0xff, 0xff, 0x00, 0x01, 0x02, 0x01, 0x00, 0xfe, 0xfe, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x01, 0x01, 0xff, 0xfe, + 0xff, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x01, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0x01, 0xff, 0xff, 0x00, 0x00, 0xff, + 0xff, 0xff, 0x00, 0x00, 0x01, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x01, 0x01, + 0xff, 0xfe, 0xff, 0xff, 0x00, 0x00, 0x01, 0x00, 0xfe, 0xfe, 0xff, 0xfe, 0xfe, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x00, 0x01, 0x00, 0xff, 0xfe, 0x01, 0x00, 0xff, 0x01, 0x01, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x01, 0x01, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, + 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xfe, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0xff, 0xfe, 0xff, + 0x00, 0x00, 0xff, 0x00, 0x00, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x01, 0x00, 0xff, 0xfe, + 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xfe, 0xfd, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x01, 0x01, 0x00, 0xfd, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xfe, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x00, 0x03, 0x01, 0xff, 0xfe, 0xfe, 0xfe, 0xff, 0x00, 0xff, 0xff, 0x00, 0x01, 0x00, 0xff, 0xff, 0xff, 0xff, + 0x01, 0x01, 0x00, 0xfe, 0xfe, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xfd, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, + 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0xfe, 0xfe, 0x00, 0x00, 0xff, 0xff, + 0x00, 0x00, 0xff, 0xff, 0x00, 0xfe, 0x00, 0x01, 0xff, 0xff, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0xff, 0xfe, 0xfe, 0x00, 0xfe, 0xfe, + 0x01, 0x00, 0x00, 0xff, 0xfe, 0xff, 0xff, 0x00, 0x01, 0x00, 0xff, 0x00, 0x01, 0x00, 0xff, 0x01, 0x01, 0x00, 0xff, 0x00, 0xff, 0xff, + 0x00, 0x01, 0x00, 0x00, 0xfe, 0xfd, 0xfd, 0xfe, 0xff, 0x00, 0x00, 0x00, 0xff, 0x01, 0x01, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, + 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xfe, 0xfe, 0xff, 0x00, 0x00, 0x00, 0xfe, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x01, 0xff, 0xfe, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0xff, 0x00, 0x02, 0x01, 0xfe, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, + 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xfe, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, + 0x00, 0xff, 0xfe, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x01, 0xff, 0xfe, 0xff, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0xff, + 0xff, 0xfe, 0xfe, 0xff, 0xff, 0x00, 0x01, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xfe, 0xff, 0x00, 0xff, 0x00, 0x01, 0x01, + 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x02, 0x00, 0xff, 0xff, 0xff, 0x00, 0x01, 0x00, 0xff, 0xff, 0x00, 0x01, 0x01, 0x00, 0xff, + 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x01, 0xff, 0xfe, 0xff, 0x00, 0x00, 0x00, 0xff, 0xfe, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xfe, 0x00, 0x00, 0xfe, 0xfd, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x01, 0x00, 0xff, 0x00, 0x01, + 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x01, 0x00, 0xff, 0xfe, 0x00, 0xff, 0xfe, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xfe, + 0xff, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xfe, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, + 0xff, 0x00, 0xff, 0xfe, 0xff, 0x01, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xfe, 0xff, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0xfe, 0xfd, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x01, 0x00, 0xff, 0xff, 0x00, + 0xff, 0xfe, 0xfe, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x01, 0x01, 0x00, 0x00, 0xfe, + 0xfe, 0xff, 0x01, 0xff, 0xff, 0x01, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xfe, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x00, 0x01, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x01, 0x00, 0x00, 0x00, 0x00, + 0x00, 0xff, 0xff, 0x00, 0x01, 0x00, 0x01, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0xfe, 0xfe, 0xff, 0xff, 0x01, + 0x01, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x01, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x01, 0x00, 0xff, 0xff, 0xff, 0x00, + 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xfe, 0xfe, 0xff, 0x00, 0x00, 0xff, 0xfe, 0xff, 0x00, 0x00, 0xff, 0xfe, 0xff, 0xff, + 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x01, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x00, 0x01, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0xff, 0x00, 0xff, 0xff, + 0x00, 0x02, 0x00, 0xff, 0xfe, 0xff, 0xff, 0xff, 0x01, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xfe, 0xff, 0x00, 0xff, 0x00, 0x00, + 0x00, 0xff, 0xff, 0xff, 0xfe, 0xff, 0xff, 0xff, 0x00, 0xff, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, + 0x00, 0x00, 0x00, 0x00, 0xff, 0xfe, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xfd, 0xfd, 0xfe, 0xff, 0x00, 0x01, 0x01, 0x00, + 0xff, 0xfe, 0x00, 0x01, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x01, 0x01, 0x00, 0x01, 0x00, 0xfe, 0xfe, 0xff, 0x00, 0x00, 0x00, 0xff, + 0xfe, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x01, 0x01, 0x00, + 0xff, 0xff, 0xff, 0xfe, 0xfd, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, + 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xfe, 0xff, 0x01, 0x00, 0xfe, 0xff, 0x00, 0x00, 0xfe, 0xfe, 0xff, 0x00, 0x00, 0x00, 0x01, + 0x02, 0xff, 0xfe, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, + 0x01, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0xfe, 0xff, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, + 0x01, 0x00, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x01, + 0xff, 0xff, 0x00, 0x01, 0xff, 0xff, 0x00, 0x00, 0xfe, 0xfe, 0xff, 0xfe, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xfe, 0xfe, 0xfe, 0xff, + 0x00, 0x01, 0x01, 0xff, 0x00, 0x00, 0x00, 0x01, 0x00, 0xff, 0xff, 0xfe, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xfe, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0xff, 0xfe, 0xff, 0xff, 0x01, 0x01, 0x00, 0x00, 0x00, 0xff, 0x00, 0xfe, 0xfe, 0x00, + 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xfe, 0x01, 0x01, 0x00, 0xff, 0x00, 0x00, 0xff, 0x01, 0x00, 0xff, 0x00, + 0xff, 0xff, 0xff, 0xff, 0x00, 0x01, 0x00, 0xfe, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x01, 0x00, 0xff, 0xff, 0x00, + 0xff, 0xff, 0x00, 0x01, 0xff, 0xfe, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x01, 0x00, 0xff, 0xff, + 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xfe, + 0xfe, 0x00, 0x01, 0x01, 0x01, 0x00, 0xfe, 0xfe, 0x00, 0x00, 0xff, 0xfe, 0xff, 0x01, 0x00, 0xff, 0x00, 0x00, 0xfe, 0xfe, 0x00, 0x00, + 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xfe, 0xff, 0xff, + 0xff, 0xff, 0x00, 0x01, 0x01, 0xff, 0xfe, 0xff, 0x00, 0xff, 0xff, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xfe, 0xff, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0x00, 0x01, 0x00, 0xff, 0x00, 0x01, 0xff, 0x00, 0x01, 0x00, 0xfe, 0xfe, 0xff, 0x00, 0xff, + 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xfe, 0xfe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xfe, 0xfe, 0xff, 0xff, 0x00, + 0x00, 0x00, 0xfe, 0xff, 0xff, 0x00, 0x00, 0xff, 0xfd, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x01, + 0x01, 0x00, 0x00, 0xff, 0xfe, 0xff, 0x00, 0xff, 0xfe, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x00, 0x01, 0x01, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xfd, 0xfe, 0x00, 0x00, 0x00, 0x01, 0x00, + 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x01, 0xff, 0xff, 0xff, 0x00, 0xfe, 0xfe, 0xff, 0xff, 0xff, + 0x00, 0x01, 0x00, 0xfe, 0xfd, 0xfe, 0xff, 0x01, 0x02, 0x00, 0x00, 0x01, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x01, 0x01, 0xff, 0xfe, + 0xff, 0x01, 0xfe, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x01, 0x00, + 0x00, 0x00, 0x00, 0xff, 0xff, 0xfe, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, + 0x01, 0x00, 0xff, 0xff, 0xfe, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xfe, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, + 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xfe, 0xff, 0xff, 0xff, 0x01, 0x01, 0x00, 0xff, 0x01, 0x00, 0xff, 0x00, 0x01, 0x00, + 0xfe, 0x00, 0x00, 0xff, 0xff, 0x00, 0x01, 0x01, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x00, 0x01, 0x01, 0x00, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xff, 0xff, 0xff, 0xff, 0x00, 0x01, 0x01, 0x00, 0x01, 0xff, 0xfe, 0xff, 0xff, 0xff, 0xff, 0x01, 0xff, 0xff, 0x00, 0xff, 0xfe, 0xff, + 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x01, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, + 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x01, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, + 0x00, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xff, 0x00, 0xfe, 0xff, 0x01, 0x01, 0xff, 0xfe, 0xff, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0x00, + 0x00, 0x01, 0x01, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, + 0xff, 0x01, 0x02, 0x01, 0xff, 0xfe, 0xff, 0xff, 0xff, 0x00, 0x01, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, + 0x01, 0x01, 0x00, 0x01, 0x00, 0xff, 0xfe, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, + 0xfe, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0xff, 0xfe, 0xff, 0x00, 0xff, 0x00, 0x02, 0x00, 0xff, 0xfe, 0xff, 0x01, 0x00, 0xff, 0xff, + 0xfe, 0xff, 0x00, 0x01, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xfe, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0xff, 0xfe, 0xff, 0x00, 0xfe, + 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xfe, 0xff, + 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0xfe, 0xfe, 0xff, 0x00, 0xff, 0x00, 0x00, 0xfe, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0xff, + 0xff, 0x01, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xfe, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, + 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xfe, 0xff, 0x00, 0xfe, 0xfd, 0xff, 0x00, + 0x00, 0xff, 0x00, 0xff, 0xfe, 0xff, 0x01, 0x00, 0x00, 0x01, 0x01, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, + 0x00, 0x01, 0xfe, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x01, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x01, 0x00, 0x01, + 0x00, 0xfe, 0xff, 0xff, 0xfe, 0xff, 0x00, 0x01, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, + 0x00, 0x00, 0xfe, 0xff, 0x01, 0x01, 0x00, 0x00, 0xff, 0xfe, 0x00, 0x00, 0xff, 0xff, 0xfe, 0xfe, 0x00, 0x01, 0x01, 0x00, 0x00, 0xff, + 0xfe, 0x00, 0xff, 0xfe, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x02, 0x01, 0x00, 0x00, 0x00, 0xff, + 0xff, 0x00, 0xff, 0x00, 0x01, 0x01, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xfe, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xff, 0xfe, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x01, 0xfe, 0xff, + 0x00, 0x00, 0xff, 0x00, 0x01, 0x00, 0x00, 0x00, 0xff, 0xff, 0xfe, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfe, 0xff, 0x01, 0x01, 0xff, 0xff, 0xff, 0x00, 0x01, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, + 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x01, 0x01, 0x00, 0x00, 0x01, 0x00, 0xfe, 0x00, 0xff, 0x00, + 0x00, 0xff, 0x00, 0x01, 0x00, 0xfe, 0xfe, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, + 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0xfe, 0xff, 0xff, 0xfe, 0xff, 0x01, 0x01, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xff, 0xfe, 0xfe, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xfe, 0xfe, 0xff, 0x00, 0x00, + 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x01, 0x01, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, + 0x01, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0x00, 0x01, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, + 0x01, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xfe, + 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xfe, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xfe, 0xfe, 0xfe, 0xff, 0x00, 0x00, 0xff, 0x00, + 0x00, 0x00, 0xff, 0xfd, 0xfe, 0x00, 0x00, 0x00, 0x01, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x01, 0x01, 0xff, 0xfe, 0x00, 0x01, + 0x00, 0x00, 0x00, 0x00, 0xfe, 0xfe, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x01, 0xff, 0xff, 0x00, + 0x01, 0x00, 0xff, 0xff, 0xfe, 0xfe, 0xfe, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xfe, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xfe, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xfe, 0xff, 0x00, 0xff, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xfe, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, + 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0xff, 0xfd, 0xfe, 0x00, 0xfe, + 0xff, 0x00, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, + 0x00, 0xfe, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xfe, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xfe, 0xff, 0x00, 0xff, 0x00, 0x00, 0xff, 0xfe, 0xff, 0xff, 0xff, 0xff, 0x00, 0x01, 0x00, 0xff, + 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xfe, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xfe, 0xfe, 0xfe, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xfe, 0xfe, 0x00, 0x01, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, + 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x01, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x00, 0x01, 0xff, 0xff, 0x00, 0xfe, 0xfe, 0x00, 0x00, 0x01, 0x01, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, + 0x01, 0x00, 0xff, 0xff, 0x00, 0xfe, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x00, 0xff, 0x00, 0x00, + 0xff, 0xff, 0x01, 0x01, 0xff, 0x00, 0x00, 0xff, 0xfe, 0xff, 0xff, 0xff, 0xfe, 0x01, 0x01, 0x00, 0xfe, 0xfe, 0xff, 0xff, 0xff, 0xff, + 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xfe, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xfe, + 0xfe, 0x00, 0x01, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x01, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x01, 0x01, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x01, 0x01, 0xff, 0xff, 0x00, + 0x00, 0xff, 0x00, 0x00, 0xff, 0xfe, 0xff, 0x01, 0x00, 0xff, 0x00, 0x00, 0xff, 0xfe, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, + 0x00, 0x00, 0xfe, 0xfe, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x01, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, + 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, + 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xfe, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xfe, 0xff, 0xff, 0x00, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x01, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x01, 0x00, + 0xff, 0xff, 0x00, 0xff, 0xfe, 0xff, 0x01, 0x01, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xfe, 0xff, 0x00, 0x00, 0xff, 0xff, + 0xff, 0xff, 0xfe, 0xfe, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xfe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, + 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xfe, 0xff, 0x00, 0x01, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, + 0x00, 0x01, 0x01, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0xfe, 0xfe, 0x00, + 0x01, 0x00, 0x00, 0x01, 0x00, 0xff, 0xff, 0x00, 0xff, 0xfe, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xfe, 0xfe, 0xfe, 0xff, 0xff, 0xff, + 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x01, 0xff, 0x00, 0x00, 0xff, 0xfe, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xfe, 0xff, + 0xff, 0x00, 0x02, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, + 0x00, 0x00, 0xfe, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, + 0x00, 0x01, 0xff, 0x00, 0x00, 0xff, 0xff, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x01, + 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xfe, 0xff, 0xff, 0xfe, 0xff, 0x00, 0x01, 0x01, + 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xfe, 0xff, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, + 0xff, 0xfe, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xfe, 0x01, 0x00, + 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, + 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0x01, 0xff, 0x00, 0x02, 0x00, 0xff, 0xff, 0xff, 0xff, 0xfe, + 0xfe, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x01, 0x01, 0x00, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x01, 0x00, 0xff, 0xff, 0x00, 0xff, + 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x01, 0x00, 0xff, + 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0xff, 0xfe, 0xfe, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, + 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x01, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x01, 0xfe, 0xfe, 0xff, 0x00, 0xff, 0xff, + 0xff, 0x00, 0xff, 0xfe, 0xff, 0xff, 0xff, 0x00, 0x01, 0x01, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x01, 0x01, 0xff, 0xff, + 0xff, 0x00, 0xff, 0x00, 0x01, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, + 0xff, 0xfe, 0xff, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xfe, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, + 0xfe, 0xfe, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x01, 0x00, 0x00, 0x00, 0xff, 0xff, + 0x00, 0x00, 0xff, 0xff, 0x00, 0x01, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xfe, 0xff, + 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, + 0x00, 0xff, 0xff, 0x00, 0xff, 0x00, 0x01, 0x00, 0xfe, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0xfe, 0xfe, 0xff, 0xfe, 0xfe, + 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, + 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xfe, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xfe, 0xff, 0x00, 0x00, 0xff, 0x00, 0x01, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x01, + 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, + 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xfe, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xfe, 0xfd, 0xff, 0x00, 0x00, 0xff, + 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x01, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x01, 0x00, 0x00, + 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xfe, 0xff, 0x01, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xfe, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, + 0xff, 0xff, 0xfe, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x01, 0xff, 0xfe, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, + 0xff, 0xff, 0xfe, 0xff, 0xff, 0xfe, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x01, 0x01, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, + 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xfe, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, + 0xff, 0x01, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x01, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xff, + 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, + 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0x00, 0x01, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xfe, + 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x01, 0x00, 0x00, 0xff, 0xfe, 0x00, 0x00, 0x00, 0xff, 0xfe, 0xff, + 0x00, 0xff, 0x00, 0x01, 0x00, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, + 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, + 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xfe, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, + 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xfe, 0xfe, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xfe, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, + 0xff, 0xfe, 0xff, 0x01, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, + 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, + 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, + 0xff, 0x00, 0x00, 0xfe, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xfe, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, + 0x00, 0x00, 0xff, 0x00, 0xff, 0xfe, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xfe, 0xff, 0x00, 0xff, 0xfe, + 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, + 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, + 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x01, 0xff, 0xff, 0x00, 0x00, 0xff, 0xfe, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, + 0xfe, 0xff, 0x00, 0xfe, 0xfe, 0x00, 0x01, 0x01, 0x01, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0xff, 0x00, 0x00, 0xff, + 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x01, 0x01, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xfe, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, + 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xfe, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x00, 0x01, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x00, 0x01, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x01, 0x00, 0xff, 0xff, 0x00, 0xff, + 0xff, 0x00, 0x00, 0xfe, 0xfe, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x01, 0xff, 0xff, 0xff, 0x00, 0xff, + 0xff, 0xff, 0x00, 0xff, 0x00, 0x01, 0x00, 0xfe, 0xfe, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, + 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x01, 0x00, 0xff, 0x00, 0x00, 0xfe, 0xff, + 0x00, 0x00, 0xff, 0xff, 0x00, 0x01, 0xff, 0xfe, 0xff, 0xff, 0xff, 0x00, 0x01, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, + 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xfe, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, + 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, + 0xfe, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x01, 0x00, 0x00, 0xff, 0xff, 0xff, 0xfe, 0xfe, + 0x00, 0x00, 0x00, 0x00, 0xff, 0xfe, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xfe, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, + 0x00, 0x00, 0x00, 0x01, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, + 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xfe, 0xff, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, + 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xfe, 0xfe, 0xff, 0x00, 0xff, 0x00, 0x00, 0x01, 0x00, 0xff, 0xff, + 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0xff, 0xfe, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, + 0xfe, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x01, 0x00, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x01, 0x01, 0x00, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x01, 0xff, 0xff, 0x00, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xfe, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, + 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, + 0xff, 0x00, 0x00, 0x01, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, + 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xfe, 0x00, 0x00, 0x00, 0x01, 0xff, 0xfe, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x01, + 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x01, 0x01, 0xff, 0xff, 0xff, 0xfe, 0xff, 0x00, 0x00, 0xff, 0x00, + 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x01, 0x00, 0xff, 0xff, 0x00, 0xff, 0xfe, 0xff, 0x00, 0x00, 0xff, 0xff, + 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, + 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, + 0x00, 0xff, 0x00, 0x00, 0xff, 0xfe, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x01, 0x01, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, + 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, + 0x00, 0x00, 0x00, 0xff, 0xfe, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, + 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, + 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, + 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, + 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, + 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xfe, 0x00, + 0xff, 0xff, 0xff, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, + 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x01, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, + 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x01, 0x00, 0xff, 0xff, + 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, + 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xfd, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, + 0xff, 0x00, 0x01, 0x00, 0xff, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, + 0xff, 0xff, 0x01, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, + 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0x00, 0x01, 0x00, 0x00, 0xff, 0xfe, 0xff, 0xff, 0xff, 0x00, + 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x00, 0x00, 0xff, 0xfe, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xfe, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, + 0x00, 0x00, 0x00, 0x00, 0xff, 0xfe, 0xfe, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, + 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x01, 0x00, 0xff, + 0xff, 0x00, 0xff, 0xfe, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xfe, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, + 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, + 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, + 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x01, 0x00, 0xff, 0xff, 0xff, 0x00, + 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, + 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xfe, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, + 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xfe, 0xff, 0x00, 0x00, 0x00, 0x00, + 0xff, 0xff, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xfe, + 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, + 0xff, 0xff, 0x00, 0xff, 0xfe, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xfe, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, + 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x01, + 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, + 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, + 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, + 0xff, 0x00, 0xff, 0xff, 0x00, 0x01, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xfe, 0xff, + 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x01, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, + 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, + 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xfe, 0xfe, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xfe, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, + 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x01, 0x00, 0xfe, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, + 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, + 0x00, 0x00, 0x00, 0x01, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, + 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, + 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xfe, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, + 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, + 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x01, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, + 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xfe, 0xfe, 0x00, 0xff, 0xff, 0x00, + 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xfe, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, + 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, + 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xfe, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, + 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xfe, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, + 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x01, 0x01, 0xff, + 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0x01, 0x00, 0x00, + 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, + 0xff, 0xfe, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x01, 0x00, + 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xfe, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, + 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x01, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, + 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, + 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, + 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, + 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x01, + 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x01, 0x00, 0xff, 0x00, 0x00, 0xff, 0xfe, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, + 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xfe, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, + 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, + 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, + 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, + 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, + 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x01, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, + 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, + 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, + 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xfe, 0x00, + 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, + 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, + 0x00, 0x01, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, + 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, + 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, + 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, + 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x01, 0x01, + 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, + 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, + 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, + 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, + 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, + 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x01, 0x00, 0xff, 0x00, + 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, + 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, + 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, + 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x00, 0x01, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xfe, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, + 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, + 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x01, 0x00, 0x00, + 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, + 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, + 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, + 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, + 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, + 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xfe, 0xff, 0x00, 0x00, + 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, + 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xfe, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, + 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, + 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x01, + 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, + 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, + 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xfe, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, + 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, + 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, + 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, + 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, + 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, + 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, + 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, + 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, + 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, + 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, + 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, + 0xff, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, + 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, + 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, + 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, + 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, + 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, + 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x01, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, + 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, + 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, + 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, + 0xff, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, + 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, + 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, + 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, + 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, + 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, + 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, + 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, + 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, + 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, + 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, + 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, + 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, + 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, + 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, + 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, + 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, + 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, + 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, + 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, + 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, + 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, + 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, + 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, + 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, + 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, + 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, + 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, + 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, + 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, + 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, + 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, + 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, + 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, + 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, + 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, + 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, + 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, + 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, + 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, + 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, + 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, + 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, + 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, + 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, + 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, + 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, + 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, + 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, + 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xff, 0x00, 0x00, + 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, + 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, + 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, + 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, + 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, + 0x00, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, + 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, + 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, + 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, + 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, + 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, + 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, + 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, + 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, + 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, + 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, + 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, + 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, + 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, + 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, + 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, + 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, + 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, + 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, + 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, + 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, + 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, + 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, + 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, + 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, + 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, + 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, + 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, + 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, + 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, + 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, + 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, + 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, + 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, + 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, + 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, + 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, + 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, + 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, + 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, + 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, + 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, + 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, + 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, + 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, + 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, + 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, + 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, + 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, + 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, + 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, + 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, + 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, + 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, + 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, + 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, + 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, + 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, + 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, + 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, + 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, + 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, + 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, + 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, + 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, + 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, + 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, + 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, + 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, + 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, + 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, + 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, + 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, + 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, + 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, + 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, + 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, + 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, + 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, + 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, + 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, + 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, + 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, + 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, + 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, + 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, + 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, + 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, + 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, + 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, + 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, + 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, + 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, + 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, + 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, + 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, + 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, + 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, + 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, + 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, + 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, + 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, + 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, + 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, + 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, + 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, + 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, + 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, + 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, + 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, + 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, + 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, + 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, + 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, + 0xff, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, + 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, + 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, + 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, + 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, + 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, + 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, + 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, + 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, + 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0x00, + 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, + 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, + 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, + 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, + 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, + 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, + 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, + 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, + 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, + 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, + 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, + 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, + 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, + 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, + 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, + 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, + 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, + 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, + 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, + 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0x00, + 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, + 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, + 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0x00, + 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, + 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, + 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, + 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, + 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, + 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, + 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, + 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, + 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, + 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, + 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, + 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, + 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, + 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, + 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, + 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, + 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, + 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, + 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, + 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, + 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, + 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, + 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, + 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, + 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, + 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, + 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, + 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0x00, + 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, + 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, + 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, + 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, + 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, + 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, + 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, + 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, + 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, + 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, + 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, + 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, + 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, + 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, + 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, + 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, + 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, + 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, + 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, + 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, + 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, + 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, + 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, + 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, + 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, + 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, + 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, + 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, + 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, + 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, + 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, + 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, + 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, + 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, + 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, + 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, + 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, + 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, + 0x00, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, + 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, + 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, + 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, + 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, + 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, + 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, + 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, + 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, + 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, + 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, + 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, + 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, + 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, + 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, + 0xff, 0x00, 0x00, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, + 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, + 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, + 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, + 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, + 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, + 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, + 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, + 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, + 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, + 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, + 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, + 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, + 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, + 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, + 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, + 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0xff, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, + 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, + 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, + 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, + 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, + 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, + 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, + 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, + 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, + 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, + 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, + 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, + 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, + 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, + 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, + 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, + 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, + 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, + 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, + 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, + 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, + 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, + 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, + 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, + 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0x00, + 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, + 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, + 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, + 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, + 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, + 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, + 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, + 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, + 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, + 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, + 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, + 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, + 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, + 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, + 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, + 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, + 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, + 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, + 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, + 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, + 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, + 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, + 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, + 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, + 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0xff, 0x00, 0x00, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, + 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, + 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, + 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, + 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, + 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, + 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, + 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, + 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, + 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, + 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, + 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, + 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, + 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, + 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, + 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, + 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, + 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, + 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, + 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, + 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, + 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, + 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, + 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, + 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, + 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, + 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, + 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, + 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, + 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, + 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, + 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, + 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, + 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, + 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, + 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, + 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, + 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, + 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, + 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, + 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, + 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, + 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, + 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, + 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, + 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, + 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, + 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, + 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, + 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, + 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, + 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, + 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, + 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, + 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, + 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, + 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, + 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, + 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, + 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, + 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, + 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, + 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, + 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, + 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, + 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, + 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, + 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, + 0xff, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, + 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, + 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, + 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0x00, 0x00, + 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, + 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, + 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, + 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, + 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, + 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, + 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, + 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, + 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, + 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, + 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, + 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, + 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, + 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, + 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, + 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, + 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, + 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, + 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, + 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, + 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, + 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, + 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, + 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, + 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, + 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, + 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, + 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, + 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, + 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, + 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, + 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, + 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, + 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, + 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, + 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, + 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, + 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, + 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, + 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, + 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, + 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, + 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, + 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, + 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, + 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, + 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, + 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, + 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, + 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, + 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, + 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, + 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, + 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, + 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, + 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, + 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, + 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, + 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, + 0x00, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, + 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, + 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, + 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, + 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, + 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, + 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, + 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, + 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, + 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, + 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, + 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, + 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, + 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, + 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, + 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, + 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, + 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, + 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, + 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, + 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, + 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, + 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, + 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, + 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, + 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, + 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, + 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, + 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, + 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0x00, + 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, + 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, + 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, + 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, + 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, + 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, + 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, + 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, + 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, + 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, + 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, + 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, + 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, + 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, + 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, + 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, + 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, + 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, + 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, + 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, + 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, + 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, + 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, + 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, + 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, + 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, + 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, + 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, + 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, + 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, + 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, + 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, + 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, + 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, + 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, + 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, + 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, + 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, + 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, + 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, + 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, + 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, + 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, + 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, + 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, + 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, + 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, + 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, + 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, + 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, + 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, + 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, + 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, + 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, + 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, + 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, + 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, + 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0xff, + 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, + 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, + 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, + 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, + 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, + 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, + 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, + 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, + 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, + 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, + 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, + 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, + 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, + 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, + 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, + 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, + 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, + 0xff, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, + 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, + 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, + 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, + 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, + 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, + 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, + 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, + 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, + 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, + 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, + 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, + 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, + 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, + 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0x00, + 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, + 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, + 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, + 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, + 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, + 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, + 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, + 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, + 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, + 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, + 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, + 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, + 0x00, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, + 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, + 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, + 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, + 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, + 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, + 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, + 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, + 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, + 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, + 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, + 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, + 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, + 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, + 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, + 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, + 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, + 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, + 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, + 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, + 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, + 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, + 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, + 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, + 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, + 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, + 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, + 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, + 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, + 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, + 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, + 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, + 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, + 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, + 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, + 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, + 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, + 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, + 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, + 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, + 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, + 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, + 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, + 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, + 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, + 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, + 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0xff, 0x00, 0x00, + 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, + 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, + 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, + 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, + 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0xff, 0x00, 0x00, + 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, + 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, + 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, + 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, + 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, + 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, + 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, + 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, + 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, + 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, + 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, + 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, + 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, + 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, + 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, + 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, + 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, + 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, + 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, + 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, + 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, + 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, + 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, + 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, + 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, + 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, + 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, + 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, + 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, + 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, + 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, + 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, + 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, + 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, + 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, + 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, + 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, + 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, + 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, + 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, + 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, + 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, + 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x00, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, + 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, + 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, + 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, + 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, + 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, + 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, + 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, + 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, + 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, + 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, + 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0x00, + 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xff, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, + 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, + 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, + 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, + 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, + 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, + 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, + 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, + 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, + 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, + 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, + 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, + 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, + 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, + 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, + 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, + 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, + 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, + 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, + 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, + 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, + 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, + 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, + 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, + 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, + 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, + 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, + 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, + 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, + 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, + 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, + 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, + 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, + 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, + 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, + 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, + 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0xff, + 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, + 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, + 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, + 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, + 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, + 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, + 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, + 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, + 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, + 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, + 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, + 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, + 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, + 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, + 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, + 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0x00, + 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, + 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, + 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, + 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, + 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, + 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, + 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, + 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, + 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, + 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, + 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, + 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, + 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, + 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, + 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, + 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, + 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, + 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, + 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, + 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, + 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, + 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, + 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, + 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, + 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, + 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, + 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, + 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, + 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, + 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, + 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, + 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, + 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, + 0xff, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, + 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, + 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, + 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, + 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, + 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, + 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, + 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, + 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, + 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, + 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, + 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, + 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, + 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, + 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, + 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, + 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, + 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, + 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, + 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, + 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, + 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, + 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, + 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, + 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, + 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, + 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, + 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, + 0xff, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0x00, + 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, + 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, + 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, + 0x00, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, + 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, + 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, + 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, + 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, + 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, + 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, + 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, + 0x00, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, + 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, + 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, + 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, + 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, + 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0xff, 0x00, + 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, + 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, + 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, + 0x00, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, + 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, + 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, + 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, + 0x00, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, + 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, + 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, + 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, + 0x00, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, + 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, + 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, + 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, + 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, + 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, + 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, + 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, + 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, + 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, + 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, + 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, + 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, + 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, + 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xff, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, + 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, + 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, + 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, + 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, + 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, + 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, + 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, + 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, + 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, + 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, +}; diff --git a/thirdparty/opnmidi/chips/pmdwin_opna.cpp b/thirdparty/opnmidi/chips/pmdwin_opna.cpp new file mode 100644 index 0000000..977386e --- /dev/null +++ b/thirdparty/opnmidi/chips/pmdwin_opna.cpp @@ -0,0 +1,84 @@ +/* + * Interfaces over Yamaha OPN2 (YM2612) chip emulators + * + * Copyright (C) 2020 Vitaly Novichkov (Wohlstand) + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#include "pmdwin_opna.h" +#include "pmdwin/opna.h" +#include +#include + +PMDWinOPNA::PMDWinOPNA(OPNFamily f) + : OPNChipBaseBufferedT(f) +{ + OPNA *opn = new OPNA; + chip = reinterpret_cast(opn); + setRate(m_rate, m_clock); +} + +PMDWinOPNA::~PMDWinOPNA() +{ + OPNA *opn = reinterpret_cast(chip); + delete opn; +} + +void PMDWinOPNA::setRate(uint32_t rate, uint32_t clock) +{ + OPNA *opn = reinterpret_cast(chip); + OPNChipBaseBufferedT::setRate(rate, clock); + + uint32_t chipRate = isRunningAtPcmRate() ? rate : nativeRate(); + std::memset(chip, 0, sizeof(*opn)); + OPNAInit(opn, m_clock, chipRate, 0); + OPNASetReg(opn, 0x29, 0x9f); +} + +void PMDWinOPNA::reset() +{ + OPNChipBaseBufferedT::reset(); + OPNA *opn = reinterpret_cast(chip); + OPNAReset(opn); + OPNASetReg(opn, 0x29, 0x9f); +} + +void PMDWinOPNA::writeReg(uint32_t port, uint16_t addr, uint8_t data) +{ + OPNA *opn = reinterpret_cast(chip); + OPNASetReg(opn, (port << 8) | addr, data); +} + +void PMDWinOPNA::writePan(uint16_t chan, uint8_t data) +{ + OPNA *opn = reinterpret_cast(chip); + OPNASetPan(opn, chan, data); +} + +void PMDWinOPNA::nativeGenerateN(int16_t *output, size_t frames) +{ + // be cautious to avoid overflowing stack buffer on PMDWin side! + // (on OPNChipBaseBuffered it's fine) + assert(frames < 16384 / 2); + + OPNA *opn = reinterpret_cast(chip); + OPNAMix(opn, output, static_cast(frames)); +} + +const char *PMDWinOPNA::emulatorName() +{ + return "PMDWin OPNA"; // git 2018-05-11 rev 255ef52 +} diff --git a/thirdparty/opnmidi/chips/pmdwin_opna.h b/thirdparty/opnmidi/chips/pmdwin_opna.h new file mode 100644 index 0000000..d47327b --- /dev/null +++ b/thirdparty/opnmidi/chips/pmdwin_opna.h @@ -0,0 +1,45 @@ +/* + * Interfaces over Yamaha OPN2 (YM2612) chip emulators + * + * Copyright (C) 2020 Vitaly Novichkov (Wohlstand) + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#ifndef PMDWIN_OPNA_H +#define PMDWIN_OPNA_H + +#include "opn_chip_base.h" + +class PMDWinOPNA final : public OPNChipBaseBufferedT +{ + struct ChipType; + ChipType *chip; +public: + explicit PMDWinOPNA(OPNFamily f); + ~PMDWinOPNA() override; + + bool canRunAtPcmRate() const override { return true; } + void setRate(uint32_t rate, uint32_t clock) override; + void reset() override; + void writeReg(uint32_t port, uint16_t addr, uint8_t data) override; + void writePan(uint16_t chan, uint8_t data) override; + void nativePreGenerate() override {} + void nativePostGenerate() override {} + void nativeGenerateN(int16_t *output, size_t frames) override; + const char *emulatorName() override; +}; + +#endif diff --git a/thirdparty/opnmidi/file_reader.hpp b/thirdparty/opnmidi/file_reader.hpp index 7d13262..f07de7f 100644 --- a/thirdparty/opnmidi/file_reader.hpp +++ b/thirdparty/opnmidi/file_reader.hpp @@ -1,7 +1,7 @@ /* * FileAndMemoryReader - a tiny helper to utify file reading from a disk and memory block * - * Copyright (c) 2015-2018 Vitaly Novichkov + * Copyright (c) 2015-2020 Vitaly Novichkov * * Permission is hereby granted, free of charge, to any person obtaining * a copy of this software and associated documentation files (the "Software"), @@ -140,6 +140,7 @@ class FileAndMemReader { switch(rel_to) { + default: case SET: m_mp_tell = static_cast(pos); break; diff --git a/thirdparty/opnmidi/fraction.hpp b/thirdparty/opnmidi/fraction.hpp new file mode 100644 index 0000000..892ba25 --- /dev/null +++ b/thirdparty/opnmidi/fraction.hpp @@ -0,0 +1,220 @@ +/* + * Fraction number handling. + * Copyright (C) 1992,2001 Bisqwit (http://iki.fi/bisqwit/) + * + * The license of this file is in Public Domain: + * https://bisqwit.iki.fi/src/index.html + * + * "... and orphan source code files are copyrighted public domain." + */ + +#ifndef bqw_fraction_h +#define bqw_fraction_h + +#include +#include + +template +class fraction +{ + inttype num1, num2; + typedef fraction self; + void Optim(); + + #if 1 + inline void Debug(char, const self &) { } + #else + inline void Debug(char op, const self &b) + { + cerr << nom() << '/' << denom() << ' ' << op + << ' ' << b.nom() << '/' << denom() + << ":\n"; + } + #endif +public: + void set(inttype n, inttype d) { num1=n; num2=d; Optim(); } + + fraction() : num1(0), num2(1) { } + fraction(inttype value) : num1(value), num2(1) { } + fraction(inttype n, inttype d) : num1(n), num2(d) { } + fraction(int value) : num1(value), num2(1) { } + template + explicit fraction(const floattype value) { operator= (value); } + inline double value() const {return nom() / (double)denom(); } + inline long double valuel() const {return nom() / (long double)denom(); } + self &operator+= (const inttype &value) { num1+=value*denom(); Optim(); return *this; } + self &operator-= (const inttype &value) { num1-=value*denom(); Optim(); return *this; } + self &operator*= (const inttype &value) { num1*=value; Optim(); return *this; } + self &operator/= (const inttype &value) { num2*=value; Optim(); return *this; } + self &operator+= (const self &b); + self &operator-= (const self &b); + self &operator*= (const self &b) { Debug('*',b);num1*=b.nom(); num2*=b.denom(); Optim(); return *this; } + self &operator/= (const self &b) { Debug('/',b);num1*=b.denom(); num2*=b.nom(); Optim(); return *this; } + self operator- () const { return self(-num1, num2); } + +#define fraction_blah_func(op1, op2) \ + self operator op1 (const self &b) const { self tmp(*this); tmp op2 b; return tmp; } + + fraction_blah_func( +, += ) + fraction_blah_func( -, -= ) + fraction_blah_func( /, /= ) + fraction_blah_func( *, *= ) + +#undef fraction_blah_func +#define fraction_blah_func(op) \ + bool operator op(const self &b) const { return value() op b.value(); } \ + bool operator op(inttype b) const { return value() op b; } + + fraction_blah_func( < ) + fraction_blah_func( > ) + fraction_blah_func( <= ) + fraction_blah_func( >= ) + +#undef fraction_blah_func + + const inttype &nom() const { return num1; } + const inttype &denom() const { return num2; } + inline bool operator == (inttype b) const { return denom() == 1 && nom() == b; } + inline bool operator != (inttype b) const { return denom() != 1 || nom() != b; } + inline bool operator == (const self &b) const { return denom()==b.denom() && nom()==b.nom(); } + inline bool operator != (const self &b) const { return denom()!=b.denom() || nom()!=b.nom(); } + //operator bool () const { return nom() != 0; } + inline bool negative() const { return (nom() < 0) ^ (denom() < 0); } + + self &operator= (const inttype value) { num2=1; num1=value; return *this; } + //self &operator= (int value) { num2=1; num1=value; return *this; } + + self &operator= (double orig) { return *this = (long double)orig; } + self &operator= (long double orig); +}; + +#ifdef _MSC_VER +#pragma warning(disable:4146) +#endif + +template +void fraction::Optim() +{ + /* Euclidean algorithm */ + inttype n1, n2, nn1, nn2; + + nn1 = std::numeric_limits::is_signed ? (num1 >= 0 ? num1 : -num1) : num1; + nn2 = std::numeric_limits::is_signed ? (num2 >= 0 ? num2 : -num2) : num2; + + if(nn1 < nn2) + n1 = num1, n2 = num2; + else + n1 = num2, n2 = num1; + + if(!num1) { num2 = 1; return; } + for(;;) + { + //fprintf(stderr, "%d/%d: n1=%d,n2=%d\n", nom(),denom(),n1,n2); + inttype tmp = n2 % n1; + if(!tmp)break; + n2 = n1; + n1 = tmp; + } + num1 /= n1; + num2 /= n1; + //fprintf(stderr, "result: %d/%d\n\n", nom(), denom()); +} + +#ifdef _MSC_VER +#pragma warning(default:4146) +#endif + +template +inline const fraction abs(const fraction &f) +{ + return fraction(abs(f.nom()), abs(f.denom())); +} + +#define fraction_blah_func(op) \ + template \ + fraction operator op \ + (const inttype bla, const fraction &b) \ + { return fraction (bla) op b; } +fraction_blah_func( + ) +fraction_blah_func( - ) +fraction_blah_func( * ) +fraction_blah_func( / ) +#undef fraction_blah_func + +#define fraction_blah_func(op1, op2) \ + template \ + fraction &fraction::operator op2 (const fraction &b) \ + { \ + inttype newnom = nom()*b.denom() op1 denom()*b.nom(); \ + num2 *= b.denom(); \ + num1 = newnom; \ + Optim(); \ + return *this; \ + } +fraction_blah_func( +, += ) +fraction_blah_func( -, -= ) +#undef fraction_blah_func + +template +fraction &fraction::operator= (long double orig) +{ + if(orig == 0.0) + { + set(0, 0); + return *this; + } + + inttype cf[25]; + for(int maxdepth=1; maxdepth<25; ++maxdepth) + { + inttype u,v; + long double virhe, a=orig; + int i, viim; + + for(i = 0; i < maxdepth; ++i) + { + cf[i] = (inttype)a; + if(cf[i]-1 > cf[i])break; + a = 1.0 / (a - cf[i]); + } + + for(viim=i-1; i < maxdepth; ++i) + cf[i] = 0; + + u = cf[viim]; + v = 1; + for(i = viim-1; i >= 0; --i) + { + inttype w = cf[i] * u + v; + v = u; + u = w; + } + + virhe = (orig - (u / (long double)v)) / orig; + + set(u, v); + //if(verbose > 4) + // cerr << "Guess: " << *this << " - error = " << virhe*100 << "%\n"; + + if(virhe < 1e-8 && virhe > -1e-8)break; + } + + //if(verbose > 4) + //{ + // cerr << "Fraction=" << orig << ": " << *this << endl; + //} + + return *this; +} + + +/* +template +ostream &operator << (ostream &dest, const fraction &m) +{ + if(m.denom() == (inttype)1) return dest << m.nom(); + return dest << m.nom() << '/' << m.denom(); +} +*/ + +#endif diff --git a/thirdparty/opnmidi/opnbank.h b/thirdparty/opnmidi/opnbank.h index 0e005a3..aff08fb 100644 --- a/thirdparty/opnmidi/opnbank.h +++ b/thirdparty/opnmidi/opnbank.h @@ -1,8 +1,8 @@ /* - * libOPNMIDI is a free MIDI to WAV conversion library with OPN2 (YM2612) emulation + * libOPNMIDI is a free Software MIDI synthesizer library with OPN2 (YM2612) emulation * * MIDI parser and player (Original code from ADLMIDI): Copyright (c) 2010-2014 Joel Yliluoma - * ADLMIDI Library API: Copyright (c) 2016 Vitaly Novichkov + * ADLMIDI Library API: Copyright (c) 2016-2020 Vitaly Novichkov * * Library is based on the ADLMIDI, a MIDI player for Linux and Windows with OPL3 emulation: * http://iki.fi/bisqwit/source/adlmidi.html @@ -48,7 +48,7 @@ enum OPERATOR1 = 0, OPERATOR2 = 1, OPERATOR3 = 2, - OPERATOR4 = 3, + OPERATOR4 = 3 }; /* *********** FM Operator indexes *end******* */ @@ -76,47 +76,46 @@ struct OPN_Operator }; OPNDATA_BYTE_COMPARABLE(struct OPN_Operator) -struct opnInstData +struct OpnTimbre { //! Operators prepared for sending to OPL chip emulator OPN_Operator OPS[4]; + //! Feedback / algorithm uint8_t fbalg; + //! LFO sensitivity uint8_t lfosens; - //! Note offset - int16_t finetune; + //! Semi-tone offset + int16_t noteOffset; }; -OPNDATA_BYTE_COMPARABLE(struct opnInstData) - -struct opnInstMeta -{ - enum { Flag_Pseudo8op = 0x01, Flag_NoSound = 0x02 }; - uint16_t opnno1, opnno2; - uint8_t tone; - uint8_t flags; - uint16_t ms_sound_kon; // Number of milliseconds it produces sound; - uint16_t ms_sound_koff; - double fine_tune; -}; -OPNDATA_BYTE_COMPARABLE(struct opnInstMeta) +OPNDATA_BYTE_COMPARABLE(struct OpnTimbre) /** * @brief Instrument data with operators included */ -struct opnInstMeta2 +struct OpnInstMeta { - opnInstData opn[2]; - uint8_t tone; + enum + { + Flag_Pseudo8op = 0x01, + Flag_NoSound = 0x02 + }; + + //! Operator data + OpnTimbre op[2]; + //! Fixed note for drum instruments + uint8_t drumTone; + //! Instrument flags uint8_t flags; - uint16_t ms_sound_kon; // Number of milliseconds it produces sound; - uint16_t ms_sound_koff; - double fine_tune; - int8_t midi_velocity_offset; -#if 0 - opnInstMeta2() {} - explicit opnInstMeta2(const opnInstMeta &d); -#endif + //! Number of milliseconds it produces sound while key on + uint16_t soundKeyOnMs; + //! Number of milliseconds it produces sound while releasing after key off + uint16_t soundKeyOffMs; + //! MIDI velocity offset + int8_t midiVelocityOffset; + //! Second voice detune + double voice2_fine_tune; }; -OPNDATA_BYTE_COMPARABLE(struct opnInstMeta2) +OPNDATA_BYTE_COMPARABLE(struct OpnInstMeta) #undef OPNDATA_BYTE_COMPARABLE #pragma pack(pop) @@ -129,30 +128,17 @@ struct OpnBankSetup int volumeModel; int lfoEnable; int lfoFrequency; + int chipType; }; -#if 0 -/** - * @brief Conversion of storage formats - */ -inline opnInstMeta2::opnInstMeta2(const opnInstMeta &d) - : tone(d.tone), flags(d.flags), - ms_sound_kon(d.ms_sound_kon), ms_sound_koff(d.ms_sound_koff), - fine_tune(d.fine_tune), midi_velocity_offset(d.midi_velocity_offset) -{ - opn[0] = ::opn[d.opnno1]; - opn[1] = ::opn[d.opnno2]; -} -#endif - /** * @brief Convert external instrument to internal instrument */ -void cvt_OPNI_to_FMIns(opnInstMeta2 &dst, const struct OPN2_Instrument &src); +void cvt_OPNI_to_FMIns(OpnInstMeta &dst, const struct OPN2_Instrument &src); /** * @brief Convert internal instrument to external instrument */ -void cvt_FMIns_to_OPNI(struct OPN2_Instrument &dst, const opnInstMeta2 &src); +void cvt_FMIns_to_OPNI(struct OPN2_Instrument &dst, const OpnInstMeta &src); #endif // OPNMIDI_OPNBANK_H diff --git a/thirdparty/opnmidi/opnmidi.cpp b/thirdparty/opnmidi/opnmidi.cpp index f3b4314..c5cf140 100644 --- a/thirdparty/opnmidi/opnmidi.cpp +++ b/thirdparty/opnmidi/opnmidi.cpp @@ -1,8 +1,8 @@ /* - * libOPNMIDI is a free MIDI to WAV conversion library with OPN2 (YM2612) emulation + * libOPNMIDI is a free Software MIDI synthesizer library with OPN2 (YM2612) emulation * * MIDI parser and player (Original code from ADLMIDI): Copyright (c) 2010-2014 Joel Yliluoma - * OPNMIDI Library and YM2612 support: Copyright (c) 2017-2018 Vitaly Novichkov + * OPNMIDI Library and YM2612 support: Copyright (c) 2017-2020 Vitaly Novichkov * * Library is based on the ADLMIDI, a MIDI player for Linux and Windows with OPL3 emulation: * http://iki.fi/bisqwit/source/adlmidi.html @@ -21,7 +21,13 @@ * along with this program. If not, see . */ +#include "opnmidi_midiplay.hpp" +#include "opnmidi_opn2.hpp" #include "opnmidi_private.hpp" +#include "chips/opn_chip_base.h" +#ifndef OPNMIDI_DISABLE_MIDI_SEQUENCER +#include "midi_sequencer.hpp" +#endif /* Unify MIDI player casting and interface between ADLMIDI and OPNMIDI */ #define GET_MIDI_PLAYER(device) reinterpret_cast((device)->opn2_midiPlayer) @@ -87,9 +93,10 @@ OPNMIDI_EXPORT int opn2_setNumChips(OPN2_MIDIPlayer *device, int numCards) return -1; } - if(!play->m_synth.setupLocked()) + Synth &synth = *play->m_synth; + if(!synth.setupLocked()) { - play->m_synth.m_numChips = play->m_setup.numChips; + synth.m_numChips = play->m_setup.numChips; play->partialReset(); } @@ -111,7 +118,7 @@ OPNMIDI_EXPORT int opn2_getNumChipsObtained(struct OPN2_MIDIPlayer *device) return -2; MidiPlayer *play = GET_MIDI_PLAYER(device); assert(play); - return (int)play->m_synth.m_numChips; + return (int)play->m_synth->m_numChips; } @@ -121,7 +128,7 @@ OPNMIDI_EXPORT int opn2_reserveBanks(OPN2_MIDIPlayer *device, unsigned banks) return -1; MidiPlayer *play = GET_MIDI_PLAYER(device); assert(play); - OPN2::BankMap &map = play->m_synth.m_insBanks; + Synth::BankMap &map = play->m_synth->m_insBanks; map.reserve(banks); return (int)map.capacity(); } @@ -134,13 +141,13 @@ OPNMIDI_EXPORT int opn2_getBank(OPN2_MIDIPlayer *device, const OPN2_BankId *idp, OPN2_BankId id = *idp; if(id.lsb > 127 || id.msb > 127 || id.percussive > 1) return -1; - size_t idnumber = ((id.msb << 8) | id.lsb | (id.percussive ? size_t(OPN2::PercussionTag) : 0)); + size_t idnumber = ((id.msb << 8) | id.lsb | (id.percussive ? size_t(Synth::PercussionTag) : 0)); MidiPlayer *play = GET_MIDI_PLAYER(device); assert(play); - OPN2::BankMap &map = play->m_synth.m_insBanks; + Synth::BankMap &map = play->m_synth->m_insBanks; - OPN2::BankMap::iterator it; + Synth::BankMap::iterator it; if(!(flags & OPNMIDI_Bank_Create)) { it = map.find(idnumber); @@ -149,16 +156,16 @@ OPNMIDI_EXPORT int opn2_getBank(OPN2_MIDIPlayer *device, const OPN2_BankId *idp, } else { - std::pair value; + std::pair value; value.first = idnumber; memset(&value.second, 0, sizeof(value.second)); for (unsigned i = 0; i < 128; ++i) - value.second.ins[i].flags = opnInstMeta::Flag_NoSound; + value.second.ins[i].flags = OpnInstMeta::Flag_NoSound; - std::pair ir; - if(flags & OPNMIDI_Bank_CreateRt) + std::pair ir; + if((flags & OPNMIDI_Bank_CreateRt) == OPNMIDI_Bank_CreateRt) { - ir = map.insert(value, OPN2::BankMap::do_not_expand_t()); + ir = map.insert(value, Synth::BankMap::do_not_expand_t()); if(ir.first == map.end()) return -1; } @@ -176,11 +183,11 @@ OPNMIDI_EXPORT int opn2_getBankId(OPN2_MIDIPlayer *device, const OPN2_Bank *bank if(!device || !bank) return -1; - OPN2::BankMap::iterator it = OPN2::BankMap::iterator::from_ptrs(bank->pointer); - OPN2::BankMap::key_type idnumber = it->first; + Synth::BankMap::iterator it = Synth::BankMap::iterator::from_ptrs(bank->pointer); + Synth::BankMap::key_type idnumber = it->first; id->msb = (idnumber >> 8) & 127; id->lsb = idnumber & 127; - id->percussive = (idnumber & OPN2::PercussionTag) ? 1 : 0; + id->percussive = (idnumber & Synth::PercussionTag) ? 1 : 0; return 0; } @@ -191,8 +198,8 @@ OPNMIDI_EXPORT int opn2_removeBank(OPN2_MIDIPlayer *device, OPN2_Bank *bank) MidiPlayer *play = GET_MIDI_PLAYER(device); assert(play); - OPN2::BankMap &map = play->m_synth.m_insBanks; - OPN2::BankMap::iterator it = OPN2::BankMap::iterator::from_ptrs(bank->pointer); + Synth::BankMap &map = play->m_synth->m_insBanks; + Synth::BankMap::iterator it = Synth::BankMap::iterator::from_ptrs(bank->pointer); size_t size = map.size(); map.erase(it); return (map.size() != size) ? 0 : -1; @@ -205,9 +212,9 @@ OPNMIDI_EXPORT int opn2_getFirstBank(OPN2_MIDIPlayer *device, OPN2_Bank *bank) MidiPlayer *play = GET_MIDI_PLAYER(device); assert(play); - OPN2::BankMap &map = play->m_synth.m_insBanks; + Synth::BankMap &map = play->m_synth->m_insBanks; - OPN2::BankMap::iterator it = map.begin(); + Synth::BankMap::iterator it = map.begin(); if(it == map.end()) return -1; @@ -222,9 +229,9 @@ OPNMIDI_EXPORT int opn2_getNextBank(OPN2_MIDIPlayer *device, OPN2_Bank *bank) MidiPlayer *play = GET_MIDI_PLAYER(device); assert(play); - OPN2::BankMap &map = play->m_synth.m_insBanks; + Synth::BankMap &map = play->m_synth->m_insBanks; - OPN2::BankMap::iterator it = OPN2::BankMap::iterator::from_ptrs(bank->pointer); + Synth::BankMap::iterator it = Synth::BankMap::iterator::from_ptrs(bank->pointer); if(++it == map.end()) return -1; @@ -237,7 +244,7 @@ OPNMIDI_EXPORT int opn2_getInstrument(OPN2_MIDIPlayer *device, const OPN2_Bank * if(!device || !bank || index > 127 || !ins) return -1; - OPN2::BankMap::iterator it = OPN2::BankMap::iterator::from_ptrs(bank->pointer); + Synth::BankMap::iterator it = Synth::BankMap::iterator::from_ptrs(bank->pointer); cvt_FMIns_to_OPNI(*ins, it->second.ins[index]); ins->version = 0; return 0; @@ -251,7 +258,7 @@ OPNMIDI_EXPORT int opn2_setInstrument(OPN2_MIDIPlayer *device, OPN2_Bank *bank, if(ins->version != 0) return -1; - OPN2::BankMap::iterator it = OPN2::BankMap::iterator::from_ptrs(bank->pointer); + Synth::BankMap::iterator it = Synth::BankMap::iterator::from_ptrs(bank->pointer); cvt_OPNI_to_FMIns(it->second.ins[index], *ins); return 0; } @@ -303,11 +310,12 @@ OPNMIDI_EXPORT void opn2_setLfoEnabled(struct OPN2_MIDIPlayer *device, int lfoEn if(!device) return; MidiPlayer *play = GET_MIDI_PLAYER(device); assert(play); + Synth &synth = *play->m_synth; play->m_setup.lfoEnable = lfoEnable; - play->m_synth.m_lfoEnable = (lfoEnable < 0 ? - play->m_synth.m_insBankSetup.lfoEnable : - play->m_setup.lfoEnable) != 0; - play->m_synth.commitLFOSetup(); + synth.m_lfoEnable = (lfoEnable < 0 ? + synth.m_insBankSetup.lfoEnable : + play->m_setup.lfoEnable) != 0; + synth.commitLFOSetup(); } OPNMIDI_EXPORT int opn2_getLfoEnabled(struct OPN2_MIDIPlayer *device) @@ -315,7 +323,7 @@ OPNMIDI_EXPORT int opn2_getLfoEnabled(struct OPN2_MIDIPlayer *device) if(!device) return -1; MidiPlayer *play = GET_MIDI_PLAYER(device); assert(play); - return play->m_synth.m_lfoEnable; + return play->m_synth->m_lfoEnable; } OPNMIDI_EXPORT void opn2_setLfoFrequency(struct OPN2_MIDIPlayer *device, int lfoFrequency) @@ -323,11 +331,12 @@ OPNMIDI_EXPORT void opn2_setLfoFrequency(struct OPN2_MIDIPlayer *device, int lfo if(!device) return; MidiPlayer *play = GET_MIDI_PLAYER(device); assert(play); + Synth &synth = *play->m_synth; play->m_setup.lfoFrequency = lfoFrequency; - play->m_synth.m_lfoFrequency = lfoFrequency < 0 ? - play->m_synth.m_insBankSetup.lfoFrequency : + synth.m_lfoFrequency = lfoFrequency < 0 ? + synth.m_insBankSetup.lfoFrequency : (uint8_t)play->m_setup.lfoFrequency; - play->m_synth.commitLFOSetup(); + synth.commitLFOSetup(); } OPNMIDI_EXPORT int opn2_getLfoFrequency(struct OPN2_MIDIPlayer *device) @@ -335,7 +344,26 @@ OPNMIDI_EXPORT int opn2_getLfoFrequency(struct OPN2_MIDIPlayer *device) if(!device) return -1; MidiPlayer *play = GET_MIDI_PLAYER(device); assert(play); - return play->m_synth.m_lfoFrequency; + return play->m_synth->m_lfoFrequency; +} + +/*Override chip type. -1 - use bank default state*/ +OPNMIDI_EXPORT void opn2_setChipType(struct OPN2_MIDIPlayer *device, int chipType) +{ + if(!device) return; + MidiPlayer *play = GET_MIDI_PLAYER(device); + assert(play); + play->m_setup.chipType = chipType; + play->applySetup(); +} + +/*Get the chip type*/ +OPNMIDI_EXPORT int opn2_getChipType(struct OPN2_MIDIPlayer *device) +{ + if(!device) return -1; + MidiPlayer *play = GET_MIDI_PLAYER(device); + assert(play); + return play->m_synth->chipFamily(); } OPNMIDI_EXPORT void opn2_setScaleModulators(OPN2_MIDIPlayer *device, int smod) @@ -345,7 +373,7 @@ OPNMIDI_EXPORT void opn2_setScaleModulators(OPN2_MIDIPlayer *device, int smod) MidiPlayer *play = GET_MIDI_PLAYER(device); assert(play); play->m_setup.ScaleModulators = smod; - play->m_synth.m_scaleModulators = (play->m_setup.ScaleModulators != 0); + play->m_synth->m_scaleModulators = (play->m_setup.ScaleModulators != 0); } OPNMIDI_EXPORT void opn2_setFullRangeBrightness(struct OPN2_MIDIPlayer *device, int fr_brightness) @@ -359,13 +387,14 @@ OPNMIDI_EXPORT void opn2_setFullRangeBrightness(struct OPN2_MIDIPlayer *device, OPNMIDI_EXPORT void opn2_setLoopEnabled(OPN2_MIDIPlayer *device, int loopEn) { +#ifndef OPNMIDI_DISABLE_MIDI_SEQUENCER if(!device) return; -#ifndef OPNMIDI_DISABLE_MIDI_SEQUENCER - MidiPlayer *play = GET_MIDI_PLAYER(device); - assert(play); - play->m_sequencer.setLoopEnabled(loopEn != 0); + MidiPlayer *play = GET_MIDI_PLAYER(device); + assert(play); + play->m_sequencer->setLoopEnabled(loopEn != 0); #else + ADL_UNUSED(device); ADL_UNUSED(loopEn); #endif } @@ -376,7 +405,7 @@ OPNMIDI_EXPORT void opn2_setSoftPanEnabled(OPN2_MIDIPlayer *device, int softPanE return; MidiPlayer *play = GET_MIDI_PLAYER(device); assert(play); - play->m_synth.m_softPanning = (softPanEn != 0); + play->m_synth->m_softPanning = (softPanEn != 0); } /* !!!DEPRECATED!!! */ @@ -386,13 +415,14 @@ OPNMIDI_EXPORT void opn2_setLogarithmicVolumes(struct OPN2_MIDIPlayer *device, i return; MidiPlayer *play = GET_MIDI_PLAYER(device); assert(play); + Synth &synth = *play->m_synth; play->m_setup.LogarithmicVolumes = static_cast(logvol); - if(!play->m_synth.setupLocked()) + if(!synth.setupLocked()) { if(play->m_setup.LogarithmicVolumes != 0) - play->m_synth.setVolumeScaleModel(OPNMIDI_VolumeModel_NativeOPN2); + synth.setVolumeScaleModel(OPNMIDI_VolumeModel_NativeOPN2); else - play->m_synth.setVolumeScaleModel(static_cast(play->m_setup.VolumeModel)); + synth.setVolumeScaleModel(static_cast(play->m_setup.VolumeModel)); } } @@ -402,13 +432,14 @@ OPNMIDI_EXPORT void opn2_setVolumeRangeModel(OPN2_MIDIPlayer *device, int volume return; MidiPlayer *play = GET_MIDI_PLAYER(device); assert(play); + Synth &synth = *play->m_synth; play->m_setup.VolumeModel = volumeModel; - if(!play->m_synth.setupLocked()) + if(!synth.setupLocked()) { if(play->m_setup.VolumeModel == OPNMIDI_VolumeModel_AUTO)//Use bank default volume model - play->m_synth.m_volumeScale = (OPN2::VolumesScale)play->m_synth.m_insBankSetup.volumeModel; + synth.m_volumeScale = (Synth::VolumesScale)synth.m_insBankSetup.volumeModel; else - play->m_synth.setVolumeScaleModel(static_cast(volumeModel)); + synth.setVolumeScaleModel(static_cast(volumeModel)); } } @@ -418,7 +449,7 @@ OPNMIDI_EXPORT int opn2_getVolumeRangeModel(struct OPN2_MIDIPlayer *device) return -1; MidiPlayer *play = GET_MIDI_PLAYER(device); assert(play); - return play->m_synth.getVolumeScaleModel(); + return play->m_synth->getVolumeScaleModel(); } OPNMIDI_EXPORT int opn2_openFile(OPN2_MIDIPlayer *device, const char *filePath) @@ -487,8 +518,9 @@ OPNMIDI_EXPORT const char *opn2_chipEmulatorName(struct OPN2_MIDIPlayer *device) { MidiPlayer *play = GET_MIDI_PLAYER(device); assert(play); - if(!play->m_synth.m_chips.empty()) - return play->m_synth.m_chips[0]->emulatorName(); + Synth &synth = *play->m_synth; + if(!synth.m_chips.empty()) + return synth.m_chips[0]->emulatorName(); } return "Unknown"; } @@ -517,8 +549,9 @@ OPNMIDI_EXPORT int opn2_setRunAtPcmRate(OPN2_MIDIPlayer *device, int enabled) { MidiPlayer *play = GET_MIDI_PLAYER(device); assert(play); + Synth &synth = *play->m_synth; play->m_setup.runAtPcmRate = (enabled != 0); - if(!play->m_synth.setupLocked()) + if(!synth.setupLocked()) play->partialReset(); return 0; } @@ -584,7 +617,7 @@ OPNMIDI_EXPORT double opn2_totalTimeLength(struct OPN2_MIDIPlayer *device) return -1.0; MidiPlayer *play = GET_MIDI_PLAYER(device); assert(play); - return play->m_sequencer.timeLength(); + return play->m_sequencer->timeLength(); #else ADL_UNUSED(device); return -1.0; @@ -598,7 +631,7 @@ OPNMIDI_EXPORT double opn2_loopStartTime(struct OPN2_MIDIPlayer *device) return -1.0; MidiPlayer *play = GET_MIDI_PLAYER(device); assert(play); - return play->m_sequencer.getLoopStart(); + return play->m_sequencer->getLoopStart(); #else ADL_UNUSED(device); return -1.0; @@ -612,7 +645,7 @@ OPNMIDI_EXPORT double opn2_loopEndTime(struct OPN2_MIDIPlayer *device) return -1.0; MidiPlayer *play = GET_MIDI_PLAYER(device); assert(play); - return play->m_sequencer.getLoopEnd(); + return play->m_sequencer->getLoopEnd(); #else ADL_UNUSED(device); return -1.0; @@ -626,7 +659,7 @@ OPNMIDI_EXPORT double opn2_positionTell(struct OPN2_MIDIPlayer *device) return -1.0; MidiPlayer *play = GET_MIDI_PLAYER(device); assert(play); - return play->m_sequencer.tell(); + return play->m_sequencer->tell(); #else ADL_UNUSED(device); return -1.0; @@ -643,7 +676,7 @@ OPNMIDI_EXPORT void opn2_positionSeek(struct OPN2_MIDIPlayer *device, double sec MidiPlayer *play = GET_MIDI_PLAYER(device); assert(play); play->realTime_panic(); - play->m_setup.delay = play->m_sequencer.seek(seconds, play->m_setup.mindelay); + play->m_setup.delay = play->m_sequencer->seek(seconds, play->m_setup.mindelay); play->m_setup.carry = 0.0; #else ADL_UNUSED(device); @@ -659,7 +692,7 @@ OPNMIDI_EXPORT void opn2_positionRewind(struct OPN2_MIDIPlayer *device) MidiPlayer *play = GET_MIDI_PLAYER(device); assert(play); play->realTime_panic(); - play->m_sequencer.rewind(); + play->m_sequencer->rewind(); #else ADL_UNUSED(device); #endif @@ -672,7 +705,7 @@ OPNMIDI_EXPORT void opn2_setTempo(struct OPN2_MIDIPlayer *device, double tempo) return; MidiPlayer *play = GET_MIDI_PLAYER(device); assert(play); - play->m_sequencer.setTempo(tempo); + play->m_sequencer->setTempo(tempo); #else ADL_UNUSED(device); ADL_UNUSED(tempo); @@ -698,7 +731,7 @@ OPNMIDI_EXPORT const char *opn2_metaMusicTitle(struct OPN2_MIDIPlayer *device) return ""; MidiPlayer *play = GET_MIDI_PLAYER(device); assert(play); - return play->m_sequencer.getMusicTitle().c_str(); + return play->m_sequencer->getMusicTitle().c_str(); #else ADL_UNUSED(device); return ""; @@ -713,7 +746,7 @@ OPNMIDI_EXPORT const char *opn2_metaMusicCopyright(struct OPN2_MIDIPlayer *devic return ""; MidiPlayer *play = GET_MIDI_PLAYER(device); assert(play); - return play->m_sequencer.getMusicCopyright().c_str(); + return play->m_sequencer->getMusicCopyright().c_str(); #else ADL_UNUSED(device); return 0; @@ -727,7 +760,7 @@ OPNMIDI_EXPORT size_t opn2_metaTrackTitleCount(struct OPN2_MIDIPlayer *device) return 0; MidiPlayer *play = GET_MIDI_PLAYER(device); assert(play); - return play->m_sequencer.getTrackTitles().size(); + return play->m_sequencer->getTrackTitles().size(); #else ADL_UNUSED(device); return 0; @@ -741,7 +774,7 @@ OPNMIDI_EXPORT const char *opn2_metaTrackTitle(struct OPN2_MIDIPlayer *device, s return ""; MidiPlayer *play = GET_MIDI_PLAYER(device); assert(play); - const std::vector &titles = play->m_sequencer.getTrackTitles(); + const std::vector &titles = play->m_sequencer->getTrackTitles(); if(index >= titles.size()) return "INVALID"; return titles[index].c_str(); @@ -760,7 +793,7 @@ OPNMIDI_EXPORT size_t opn2_metaMarkerCount(struct OPN2_MIDIPlayer *device) return 0; MidiPlayer *play = GET_MIDI_PLAYER(device); assert(play); - return play->m_sequencer.getMarkers().size(); + return play->m_sequencer->getMarkers().size(); #else ADL_UNUSED(device); return 0; @@ -783,7 +816,7 @@ OPNMIDI_EXPORT Opn2_MarkerEntry opn2_metaMarker(struct OPN2_MIDIPlayer *device, MidiPlayer *play = GET_MIDI_PLAYER(device); assert(play); - const std::vector &markers = play->m_sequencer.getMarkers(); + const std::vector &markers = play->m_sequencer->getMarkers(); if(index >= markers.size()) { marker.label = "INVALID"; @@ -812,8 +845,8 @@ OPNMIDI_EXPORT void opn2_setRawEventHook(struct OPN2_MIDIPlayer *device, OPN2_Ra return; MidiPlayer *play = GET_MIDI_PLAYER(device); assert(play); - play->m_sequencerInterface.onEvent = rawEventHook; - play->m_sequencerInterface.onEvent_userData = userData; + play->m_sequencerInterface->onEvent = rawEventHook; + play->m_sequencerInterface->onEvent_userData = userData; #else ADL_UNUSED(device); ADL_UNUSED(rawEventHook); @@ -842,8 +875,8 @@ OPNMIDI_EXPORT void opn2_setDebugMessageHook(struct OPN2_MIDIPlayer *device, OPN play->hooks.onDebugMessage = debugMessageHook; play->hooks.onDebugMessage_userData = userData; #ifndef OPNMIDI_DISABLE_MIDI_SEQUENCER - play->m_sequencerInterface.onDebugMessage = debugMessageHook; - play->m_sequencerInterface.onDebugMessage_userData = userData; + play->m_sequencerInterface->onDebugMessage = debugMessageHook; + play->m_sequencerInterface->onDebugMessage_userData = userData; #endif } @@ -1029,7 +1062,7 @@ OPNMIDI_EXPORT int opn2_playFormat(OPN2_MIDIPlayer *device, int sampleCount, // setup.SkipForward -= 1; //else { - if((player->m_sequencer.positionAtEnd()) && (setup.delay <= 0.0)) + if((player->m_sequencer->positionAtEnd()) && (setup.delay <= 0.0)) break;//Stop to fetch samples at reaching the song end with disabled loop ssize_t leftSamples = left / 2; @@ -1046,14 +1079,15 @@ OPNMIDI_EXPORT int opn2_playFormat(OPN2_MIDIPlayer *device, int sampleCount, //fill buffer with zeros int32_t *out_buf = player->m_outBuf; std::memset(out_buf, 0, static_cast(in_generatedPhys) * sizeof(out_buf[0])); - unsigned int chips = player->m_synth.m_numChips; + Synth &synth = *player->m_synth; + unsigned int chips = synth.m_numChips; if(chips == 1) - player->m_synth.m_chips[0]->generate32(out_buf, (size_t)in_generatedStereo); + synth.m_chips[0]->generate32(out_buf, (size_t)in_generatedStereo); else/* if(n_periodCountStereo > 0)*/ { /* Generate data from every chip and mix result */ for(size_t card = 0; card < chips; ++card) - player->m_synth.m_chips[card]->generateAndMix32(out_buf, (size_t)in_generatedStereo); + synth.m_chips[card]->generateAndMix32(out_buf, (size_t)in_generatedStereo); } /* Process it */ if(SendStereoAudio(sampleCount, in_generatedStereo, out_buf, gotten_len, out_left, out_right, format) == -1) @@ -1123,14 +1157,15 @@ OPNMIDI_EXPORT int opn2_generateFormat(struct OPN2_MIDIPlayer *device, int sampl //fill buffer with zeros int32_t *out_buf = player->m_outBuf; std::memset(out_buf, 0, static_cast(in_generatedPhys) * sizeof(out_buf[0])); - unsigned int chips = player->m_synth.m_numChips; + Synth &synth = *player->m_synth; + unsigned int chips = synth.m_numChips; if(chips == 1) - player->m_synth.m_chips[0]->generate32(out_buf, (size_t)in_generatedStereo); + synth.m_chips[0]->generate32(out_buf, (size_t)in_generatedStereo); else/* if(n_periodCountStereo > 0)*/ { /* Generate data from every chip and mix result */ for(size_t card = 0; card < chips; ++card) - player->m_synth.m_chips[card]->generateAndMix32(out_buf, (size_t)in_generatedStereo); + synth.m_chips[card]->generateAndMix32(out_buf, (size_t)in_generatedStereo); } /* Process it */ if(SendStereoAudio(sampleCount, in_generatedStereo, out_buf, gotten_len, out_left, out_right, format) == -1) @@ -1170,7 +1205,7 @@ OPNMIDI_EXPORT int opn2_atEnd(struct OPN2_MIDIPlayer *device) return 1; MidiPlayer *play = GET_MIDI_PLAYER(device); assert(play); - return (int)play->m_sequencer.positionAtEnd(); + return (int)play->m_sequencer->positionAtEnd(); #else ADL_UNUSED(device); return 1; @@ -1184,7 +1219,7 @@ OPNMIDI_EXPORT size_t opn2_trackCount(struct OPN2_MIDIPlayer *device) return 0; MidiPlayer *play = GET_MIDI_PLAYER(device); assert(play); - return play->m_sequencer.getTrackCount(); + return play->m_sequencer->getTrackCount(); #else ADL_UNUSED(device); return 0; @@ -1198,7 +1233,7 @@ OPNMIDI_EXPORT int opn2_setTrackOptions(struct OPN2_MIDIPlayer *device, size_t t return -1; MidiPlayer *play = GET_MIDI_PLAYER(device); assert(play); - MidiSequencer &seq = play->m_sequencer; + MidiSequencer &seq = *play->m_sequencer; unsigned enableFlag = trackOptions & 3; trackOptions &= ~3u; diff --git a/thirdparty/opnmidi/opnmidi.h b/thirdparty/opnmidi/opnmidi.h index 5f2cd78..bf02920 100644 --- a/thirdparty/opnmidi/opnmidi.h +++ b/thirdparty/opnmidi/opnmidi.h @@ -1,8 +1,8 @@ /* - * libOPNMIDI is a free MIDI to WAV conversion library with OPN2 (YM2612) emulation + * libOPNMIDI is a free Software MIDI synthesizer library with OPN2 (YM2612) emulation * * MIDI parser and player (Original code from ADLMIDI): Copyright (c) 2010-2014 Joel Yliluoma - * OPNMIDI Library and YM2612 support: Copyright (c) 2017-2018 Vitaly Novichkov + * OPNMIDI Library and YM2612 support: Copyright (c) 2017-2020 Vitaly Novichkov * * Library is based on the ADLMIDI, a MIDI player for Linux and Windows with OPL3 emulation: * http://iki.fi/bisqwit/source/adlmidi.html @@ -29,7 +29,7 @@ extern "C" { #endif #define OPNMIDI_VERSION_MAJOR 1 -#define OPNMIDI_VERSION_MINOR 4 +#define OPNMIDI_VERSION_MINOR 5 #define OPNMIDI_VERSION_PATCHLEVEL 0 #define OPNMIDI_TOSTR_I(s) #s @@ -39,6 +39,9 @@ extern "C" { OPNMIDI_TOSTR(OPNMIDI_VERSION_MINOR) "." \ OPNMIDI_TOSTR(OPNMIDI_VERSION_PATCHLEVEL) +#define OPN_OPN2_SAMPLE_RATE 53267 +#define OPN_OPNA_SAMPLE_RATE 55466 + #include #if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) @@ -93,6 +96,17 @@ typedef short OPN2_SInt16; # define OPNMIDI_DECLSPEC #endif +/** + * @brief Chip types + */ +enum OPNMIDI_ChipType +{ + /*! The Yamaha OPN2, alias YM2612 YM3438 */ + OPNMIDI_ChipType_OPN2 = 0, + /*! The Yamaha OPNA, alias YM2608 */ + OPNMIDI_ChipType_OPNA +}; + /** * @brief Volume scaling models */ @@ -138,7 +152,7 @@ enum OPNMIDI_SampleType /*! unsigned PCM 32-bit */ OPNMIDI_SampleType_U32, /*! Count of available sample format types */ - OPNMIDI_SampleType_Count, + OPNMIDI_SampleType_Count }; /** @@ -220,7 +234,74 @@ enum OPN2_BankAccessFlags OPNMIDI_Bank_CreateRt = 1|2 }; -typedef struct OPN2_Instrument OPN2_Instrument; + + +/* ======== Instrument structures ======== */ + +/** + * @brief Version of the instrument data format + */ +enum +{ + OPNMIDI_InstrumentVersion = 0 +}; + +/** + * @brief Instrument flags + */ +typedef enum OPN2_InstrumentFlags +{ + OPNMIDI_Ins_Pseudo8op = 0x01, /*Reserved for future use, not implemented yet*/ + OPNMIDI_Ins_IsBlank = 0x02 +} OPN2_InstrumentFlags; + +/** + * @brief Operator structure, part of Instrument structure + */ +typedef struct OPN2_Operator +{ + /* Detune and frequency multiplication register data */ + OPN2_UInt8 dtfm_30; + /* Total level register data */ + OPN2_UInt8 level_40; + /* Rate scale and attack register data */ + OPN2_UInt8 rsatk_50; + /* Amplitude modulation enable and Decay-1 register data */ + OPN2_UInt8 amdecay1_60; + /* Decay-2 register data */ + OPN2_UInt8 decay2_70; + /* Sustain and Release register data */ + OPN2_UInt8 susrel_80; + /* SSG-EG register data */ + OPN2_UInt8 ssgeg_90; +} OPN2_Operator; + +/** + * @brief Instrument structure + */ +typedef struct OPN2_Instrument +{ + /*! Version of the instrument object */ + int version; + /* MIDI note key (half-tone) offset for an instrument (or a first voice in pseudo-4-op mode) */ + OPN2_SInt16 note_offset; + /* Reserved */ + OPN2_SInt8 midi_velocity_offset; + /* Percussion MIDI base tone number at which this drum will be played */ + OPN2_UInt8 percussion_key_number; + /* Instrument flags */ + OPN2_UInt8 inst_flags; + /* Feedback and Algorithm register data */ + OPN2_UInt8 fbalg; + /* LFO Sensitivity register data */ + OPN2_UInt8 lfosens; + /* Operators register data */ + OPN2_Operator operators[4]; + /* Millisecond delay of sounding while key is on */ + OPN2_UInt16 delay_on_ms; + /* Millisecond delay of sounding after key off */ + OPN2_UInt16 delay_off_ms; +} OPN2_Instrument; @@ -311,6 +392,12 @@ extern OPNMIDI_DECLSPEC void opn2_setLfoFrequency(struct OPN2_MIDIPlayer *device /*Get the LFO frequency*/ extern OPNMIDI_DECLSPEC int opn2_getLfoFrequency(struct OPN2_MIDIPlayer *device); +/*Override chip type. -1 - use bank default state*/ +extern OPNMIDI_DECLSPEC void opn2_setChipType(struct OPN2_MIDIPlayer *device, int chipType); + +/*Get the chip type*/ +extern OPNMIDI_DECLSPEC int opn2_getChipType(struct OPN2_MIDIPlayer *device); + /** * @brief Override Enable(1) or Disable(0) scaling of modulator volumes. -1 - use bank default scaling of modulator volumes * @param device Instance of the library @@ -419,6 +506,14 @@ enum Opn2_Emulator OPNMIDI_EMU_GENS, /*! Genesis Plus GX (a fork of Mame YM2612) */ OPNMIDI_EMU_GX, + /*! Neko Project II OPNA */ + OPNMIDI_EMU_NP2, + /*! Mame YM2608 */ + OPNMIDI_EMU_MAME_2608, + /*! PMDWin OPNA */ + OPNMIDI_EMU_PMDWIN, + /*! VGM file dumper (required for MIDI2VGM) */ + OPNMIDI_VGM_DUMPER, /*! Count instrument on the level */ OPNMIDI_EMU_end }; @@ -502,6 +597,8 @@ extern OPNMIDI_DECLSPEC const char *opn2_errorInfo(struct OPN2_MIDIPlayer *devic * Tip 1: You can initialize multiple instances and run them in parallel * Tip 2: Library is NOT thread-safe, therefore don't use same instance in different threads or use mutexes * Tip 3: Changing of sample rate on the fly is not supported. Re-create the instance again. + * Top 4: To generate output in OPN2 or OPNA chip native sample rate, please initialize it with sample rate + * value as `OPN_OPN2_SAMPLE_RATE` or `OPN_OPNA_SAMPLE_RATE` in dependence on the chip * * @param sample_rate Output sample rate * @return Instance of the library. If NULL was returned, check the `adl_errorString` message for more info. @@ -798,7 +895,7 @@ enum OPNMIDI_TrackOptions /*! Disabled track */ OPNMIDI_TrackOption_Off = 2, /*! Solo track */ - OPNMIDI_TrackOption_Solo = 3, + OPNMIDI_TrackOption_Solo = 3 }; /** @@ -1002,76 +1099,6 @@ extern OPNMIDI_DECLSPEC void opn2_setDebugMessageHook(struct OPN2_MIDIPlayer *de */ extern OPNMIDI_DECLSPEC int opn2_describeChannels(struct OPN2_MIDIPlayer *device, char *text, char *attr, size_t size); - - - -/* ======== Instrument structures ======== */ - -/** - * @brief Version of the instrument data format - */ -enum -{ - OPNMIDI_InstrumentVersion = 0 -}; - -/** - * @brief Instrument flags - */ -typedef enum OPN2_InstrumentFlags -{ - OPNMIDI_Ins_Pseudo8op = 0x01, /*Reserved for future use, not implemented yet*/ - OPNMIDI_Ins_IsBlank = 0x02 -} OPN2_InstrumentFlags; - -/** - * @brief Operator structure, part of Instrument structure - */ -typedef struct OPN2_Operator -{ - /* Detune and frequency multiplication register data */ - OPN2_UInt8 dtfm_30; - /* Total level register data */ - OPN2_UInt8 level_40; - /* Rate scale and attack register data */ - OPN2_UInt8 rsatk_50; - /* Amplitude modulation enable and Decay-1 register data */ - OPN2_UInt8 amdecay1_60; - /* Decay-2 register data */ - OPN2_UInt8 decay2_70; - /* Sustain and Release register data */ - OPN2_UInt8 susrel_80; - /* SSG-EG register data */ - OPN2_UInt8 ssgeg_90; -} OPN2_Operator; - -/** - * @brief Instrument structure - */ -typedef struct OPN2_Instrument -{ - /*! Version of the instrument object */ - int version; - /* MIDI note key (half-tone) offset for an instrument (or a first voice in pseudo-4-op mode) */ - OPN2_SInt16 note_offset; - /* Reserved */ - OPN2_SInt8 midi_velocity_offset; - /* Percussion MIDI base tone number at which this drum will be played */ - OPN2_UInt8 percussion_key_number; - /* Instrument flags */ - OPN2_UInt8 inst_flags; - /* Feedback and Algorithm register data */ - OPN2_UInt8 fbalg; - /* LFO Sensitivity register data */ - OPN2_UInt8 lfosens; - /* Operators register data */ - OPN2_Operator operators[4]; - /* Millisecond delay of sounding while key is on */ - OPN2_UInt16 delay_on_ms; - /* Millisecond delay of sounding after key off */ - OPN2_UInt16 delay_off_ms; -} OPN2_Instrument; - #ifdef __cplusplus } #endif diff --git a/thirdparty/opnmidi/opnmidi_bankmap.h b/thirdparty/opnmidi/opnmidi_bankmap.h index 98293b8..6881d8b 100644 --- a/thirdparty/opnmidi/opnmidi_bankmap.h +++ b/thirdparty/opnmidi/opnmidi_bankmap.h @@ -1,8 +1,8 @@ /* - * libOPNMIDI is a free MIDI to WAV conversion library with OPN2 (YM2612) emulation + * libOPNMIDI is a free Software MIDI synthesizer library with OPN2 (YM2612) emulation * * MIDI parser and player (Original code from ADLMIDI): Copyright (c) 2010-2014 Joel Yliluoma - * ADLMIDI Library API: Copyright (c) 2015-2018 Vitaly Novichkov + * ADLMIDI Library API: Copyright (c) 2015-2020 Vitaly Novichkov * * Library is based on the ADLMIDI, a MIDI player for Linux and Windows with OPL3 emulation: * http://iki.fi/bisqwit/source/adlmidi.html @@ -74,7 +74,7 @@ class BasicBankMap enum { hash_bits = 8, /* worst case # of collisions: 128^2/2^hash_bits */ - hash_buckets = 1 << hash_bits, + hash_buckets = 1 << hash_bits }; public: diff --git a/thirdparty/opnmidi/opnmidi_bankmap.tcc b/thirdparty/opnmidi/opnmidi_bankmap.tcc index 80ced11..b7b1718 100644 --- a/thirdparty/opnmidi/opnmidi_bankmap.tcc +++ b/thirdparty/opnmidi/opnmidi_bankmap.tcc @@ -2,7 +2,7 @@ * libOPNMIDI is a free MIDI to WAV conversion library with OPN2 (YM2612) emulation * * MIDI parser and player (Original code from ADLMIDI): Copyright (c) 2010-2014 Joel Yliluoma - * ADLMIDI Library API: Copyright (c) 2015-2018 Vitaly Novichkov + * ADLMIDI Library API: Copyright (c) 2015-2020 Vitaly Novichkov * * Library is based on the ADLMIDI, a MIDI player for Linux and Windows with OPL3 emulation: * http://iki.fi/bisqwit/source/adlmidi.html diff --git a/thirdparty/opnmidi/opnmidi_cvt.hpp b/thirdparty/opnmidi/opnmidi_cvt.hpp index b565b9b..6814b1d 100644 --- a/thirdparty/opnmidi/opnmidi_cvt.hpp +++ b/thirdparty/opnmidi/opnmidi_cvt.hpp @@ -1,8 +1,8 @@ /* - * libOPNMIDI is a free MIDI to WAV conversion library with OPN2 (YM2612) emulation + * libOPNMIDI is a free Software MIDI synthesizer library with OPN2 (YM2612) emulation * * MIDI parser and player (Original code from ADLMIDI): Copyright (c) 2010-2014 Joel Yliluoma - * ADLMIDI Library API: Copyright (c) 2015-2018 Vitaly Novichkov + * ADLMIDI Library API: Copyright (c) 2015-2020 Vitaly Novichkov * * Library is based on the ADLMIDI, a MIDI player for Linux and Windows with OPL3 emulation: * http://iki.fi/bisqwit/source/adlmidi.html @@ -24,59 +24,59 @@ #include "opnbank.h" template -static void cvt_generic_to_FMIns(opnInstMeta2 &ins, const WOPNI &in) +static void cvt_generic_to_FMIns(OpnInstMeta &ins, const WOPNI &in) { - ins.tone = in.percussion_key_number; + ins.drumTone = in.percussion_key_number; ins.flags = in.inst_flags; /* Junk, delete later */ - ins.fine_tune = 0.0; + ins.voice2_fine_tune = 0.0; /* Junk, delete later */ - ins.opn[0].fbalg = in.fbalg; - ins.opn[0].lfosens = in.lfosens; - ins.opn[0].finetune = in.note_offset; - ins.midi_velocity_offset = in.midi_velocity_offset; + ins.op[0].fbalg = in.fbalg; + ins.op[0].lfosens = in.lfosens; + ins.op[0].noteOffset = in.note_offset; + ins.midiVelocityOffset = in.midi_velocity_offset; for(size_t op = 0; op < 4; op++) { - ins.opn[0].OPS[op].data[0] = in.operators[op].dtfm_30; - ins.opn[0].OPS[op].data[1] = in.operators[op].level_40; - ins.opn[0].OPS[op].data[2] = in.operators[op].rsatk_50; - ins.opn[0].OPS[op].data[3] = in.operators[op].amdecay1_60; - ins.opn[0].OPS[op].data[4] = in.operators[op].decay2_70; - ins.opn[0].OPS[op].data[5] = in.operators[op].susrel_80; - ins.opn[0].OPS[op].data[6] = in.operators[op].ssgeg_90; + ins.op[0].OPS[op].data[0] = in.operators[op].dtfm_30; + ins.op[0].OPS[op].data[1] = in.operators[op].level_40; + ins.op[0].OPS[op].data[2] = in.operators[op].rsatk_50; + ins.op[0].OPS[op].data[3] = in.operators[op].amdecay1_60; + ins.op[0].OPS[op].data[4] = in.operators[op].decay2_70; + ins.op[0].OPS[op].data[5] = in.operators[op].susrel_80; + ins.op[0].OPS[op].data[6] = in.operators[op].ssgeg_90; } - ins.opn[1] = ins.opn[0]; + ins.op[1] = ins.op[0]; - ins.ms_sound_kon = in.delay_on_ms; - ins.ms_sound_koff = in.delay_off_ms; + ins.soundKeyOnMs = in.delay_on_ms; + ins.soundKeyOffMs = in.delay_off_ms; } template -static void cvt_FMIns_to_generic(WOPNI &ins, const opnInstMeta2 &in) +static void cvt_FMIns_to_generic(WOPNI &ins, const OpnInstMeta &in) { - ins.percussion_key_number = in.tone; + ins.percussion_key_number = in.drumTone; ins.inst_flags = in.flags; - ins.fbalg = in.opn[0].fbalg; - ins.lfosens = in.opn[0].lfosens; - ins.note_offset = in.opn[0].finetune; + ins.fbalg = in.op[0].fbalg; + ins.lfosens = in.op[0].lfosens; + ins.note_offset = in.op[0].noteOffset; - ins.midi_velocity_offset = in.midi_velocity_offset; + ins.midi_velocity_offset = in.midiVelocityOffset; for(size_t op = 0; op < 4; op++) { - ins.operators[op].dtfm_30 = in.opn[0].OPS[op].data[0]; - ins.operators[op].level_40 = in.opn[0].OPS[op].data[1]; - ins.operators[op].rsatk_50 = in.opn[0].OPS[op].data[2]; - ins.operators[op].amdecay1_60 = in.opn[0].OPS[op].data[3]; - ins.operators[op].decay2_70 = in.opn[0].OPS[op].data[4]; - ins.operators[op].susrel_80 = in.opn[0].OPS[op].data[5]; - ins.operators[op].ssgeg_90 = in.opn[0].OPS[op].data[6]; + ins.operators[op].dtfm_30 = in.op[0].OPS[op].data[0]; + ins.operators[op].level_40 = in.op[0].OPS[op].data[1]; + ins.operators[op].rsatk_50 = in.op[0].OPS[op].data[2]; + ins.operators[op].amdecay1_60 = in.op[0].OPS[op].data[3]; + ins.operators[op].decay2_70 = in.op[0].OPS[op].data[4]; + ins.operators[op].susrel_80 = in.op[0].OPS[op].data[5]; + ins.operators[op].ssgeg_90 = in.op[0].OPS[op].data[6]; } - ins.delay_on_ms = in.ms_sound_kon; - ins.delay_off_ms = in.ms_sound_koff; + ins.delay_on_ms = in.soundKeyOnMs; + ins.delay_off_ms = in.soundKeyOffMs; } diff --git a/thirdparty/opnmidi/opnmidi_load.cpp b/thirdparty/opnmidi/opnmidi_load.cpp index 1fd8a33..246a0bf 100644 --- a/thirdparty/opnmidi/opnmidi_load.cpp +++ b/thirdparty/opnmidi/opnmidi_load.cpp @@ -1,8 +1,8 @@ /* - * libOPNMIDI is a free MIDI to WAV conversion library with OPN2 (YM2612) emulation + * libOPNMIDI is a free Software MIDI synthesizer library with OPN2 (YM2612) emulation * * MIDI parser and player (Original code from ADLMIDI): Copyright (c) 2010-2014 Joel Yliluoma - * OPNMIDI Library and YM2612 support: Copyright (c) 2017-2018 Vitaly Novichkov + * OPNMIDI Library and YM2612 support: Copyright (c) 2017-2020 Vitaly Novichkov * * Library is based on the ADLMIDI, a MIDI player for Linux and Windows with OPL3 emulation: * http://iki.fi/bisqwit/source/adlmidi.html @@ -21,8 +21,14 @@ * along with this program. If not, see . */ +#include "opnmidi_midiplay.hpp" +#include "opnmidi_opn2.hpp" #include "opnmidi_private.hpp" #include "opnmidi_cvt.hpp" +#include "file_reader.hpp" +#ifndef OPNMIDI_DISABLE_MIDI_SEQUENCER +#include "midi_sequencer.hpp" +#endif #include "wopn/wopn_file.h" bool OPNMIDIplay::LoadBank(const std::string &filename) @@ -39,12 +45,12 @@ bool OPNMIDIplay::LoadBank(const void *data, size_t size) return LoadBank(file); } -void cvt_OPNI_to_FMIns(opnInstMeta2 &ins, const OPN2_Instrument &in) +void cvt_OPNI_to_FMIns(OpnInstMeta &ins, const OPN2_Instrument &in) { return cvt_generic_to_FMIns(ins, in); } -void cvt_FMIns_to_OPNI(OPN2_Instrument &ins, const opnInstMeta2 &in) +void cvt_FMIns_to_OPNI(OPN2_Instrument &ins, const OpnInstMeta &in) { cvt_FMIns_to_generic(ins, in); } @@ -104,14 +110,17 @@ bool OPNMIDIplay::LoadBank(FileAndMemReader &fr) } } - m_synth.m_insBankSetup.volumeModel = wopn->volume_model; - m_synth.m_insBankSetup.lfoEnable = (wopn->lfo_freq & 8) != 0; - m_synth.m_insBankSetup.lfoFrequency = wopn->lfo_freq & 7; + Synth &synth = *m_synth; + synth.m_insBankSetup.volumeModel = wopn->volume_model; + synth.m_insBankSetup.lfoEnable = (wopn->lfo_freq & 8) != 0; + synth.m_insBankSetup.lfoFrequency = wopn->lfo_freq & 7; + synth.m_insBankSetup.chipType = wopn->chip_type; m_setup.VolumeModel = OPNMIDI_VolumeModel_AUTO; m_setup.lfoEnable = -1; m_setup.lfoFrequency = -1; + m_setup.chipType = -1; - m_synth.m_insBanks.clear(); + synth.m_insBanks.clear(); uint16_t slots_counts[2] = {wopn->banks_count_melodic, wopn->banks_count_percussion}; WOPNBank *slots_src_ins[2] = { wopn->banks_melodic, wopn->banks_percussive }; @@ -122,12 +131,12 @@ bool OPNMIDIplay::LoadBank(FileAndMemReader &fr) { size_t bankno = (slots_src_ins[ss][i].bank_midi_msb * 256) + (slots_src_ins[ss][i].bank_midi_lsb) + - (ss ? size_t(OPN2::PercussionTag) : 0); - OPN2::Bank &bank = m_synth.m_insBanks[bankno]; + (ss ? size_t(Synth::PercussionTag) : 0); + Synth::Bank &bank = synth.m_insBanks[bankno]; for(int j = 0; j < 128; j++) { - opnInstMeta2 &ins = bank.ins[j]; - std::memset(&ins, 0, sizeof(opnInstMeta2)); + OpnInstMeta &ins = bank.ins[j]; + std::memset(&ins, 0, sizeof(OpnInstMeta)); WOPNInstrument &inIns = slots_src_ins[ss][i].ins[j]; cvt_generic_to_FMIns(ins, inIns); } @@ -145,7 +154,8 @@ bool OPNMIDIplay::LoadBank(FileAndMemReader &fr) bool OPNMIDIplay::LoadMIDI_pre() { - if(m_synth.m_insBanks.empty()) + Synth &synth = *m_synth; + if(synth.m_insBanks.empty()) { errorStringOut = "Bank is not set! Please load any instruments bank by using of adl_openBankFile() or adl_openBankData() functions!"; return false; @@ -160,7 +170,9 @@ bool OPNMIDIplay::LoadMIDI_pre() bool OPNMIDIplay::LoadMIDI_post() { - MidiSequencer::FileFormat format = m_sequencer.getFormat(); + Synth &synth = *m_synth; + MidiSequencer &seq = *m_sequencer; + MidiSequencer::FileFormat format = seq.getFormat(); if(format == MidiSequencer::Format_CMF) { errorStringOut = "OPNMIDI doesn't supports CMF, use ADLMIDI to play this file!"; @@ -169,9 +181,9 @@ bool OPNMIDIplay::LoadMIDI_post() } else if(format == MidiSequencer::Format_RSXX) { - m_synth.m_musicMode = OPN2::MODE_RSXX; - m_synth.m_volumeScale = OPN2::VOLUME_Generic; - m_synth.m_numChips = 2; + synth.m_musicMode = Synth::MODE_RSXX; + synth.m_volumeScale = Synth::VOLUME_Generic; + synth.m_numChips = 2; } else if(format == MidiSequencer::Format_IMF) { @@ -179,11 +191,21 @@ bool OPNMIDIplay::LoadMIDI_post() /* Same as for CMF */ return false; } + else if(format == MidiSequencer::Format_XMIDI) + synth.m_musicMode = Synth::MODE_XMIDI; m_setup.tick_skip_samples_delay = 0; - m_synth.reset(m_setup.emulator, m_setup.PCM_RATE, this); // Reset OPN2 chip + synth.reset(m_setup.emulator, m_setup.PCM_RATE, synth.chipFamily(), this); // Reset OPN2 chip m_chipChannels.clear(); - m_chipChannels.resize(m_synth.m_numChannels); + m_chipChannels.resize(synth.m_numChannels); + resetMIDIDefaults(); +#ifdef OPNMIDI_MIDI2VGM + m_sequencerInterface->onloopStart = synth.m_loopStartHook; + m_sequencerInterface->onloopStart_userData = synth.m_loopStartHookData; + m_sequencerInterface->onloopEnd = synth.m_loopEndHook; + m_sequencerInterface->onloopEnd_userData = synth.m_loopEndHookData; + m_sequencer->setLoopHooksOnly(m_sequencerInterface->onloopStart != NULL); +#endif return true; } @@ -195,9 +217,10 @@ bool OPNMIDIplay::LoadMIDI(const std::string &filename) file.openFile(filename.c_str()); if(!LoadMIDI_pre()) return false; - if(!m_sequencer.loadMIDI(file)) + MidiSequencer &seq = *m_sequencer; + if(!seq.loadMIDI(file)) { - errorStringOut = m_sequencer.getErrorString(); + errorStringOut = seq.getErrorString(); return false; } if(!LoadMIDI_post()) @@ -211,9 +234,10 @@ bool OPNMIDIplay::LoadMIDI(const void *data, size_t size) file.openData(data, size); if(!LoadMIDI_pre()) return false; - if(!m_sequencer.loadMIDI(file)) + MidiSequencer &seq = *m_sequencer; + if(!seq.loadMIDI(file)) { - errorStringOut = m_sequencer.getErrorString(); + errorStringOut = seq.getErrorString(); return false; } if(!LoadMIDI_post()) diff --git a/thirdparty/opnmidi/opnmidi_midiplay.cpp b/thirdparty/opnmidi/opnmidi_midiplay.cpp index 6e9f3bc..f3e4f49 100644 --- a/thirdparty/opnmidi/opnmidi_midiplay.cpp +++ b/thirdparty/opnmidi/opnmidi_midiplay.cpp @@ -1,8 +1,8 @@ /* - * libOPNMIDI is a free MIDI to WAV conversion library with OPN2 (YM2612) emulation + * libOPNMIDI is a free Software MIDI synthesizer library with OPN2 (YM2612) emulation * * MIDI parser and player (Original code from ADLMIDI): Copyright (c) 2010-2014 Joel Yliluoma - * OPNMIDI Library and YM2612 support: Copyright (c) 2017-2018 Vitaly Novichkov + * OPNMIDI Library and YM2612 support: Copyright (c) 2017-2020 Vitaly Novichkov * * Library is based on the ADLMIDI, a MIDI player for Linux and Windows with OPL3 emulation: * http://iki.fi/bisqwit/source/adlmidi.html @@ -21,37 +21,16 @@ * along with this program. If not, see . */ +#include "opnmidi_midiplay.hpp" +#include "opnmidi_opn2.hpp" #include "opnmidi_private.hpp" +#ifndef OPNMIDI_DISABLE_MIDI_SEQUENCER +#include "midi_sequencer.hpp" +#endif +#include "chips/opn_chip_base.h" -// Mapping from MIDI volume level to OPL level value. - -static const uint_fast32_t DMX_volume_mapping_table[128] = -{ - 0, 1, 3, 5, 6, 8, 10, 11, - 13, 14, 16, 17, 19, 20, 22, 23, - 25, 26, 27, 29, 30, 32, 33, 34, - 36, 37, 39, 41, 43, 45, 47, 49, - 50, 52, 54, 55, 57, 59, 60, 61, - 63, 64, 66, 67, 68, 69, 71, 72, - 73, 74, 75, 76, 77, 79, 80, 81, - 82, 83, 84, 84, 85, 86, 87, 88, - 89, 90, 91, 92, 92, 93, 94, 95, - 96, 96, 97, 98, 99, 99, 100, 101, - 101, 102, 103, 103, 104, 105, 105, 106, - 107, 107, 108, 109, 109, 110, 110, 111, - 112, 112, 113, 113, 114, 114, 115, 115, - 116, 117, 117, 118, 118, 119, 119, 120, - 120, 121, 121, 122, 122, 123, 123, 123, - 124, 124, 125, 125, 126, 126, 127, 127, -}; - -static const uint_fast32_t W9X_volume_mapping_table[32] = -{ - 63, 63, 40, 36, 32, 28, 23, 21, - 19, 17, 15, 14, 13, 12, 11, 10, - 9, 8, 7, 6, 5, 5, 4, 4, - 3, 3, 2, 2, 1, 1, 0, 0 -}; +// Minimum life time of percussion notes +static const double drum_note_min_time = 0.03; enum { MasterVolumeDefault = 127 }; @@ -63,7 +42,7 @@ inline bool isXgPercChannel(uint8_t msb, uint8_t lsb) void OPNMIDIplay::OpnChannel::addAge(int64_t us) { const int64_t neg = 1000 * static_cast(-0x1FFFFFFFl); - if(users_empty()) + if(users.empty()) { koff_time_until_neglible_us = std::max(koff_time_until_neglible_us - us, neg); if(koff_time_until_neglible_us < 0) @@ -72,17 +51,17 @@ void OPNMIDIplay::OpnChannel::addAge(int64_t us) else { koff_time_until_neglible_us = 0; - for(LocationData *i = users_first; i; i = i->next) + for(users_iterator i = users.begin(); !i.is_end(); ++i) { - if(!i->fixed_sustain) - i->kon_time_until_neglible_us = std::max(i->kon_time_until_neglible_us - us, neg); - i->vibdelay_us += us; + LocationData &d = i->value; + if(!d.fixed_sustain) + d.kon_time_until_neglible_us = std::max(d.kon_time_until_neglible_us - us, neg); + d.vibdelay_us += us; } } } OPNMIDIplay::OPNMIDIplay(unsigned long sampleRate) : - m_masterVolume(MasterVolumeDefault), m_sysExDeviceId(0), m_synthMode(Mode_XG), m_arpeggioCounter(0) @@ -96,8 +75,8 @@ OPNMIDIplay::OPNMIDIplay(unsigned long sampleRate) : m_setup.runAtPcmRate = false; m_setup.PCM_RATE = sampleRate; - m_setup.mindelay = 1.0 / (double)m_setup.PCM_RATE; - m_setup.maxdelay = 512.0 / (double)m_setup.PCM_RATE; + m_setup.mindelay = 1.0 / static_cast(m_setup.PCM_RATE); + m_setup.maxdelay = 512.0 / static_cast(m_setup.PCM_RATE); m_setup.OpnBank = 0; m_setup.numChips = 2; @@ -105,6 +84,7 @@ OPNMIDIplay::OPNMIDIplay(unsigned long sampleRate) : m_setup.VolumeModel = OPNMIDI_VolumeModel_AUTO; m_setup.lfoEnable = -1; m_setup.lfoFrequency = -1; + m_setup.chipType = -1; //m_setup.SkipForward = 0; m_setup.ScaleModulators = 0; m_setup.fullRangeBrightnessCC74 = false; @@ -112,7 +92,10 @@ OPNMIDIplay::OPNMIDIplay(unsigned long sampleRate) : m_setup.carry = 0.0; m_setup.tick_skip_samples_delay = 0; + m_synth.reset(new Synth); + #ifndef OPNMIDI_DISABLE_MIDI_SEQUENCER + m_sequencer.reset(new MidiSequencer); initSequencerInterface(); #endif resetMIDI(); @@ -120,57 +103,86 @@ OPNMIDIplay::OPNMIDIplay(unsigned long sampleRate) : realTime_ResetState(); } +OPNMIDIplay::~OPNMIDIplay() +{ +} + void OPNMIDIplay::applySetup() { - m_synth.m_musicMode = OPN2::MODE_MIDI; + Synth &synth = *m_synth; + + synth.m_musicMode = Synth::MODE_MIDI; m_setup.tick_skip_samples_delay = 0; - m_synth.m_runAtPcmRate = m_setup.runAtPcmRate; + synth.m_runAtPcmRate = m_setup.runAtPcmRate; - m_synth.m_scaleModulators = (m_setup.ScaleModulators != 0); + synth.m_scaleModulators = (m_setup.ScaleModulators != 0); if(m_setup.LogarithmicVolumes != 0) - m_synth.setVolumeScaleModel(OPNMIDI_VolumeModel_NativeOPN2); + synth.setVolumeScaleModel(OPNMIDI_VolumeModel_NativeOPN2); else - m_synth.setVolumeScaleModel(static_cast(m_setup.VolumeModel)); + synth.setVolumeScaleModel(static_cast(m_setup.VolumeModel)); if(m_setup.VolumeModel == OPNMIDI_VolumeModel_AUTO) - m_synth.m_volumeScale = (OPN2::VolumesScale)m_synth.m_insBankSetup.volumeModel; + synth.m_volumeScale = static_cast(synth.m_insBankSetup.volumeModel); - m_synth.m_numChips = m_setup.numChips; + synth.m_numChips = m_setup.numChips; if(m_setup.lfoEnable < 0) - m_synth.m_lfoEnable = (m_synth.m_insBankSetup.lfoEnable != 0); + synth.m_lfoEnable = (synth.m_insBankSetup.lfoEnable != 0); else - m_synth.m_lfoEnable = (m_setup.lfoEnable != 0); + synth.m_lfoEnable = (m_setup.lfoEnable != 0); if(m_setup.lfoFrequency < 0) - m_synth.m_lfoFrequency = m_synth.m_insBankSetup.lfoFrequency; + synth.m_lfoFrequency = static_cast(synth.m_insBankSetup.lfoFrequency); else - m_synth.m_lfoFrequency = m_setup.lfoFrequency; + synth.m_lfoFrequency = static_cast(m_setup.lfoFrequency); - m_synth.reset(m_setup.emulator, m_setup.PCM_RATE, this); - m_chipChannels.clear(); - m_chipChannels.resize(m_synth.m_numChannels, OpnChannel()); + int chipType; + if(m_setup.chipType < 0) + chipType = synth.m_insBankSetup.chipType; + else + chipType = m_setup.chipType; + synth.reset(m_setup.emulator, m_setup.PCM_RATE, static_cast(chipType), this); + m_chipChannels.clear(); + m_chipChannels.resize(synth.m_numChannels, OpnChannel()); + resetMIDIDefaults(); +#if defined(OPNMIDI_MIDI2VGM) && !defined(OPNMIDI_DISABLE_MIDI_SEQUENCER) + m_sequencerInterface->onloopStart = synth.m_loopStartHook; + m_sequencerInterface->onloopStart_userData = synth.m_loopStartHookData; + m_sequencerInterface->onloopEnd = synth.m_loopEndHook; + m_sequencerInterface->onloopEnd_userData = synth.m_loopEndHookData; + m_sequencer->setLoopHooksOnly(m_sequencerInterface->onloopStart != NULL); +#endif // Reset the arpeggio counter m_arpeggioCounter = 0; } void OPNMIDIplay::partialReset() { + Synth &synth = *m_synth; realTime_panic(); m_setup.tick_skip_samples_delay = 0; - m_synth.m_runAtPcmRate = m_setup.runAtPcmRate; - m_synth.reset(m_setup.emulator, m_setup.PCM_RATE, this); + synth.m_runAtPcmRate = m_setup.runAtPcmRate; + synth.reset(m_setup.emulator, m_setup.PCM_RATE, synth.chipFamily(), this); m_chipChannels.clear(); - m_chipChannels.resize(m_synth.m_numChannels); + m_chipChannels.resize(synth.m_numChannels); + resetMIDIDefaults(); +#if defined(OPNMIDI_MIDI2VGM) && !defined(OPNMIDI_DISABLE_MIDI_SEQUENCER) + m_sequencerInterface->onloopStart = synth.m_loopStartHook; + m_sequencerInterface->onloopStart_userData = synth.m_loopStartHookData; + m_sequencerInterface->onloopEnd = synth.m_loopEndHook; + m_sequencerInterface->onloopEnd_userData = synth.m_loopEndHookData; + m_sequencer->setLoopHooksOnly(m_sequencerInterface->onloopStart != NULL); +#endif } void OPNMIDIplay::resetMIDI() { - m_masterVolume = MasterVolumeDefault; + Synth &synth = *m_synth; + synth.m_masterVolume = MasterVolumeDefault; m_sysExDeviceId = 0; m_synthMode = Mode_XG; m_arpeggioCounter = 0; @@ -178,15 +190,70 @@ void OPNMIDIplay::resetMIDI() m_midiChannels.clear(); m_midiChannels.resize(16, MIDIchannel()); + resetMIDIDefaults(); + caugh_missing_instruments.clear(); caugh_missing_banks_melodic.clear(); caugh_missing_banks_percussion.clear(); } +void OPNMIDIplay::resetMIDIDefaults(int offset) +{ + Synth &synth = *m_synth; + + for(size_t c = offset, n = m_midiChannels.size(); c < n; ++c) + { + MIDIchannel &ch = m_midiChannels[c]; + if(synth.m_musicMode == Synth::MODE_XMIDI) + { + ch.def_volume = 127; + ch.def_bendsense_lsb = 0; + ch.def_bendsense_msb = 12; + } + else + if(synth.m_musicMode == Synth::MODE_RSXX) + ch.def_volume = 127; + } +} + void OPNMIDIplay::TickIterators(double s) { - for(uint16_t c = 0; c < m_synth.m_numChannels; ++c) - m_chipChannels[c].addAge(static_cast(s * 1e6)); + Synth &synth = *m_synth; + for(uint32_t c = 0, n = synth.m_numChannels; c < n; ++c) + { + OpnChannel &ch = m_chipChannels[c]; + ch.addAge(static_cast(s * 1e6)); + } + + // Resolve "hell of all times" of too short drum notes + for(size_t c = 0, n = m_midiChannels.size(); c < n; ++c) + { + MIDIchannel &ch = m_midiChannels[c]; + if(ch.extended_note_count == 0) + continue; + + for(MIDIchannel::notes_iterator inext = ch.activenotes.begin(); !inext.is_end();) + { + MIDIchannel::notes_iterator i(inext++); + MIDIchannel::NoteInfo &ni = i->value; + + double ttl = ni.ttl; + if(ttl <= 0) + continue; + + ni.ttl = ttl = ttl - s; + if(ttl <= 0) + { + --ch.extended_note_count; + if(ni.isOnExtendedLifeTime) + { + noteUpdate(c, i, Upd_Off); + ni.isOnExtendedLifeTime = false; + } + } + } + } + updateVibrato(s); updateArpeggio(s); #if !defined(ADLMIDI_AUDIO_TICK_HANDLER) @@ -196,11 +263,11 @@ void OPNMIDIplay::TickIterators(double s) void OPNMIDIplay::realTime_ResetState() { + Synth &synth = *m_synth; for(size_t ch = 0; ch < m_midiChannels.size(); ch++) { MIDIchannel &chan = m_midiChannels[ch]; chan.resetAllControllers(); - chan.volume = (m_synth.m_musicMode == OPN2::MODE_RSXX) ? 127 : 100; chan.vibpos = 0.0; chan.lastlrpn = 0; chan.lastmrpn = 0; @@ -210,23 +277,26 @@ void OPNMIDIplay::realTime_ResetState() noteUpdateAll(uint16_t(ch), Upd_All); noteUpdateAll(uint16_t(ch), Upd_Off); } - m_masterVolume = MasterVolumeDefault; + synth.m_masterVolume = MasterVolumeDefault; } bool OPNMIDIplay::realTime_NoteOn(uint8_t channel, uint8_t note, uint8_t velocity) { + Synth &synth = *m_synth; + if(note >= 127) note = 127; - if((m_synth.m_musicMode == OPN2::MODE_RSXX) && (velocity != 0)) + if((synth.m_musicMode == Synth::MODE_RSXX) && (velocity != 0)) { // Check if this is just a note after-touch - MIDIchannel::activenoteiterator i = m_midiChannels[channel].activenotes_find(note); - if(i) + MIDIchannel::notes_iterator i = m_midiChannels[channel].find_activenote(note); + if(!i.is_end()) { - const int veloffset = i->ains->midi_velocity_offset; - velocity = (uint8_t)std::min(127, std::max(1, (int)velocity + veloffset)); - i->vol = velocity; + MIDIchannel::NoteInfo &ni = i->value; + const int veloffset = ni.ains->midiVelocityOffset; + velocity = static_cast(std::min(127, std::max(1, static_cast(velocity) + veloffset))); + ni.vol = velocity; noteUpdate(channel, i, Upd_Volume); return false; } @@ -234,7 +304,7 @@ bool OPNMIDIplay::realTime_NoteOn(uint8_t channel, uint8_t note, uint8_t velocit if(static_cast(channel) > m_midiChannels.size()) channel = channel % 16; - noteOff(channel, note); + noteOff(channel, note, velocity != 0); // On Note on, Keyoff the note first, just in case keyoff // was omitted; this fixes Dance of sugar-plum fairy // by Microsoft. Now that we've done a Keyoff, @@ -280,16 +350,16 @@ bool OPNMIDIplay::realTime_NoteOn(uint8_t channel, uint8_t note, uint8_t velocit } if(isPercussion) - bank += OPN2::PercussionTag; + bank += Synth::PercussionTag; - const opnInstMeta2 *ains = &OPN2::m_emptyInstrument; + const OpnInstMeta *ains = &Synth::m_emptyInstrument; //Set bank bank - const OPN2::Bank *bnk = NULL; - if((bank & ~(uint16_t)OPN2::PercussionTag) > 0) + const Synth::Bank *bnk = NULL; + if((bank & static_cast(~static_cast(Synth::PercussionTag))) > 0) { - OPN2::BankMap::iterator b = m_synth.m_insBanks.find(bank); - if(b != m_synth.m_insBanks.end()) + Synth::BankMap::iterator b = synth.m_insBanks.find(bank); + if(b != synth.m_insBanks.end()) bnk = &b->second; if(bnk) @@ -305,23 +375,23 @@ bool OPNMIDIplay::realTime_NoteOn(uint8_t channel, uint8_t note, uint8_t velocit } } //Or fall back to first bank - if(ains->flags & opnInstMeta::Flag_NoSound) + if(ains->flags & OpnInstMeta::Flag_NoSound) { - OPN2::BankMap::iterator b = m_synth.m_insBanks.find(bank & OPN2::PercussionTag); - if(b != m_synth.m_insBanks.end()) + Synth::BankMap::iterator b = synth.m_insBanks.find(bank & Synth::PercussionTag); + if(b != synth.m_insBanks.end()) bnk = &b->second; if(bnk) ains = &bnk->ins[midiins]; } - const int veloffset = ains->midi_velocity_offset; - velocity = (uint8_t)std::min(127, std::max(1, (int)velocity + veloffset)); + const int veloffset = ains->midiVelocityOffset; + velocity = static_cast(std::min(127, std::max(1, static_cast(velocity) + veloffset))); int32_t tone = note; if(!isPercussion && (bank > 0)) // For non-zero banks { - if(ains->flags & opnInstMeta::Flag_NoSound) + if(ains->flags & OpnInstMeta::Flag_NoSound) { if(hooks.onDebugMessage) { @@ -336,25 +406,25 @@ bool OPNMIDIplay::realTime_NoteOn(uint8_t channel, uint8_t note, uint8_t velocit } } - if(ains->tone) + if(ains->drumTone) { /*if(ains.tone < 20) tone += ains.tone; else*/ - if(ains->tone < 128) - tone = ains->tone; + if(ains->drumTone < 128) + tone = ains->drumTone; else - tone -= ains->tone - 128; + tone -= ains->drumTone - 128; } MIDIchannel::NoteInfo::Phys voices[MIDIchannel::NoteInfo::MaxNumPhysChans] = { - {0, ains->opn[0], /*false*/}, - {0, ains->opn[1], /*pseudo_4op*/}, + {0, ains->op[0], /*false*/}, + {0, ains->op[1], /*pseudo_4op*/}, }; //bool pseudo_4op = ains.flags & opnInstMeta::Flag_Pseudo8op; //if((opn.AdlPercussionMode == 1) && PercussionMap[midiins & 0xFF]) i[1] = i[0]; - bool isBlankNote = (ains->flags & opnInstMeta::Flag_NoSound) != 0; + bool isBlankNote = (ains->flags & OpnInstMeta::Flag_NoSound) != 0; if(hooks.onDebugMessage) { @@ -368,11 +438,13 @@ bool OPNMIDIplay::realTime_NoteOn(uint8_t channel, uint8_t note, uint8_t velocit if(isBlankNote) { // Don't even try to play the blank instrument! But, insert the dummy note. - std::pair - dummy = midiChan.activenotes_insert(note); - dummy.first->isBlank = true; - dummy.first->ains = NULL; - dummy.first->chip_channels_count = 0; + MIDIchannel::notes_iterator i = midiChan.ensure_find_or_create_activenote(note); + MIDIchannel::NoteInfo &dummy = i->value; + dummy.isBlank = true; + dummy.isOnExtendedLifeTime = false; + dummy.ttl = 0; + dummy.ains = NULL; + dummy.chip_channels_count = 0; // Record the last note on MIDI channel as source of portamento midiChan.portamentoSource = static_cast(note); return false; @@ -394,7 +466,7 @@ bool OPNMIDIplay::realTime_NoteOn(uint8_t channel, uint8_t note, uint8_t velocit int32_t c = -1; int32_t bs = -0x7FFFFFFFl; - for(size_t a = 0; a < (size_t)m_synth.m_numChannels; ++a) + for(size_t a = 0; a < static_cast(synth.m_numChannels); ++a) { if(ccount == 1 && static_cast(a) == adlchannel[0]) continue; // ^ Don't use the same channel for primary&secondary @@ -416,7 +488,7 @@ bool OPNMIDIplay::realTime_NoteOn(uint8_t channel, uint8_t note, uint8_t velocit int64_t s = calculateChipChannelGoodness(a, voices[ccount]); if(s > bs) { - bs = (int32_t)s; // Best candidate wins + bs = static_cast(s); // Best candidate wins c = static_cast(a); } } @@ -447,18 +519,20 @@ bool OPNMIDIplay::realTime_NoteOn(uint8_t channel, uint8_t note, uint8_t velocit velocity = static_cast(std::floor(static_cast(velocity) * 0.8f)); // Allocate active note for MIDI channel - std::pair - ir = midiChan.activenotes_insert(note); - ir.first->vol = velocity; - ir.first->vibrato = midiChan.noteAftertouch[note]; - ir.first->noteTone = static_cast(tone); - ir.first->currentTone = tone; - ir.first->glideRate = HUGE_VAL; - ir.first->midiins = midiins; - ir.first->isPercussion = isPercussion; - ir.first->isBlank = isBlankNote; - ir.first->ains = ains; - ir.first->chip_channels_count = 0; + MIDIchannel::notes_iterator ir = midiChan.ensure_find_or_create_activenote(note); + MIDIchannel::NoteInfo &ni = ir->value; + ni.vol = velocity; + ni.vibrato = midiChan.noteAftertouch[note]; + ni.noteTone = static_cast(tone); + ni.currentTone = tone; + ni.glideRate = HUGE_VAL; + ni.midiins = midiins; + ni.isPercussion = isPercussion; + ni.isBlank = isBlankNote; + ni.isOnExtendedLifeTime = false; + ni.ttl = 0; + ni.ains = ains; + ni.chip_channels_count = 0; int8_t currentPortamentoSource = midiChan.portamentoSource; double currentPortamentoRate = midiChan.portamentoRate; @@ -471,21 +545,28 @@ bool OPNMIDIplay::realTime_NoteOn(uint8_t channel, uint8_t note, uint8_t velocit // Enable gliding on portamento note if (portamentoEnable && currentPortamentoSource >= 0) { - ir.first->currentTone = currentPortamentoSource; - ir.first->glideRate = currentPortamentoRate; + ni.currentTone = currentPortamentoSource; + ni.glideRate = currentPortamentoRate; ++midiChan.gliding_note_count; } + // Enable life time extension on percussion note + if (isPercussion) + { + ni.ttl = drum_note_min_time; + ++midiChan.extended_note_count; + } + for(unsigned ccount = 0; ccount < MIDIchannel::NoteInfo::MaxNumPhysChans; ++ccount) { int32_t c = adlchannel[ccount]; if(c < 0) continue; uint16_t chipChan = static_cast(adlchannel[ccount]); - ir.first->phys_ensure_find_or_create(chipChan)->assign(voices[ccount]); + ni.phys_ensure_find_or_create(chipChan)->assign(voices[ccount]); } - noteUpdate(channel, ir.first, Upd_All | Upd_Patch); + noteUpdate(channel, ir, Upd_All | Upd_Patch); for(unsigned ccount = 0; ccount < MIDIchannel::NoteInfo::MaxNumPhysChans; ++ccount) { @@ -511,10 +592,10 @@ void OPNMIDIplay::realTime_NoteAfterTouch(uint8_t channel, uint8_t note, uint8_t if(static_cast(channel) > m_midiChannels.size()) channel = channel % 16; MIDIchannel &chan = m_midiChannels[channel]; - MIDIchannel::activenoteiterator i = m_midiChannels[channel].activenotes_find(note); - if(i) + MIDIchannel::notes_iterator i = m_midiChannels[channel].find_activenote(note); + if(!i.is_end()) { - i->vibrato = atVal; + i->value.vibrato = atVal; } uint8_t oldAtVal = chan.noteAftertouch[note % 128]; @@ -611,7 +692,7 @@ void OPNMIDIplay::realTime_Controller(uint8_t channel, uint8_t type, uint8_t val break; case 121: // Reset all controllers - m_midiChannels[channel].resetAllControllers(); + m_midiChannels[channel].resetAllControllers121(); noteUpdateAll(channel, Upd_Pan + Upd_Volume + Upd_Pitch); // Kill all sustained notes killSustainingNotes(channel, -1, OpnChannel::LocationData::Sustain_ANY); @@ -790,7 +871,8 @@ bool OPNMIDIplay::doUniversalSysEx(unsigned dev, bool realtime, const uint8_t *d unsigned volume = (((unsigned)data[0] & 0x7F)) | (((unsigned)data[1] & 0x7F) << 7); - m_masterVolume = static_cast(volume >> 7); + if(m_synth.get()) + m_synth->m_masterVolume = static_cast(volume >> 7); for(size_t ch = 0; ch < m_midiChannels.size(); ch++) noteUpdateAll(uint16_t(ch), Upd_Volume); return true; @@ -858,10 +940,10 @@ bool OPNMIDIplay::doRolandSysEx(unsigned dev, const uint8_t *data, size_t size) { if(size != 1 || (dev & 0xF0) != 0x10) break; - unsigned mode = data[0] & 0x7F; - ADL_UNUSED(mode);//TODO: Hook this correctly! + unsigned gs_mode = data[0] & 0x7F; + ADL_UNUSED(gs_mode);//TODO: Hook this correctly! if(hooks.onDebugMessage) - hooks.onDebugMessage(hooks.onDebugMessage_userData, "SysEx: Caught Roland System Mode Set: %02X", mode); + hooks.onDebugMessage(hooks.onDebugMessage_userData, "SysEx: Caught Roland System Mode Set: %02X", gs_mode); m_synthMode = Mode_GS; realTime_ResetState(); return true; @@ -985,16 +1067,17 @@ void OPNMIDIplay::AudioTick(uint32_t chipId, uint32_t rate) #endif void OPNMIDIplay::noteUpdate(size_t midCh, - OPNMIDIplay::MIDIchannel::activenoteiterator i, + OPNMIDIplay::MIDIchannel::notes_iterator i, unsigned props_mask, int32_t select_adlchn) { - MIDIchannel::NoteInfo &info = *i; + Synth &synth = *m_synth; + MIDIchannel::NoteInfo &info = i->value; const int16_t noteTone = info.noteTone; const double currentTone = info.currentTone; const uint8_t vol = info.vol; const size_t midiins = info.midiins; - const opnInstMeta2 &ains = *info.ains; + const OpnInstMeta &ains = *info.ains; OpnChannel::Location my_loc; my_loc.MidCh = static_cast(midCh); my_loc.note = info.note; @@ -1002,7 +1085,7 @@ void OPNMIDIplay::noteUpdate(size_t midCh, if(info.isBlank) { if(props_mask & Upd_Off) - m_midiChannels[midCh].activenotes_erase(i); + m_midiChannels[midCh].activenotes.erase(i); return; } @@ -1015,14 +1098,16 @@ void OPNMIDIplay::noteUpdate(size_t midCh, if(props_mask & Upd_Patch) { - m_synth.setPatch(c, ins.ains); - OpnChannel::LocationData *d = m_chipChannels[c].users_find_or_create(my_loc); - if(d) { // inserts if necessary - d->sustained = OpnChannel::LocationData::Sustain_None; - d->vibdelay_us = 0; - d->fixed_sustain = (ains.ms_sound_kon == static_cast(opnNoteOnMaxTime)); - d->kon_time_until_neglible_us = 1000 * ains.ms_sound_kon; - d->ins = ins; + synth.setPatch(c, ins.ains); + OpnChannel::users_iterator ci = m_chipChannels[c].find_or_create_user(my_loc); + if(!ci.is_end()) // inserts if necessary + { + OpnChannel::LocationData &d = ci->value; + d.sustained = OpnChannel::LocationData::Sustain_None; + d.vibdelay_us = 0; + d.fixed_sustain = (ains.soundKeyOnMs == static_cast(opnNoteOnMaxTime)); + d.kon_time_until_neglible_us = 1000 * ains.soundKeyOnMs; + d.ins = ins; } } } @@ -1039,25 +1124,25 @@ void OPNMIDIplay::noteUpdate(size_t midCh, { if(m_midiChannels[midCh].sustain == 0) { - OpnChannel::LocationData *k = m_chipChannels[c].users_find(my_loc); - bool do_erase_user = (k && ((k->sustained & OpnChannel::LocationData::Sustain_Sostenuto) == 0)); + OpnChannel::users_iterator k = m_chipChannels[c].find_user(my_loc); + bool do_erase_user = (!k.is_end() && ((k->value.sustained & OpnChannel::LocationData::Sustain_Sostenuto) == 0)); if(do_erase_user) - m_chipChannels[c].users_erase(k); + m_chipChannels[c].users.erase(k); if(hooks.onNote) - hooks.onNote(hooks.onNote_userData, c, noteTone, (int)midiins, 0, 0.0); + hooks.onNote(hooks.onNote_userData, c, noteTone, static_cast(midiins), 0, 0.0); - if(do_erase_user && m_chipChannels[c].users_empty()) + if(do_erase_user && m_chipChannels[c].users.empty()) { - m_synth.noteOff(c); + synth.noteOff(c); if(props_mask & Upd_Mute) // Mute the note { - m_synth.touchNote(c, 0); + synth.touchNote(c, 0); m_chipChannels[c].koff_time_until_neglible_us = 0; } else { - m_chipChannels[c].koff_time_until_neglible_us = 1000 * int64_t(ains.ms_sound_koff); + m_chipChannels[c].koff_time_until_neglible_us = 1000 * int64_t(ains.soundKeyOffMs); } } } @@ -1065,11 +1150,11 @@ void OPNMIDIplay::noteUpdate(size_t midCh, { // Sustain: Forget about the note, but don't key it off. // Also will avoid overwriting it very soon. - OpnChannel::LocationData *d = m_chipChannels[c].users_find_or_create(my_loc); - if(d) - d->sustained |= OpnChannel::LocationData::Sustain_Pedal; // note: not erased! + OpnChannel::users_iterator d = m_chipChannels[c].find_or_create_user(my_loc); + if(!d.is_end()) + d->value.sustained |= OpnChannel::LocationData::Sustain_Pedal; // note: not erased! if(hooks.onNote) - hooks.onNote(hooks.onNote_userData, c, noteTone, (int)midiins, -1, 0.0); + hooks.onNote(hooks.onNote_userData, c, noteTone, static_cast(midiins), -1, 0.0); } info.phys_erase_at(&ins); // decrements channel count @@ -1078,13 +1163,13 @@ void OPNMIDIplay::noteUpdate(size_t midCh, } if(props_mask & Upd_Pan) - m_synth.setPan(c, m_midiChannels[midCh].panning); + synth.setPan(c, m_midiChannels[midCh].panning); if(props_mask & Upd_Volume) { - uint_fast32_t volume; - bool is_percussion = (midCh == 9) || m_midiChannels[midCh].is_xg_percussion; - uint_fast32_t brightness = is_percussion ? 127 : m_midiChannels[midCh].brightness; + const MIDIchannel &ch = m_midiChannels[midCh]; + bool is_percussion = (midCh == 9) || ch.is_xg_percussion; + uint_fast32_t brightness = is_percussion ? 127 : ch.brightness; if(!m_setup.fullRangeBrightnessCC74) { @@ -1095,127 +1180,57 @@ void OPNMIDIplay::noteUpdate(size_t midCh, brightness *= 2; } - switch(m_synth.m_volumeScale) - { - default: - case OPN2::VOLUME_Generic: - { - volume = vol * m_masterVolume * m_midiChannels[midCh].volume * m_midiChannels[midCh].expression; - /* If the channel has arpeggio, the effective volume of - * *this* instrument is actually lower due to timesharing. - * To compensate, add extra volume that corresponds to the - * time this note is *not* heard. - * Empirical tests however show that a full equal-proportion - * increment sounds wrong. Therefore, using the square root. - */ - //volume = (int)(volume * std::sqrt( (double) ch[c].users.size() )); - - // The formula below: SOLVE(V=127^3 * 2^( (A-63.49999) / 8), A) - volume = volume > (8725 * 127) ? static_cast((std::log(static_cast(volume)) * 11.541560327111707 - 1.601379199767093e+02) * 2.0) : 0; - // The incorrect formula below: SOLVE(V=127^3 * (2^(A/63)-1), A) - //opl.Touch_Real(c, volume>11210 ? 91.61112 * std::log(4.8819E-7*volume + 1.0)+0.5 : 0); - } - break; - - case OPN2::VOLUME_NATIVE: - { - volume = vol * m_midiChannels[midCh].volume * m_midiChannels[midCh].expression; - //volume = volume * m_masterVolume / (127 * 127 * 127) / 2; - volume = (volume * m_masterVolume) / 4096766; - } - break; - - case OPN2::VOLUME_DMX: - { - volume = 2 * (m_midiChannels[midCh].volume * m_midiChannels[midCh].expression * m_masterVolume / 16129) + 1; - //volume = 2 * (Ch[MidCh].volume) + 1; - volume = (DMX_volume_mapping_table[(vol < 128) ? vol : 127] * volume) >> 9; - if(volume > 0) - volume += 64;//OPN has 0~127 range. As 0...63 is almost full silence, but at 64 to 127 is very closed to OPL3, just add 64. - } - break; - - case OPN2::VOLUME_APOGEE: - { - volume = (m_midiChannels[midCh].volume * m_midiChannels[midCh].expression * m_masterVolume / 16129); - volume = ((64 * (vol + 0x80)) * volume) >> 15; - //volume = ((63 * (vol + 0x80)) * Ch[MidCh].volume) >> 15; - if(volume > 0) - volume += 64;//OPN has 0~127 range. As 0...63 is almost full silence, but at 64 to 127 is very closed to OPL3, just add 64. - } - break; - - case OPN2::VOLUME_9X: - { - //volume = 63 - W9X_volume_mapping_table[(((vol * Ch[MidCh].volume /** Ch[MidCh].expression*/) * 127 / 16129 /*2048383*/) >> 2)]; - volume = 63 - W9X_volume_mapping_table[((vol * m_midiChannels[midCh].volume * m_midiChannels[midCh].expression * m_masterVolume / 2048383) >> 2)]; - //volume = W9X_volume_mapping_table[vol >> 2] + volume; - if(volume > 0) - volume += 64;//OPN has 0~127 range. As 0...63 is almost full silence, but at 64 to 127 is very closed to OPL3, just add 64. - } - break; - } - - m_synth.touchNote(c, static_cast(volume), static_cast(brightness)); - - /* DEBUG ONLY!!! - static uint32_t max = 0; - - if(volume == 0) - max = 0; - - if(volume > max) - max = volume; - - printf("%d\n", max); - fflush(stdout); - */ + synth.touchNote(c, + vol, + ch.volume, + ch.expression, + static_cast(brightness)); } if(props_mask & Upd_Pitch) { - OpnChannel::LocationData *d = m_chipChannels[c].users_find(my_loc); + OpnChannel::users_iterator d = m_chipChannels[c].find_user(my_loc); // Don't bend a sustained note - if(!d || (d->sustained == OpnChannel::LocationData::Sustain_None)) + if(d.is_end() || (d->value.sustained == OpnChannel::LocationData::Sustain_None)) { - double midibend = m_midiChannels[midCh].bend * m_midiChannels[midCh].bendsense; - double bend = midibend + ins.ains.finetune; + MIDIchannel &chan = m_midiChannels[midCh]; + double midibend = chan.bend * chan.bendsense; + double bend = midibend + ins.ains.noteOffset; double phase = 0.0; - uint8_t vibrato = std::max(m_midiChannels[midCh].vibrato, m_midiChannels[midCh].aftertouch); - vibrato = std::max(vibrato, i->vibrato); + uint8_t vibrato = std::max(chan.vibrato, chan.aftertouch); + + vibrato = std::max(vibrato, info.vibrato); - if((ains.flags & opnInstMeta::Flag_Pseudo8op) && ins.ains == ains.opn[1]) + if((ains.flags & OpnInstMeta::Flag_Pseudo8op) && ins.ains == ains.op[1]) { - phase = ains.fine_tune;//0.125; // Detune the note slightly (this is what Doom does) + phase = ains.voice2_fine_tune; } - if(vibrato && (!d || d->vibdelay_us >= m_midiChannels[midCh].vibdelay_us)) - bend += static_cast(vibrato) * m_midiChannels[midCh].vibdepth * std::sin(m_midiChannels[midCh].vibpos); + if(vibrato && (d.is_end() || d->value.vibdelay_us >= chan.vibdelay_us)) + bend += static_cast(vibrato) * chan.vibdepth * std::sin(chan.vibpos); + + synth.noteOn(c, currentTone + bend + phase); -#define BEND_COEFFICIENT 321.88557 - m_synth.noteOn(c, BEND_COEFFICIENT * std::exp(0.057762265 * (currentTone + bend + phase))); -#undef BEND_COEFFICIENT if(hooks.onNote) - hooks.onNote(hooks.onNote_userData, c, noteTone, (int)midiins, vol, midibend); + hooks.onNote(hooks.onNote_userData, c, noteTone, static_cast(midiins), vol, midibend); } } } if(info.chip_channels_count == 0) { - if(i->glideRate != HUGE_VAL) - --m_midiChannels[midCh].gliding_note_count; - m_midiChannels[midCh].activenotes_erase(i); + m_midiChannels[midCh].cleanupNote(i); + m_midiChannels[midCh].activenotes.erase(i); } } void OPNMIDIplay::noteUpdateAll(size_t midCh, unsigned props_mask) { - for(MIDIchannel::activenoteiterator - i = m_midiChannels[midCh].activenotes_begin(); i;) + for(MIDIchannel::notes_iterator + i = m_midiChannels[midCh].activenotes.begin(); !i.is_end();) { - MIDIchannel::activenoteiterator j(i++); + MIDIchannel::notes_iterator j(i++); noteUpdate(midCh, j, props_mask); } } @@ -1232,46 +1247,49 @@ void OPNMIDIplay::setErrorString(const std::string &err) int64_t OPNMIDIplay::calculateChipChannelGoodness(size_t c, const MIDIchannel::NoteInfo::Phys &ins) const { + Synth &synth = *m_synth; const OpnChannel &chan = m_chipChannels[c]; int64_t koff_ms = chan.koff_time_until_neglible_us / 1000; int64_t s = -koff_ms; // Rate channel with a releasing note - if(s < 0 && chan.users_empty()) + if(s < 0 && chan.users.empty()) { s -= 40000; // If it's same instrument, better chance to get it when no free channels if(chan.recent_ins == ins) - s = (m_synth.m_musicMode == OPN2::MODE_CMF) ? 0 : -koff_ms; + s = (synth.m_musicMode == Synth::MODE_CMF) ? 0 : -koff_ms; return s; } // Same midi-instrument = some stability - for(OpnChannel::LocationData *j = chan.users_first; j; j = j->next) + for(OpnChannel::const_users_iterator j = chan.users.begin(); !j.is_end(); ++j) { - s -= 4000000; + const OpnChannel::LocationData &jd = j->value; - int64_t kon_ms = j->kon_time_until_neglible_us / 1000; - s -= (j->sustained == OpnChannel::LocationData::Sustain_None) ? - kon_ms : (kon_ms / 2); + int64_t kon_ms = jd.kon_time_until_neglible_us / 1000; + s -= (jd.sustained == OpnChannel::LocationData::Sustain_None) ? + (4000000 + kon_ms) : (500000 + (kon_ms / 2)); - MIDIchannel::activenoteiterator - k = const_cast(m_midiChannels[j->loc.MidCh]).activenotes_find(j->loc.note); + MIDIchannel::notes_iterator + k = const_cast(m_midiChannels[jd.loc.MidCh]).find_activenote(jd.loc.note); - if(k) + if(!k.is_end()) { + const MIDIchannel::NoteInfo &info = k->value; + // Same instrument = good - if(j->ins == ins) + if(jd.ins == ins) { s += 300; // Arpeggio candidate = even better - if(j->vibdelay_us < 70000 - || j->kon_time_until_neglible_us > 20000000) + if(jd.vibdelay_us < 70000 + || jd.kon_time_until_neglible_us > 20000000) s += 10; } // Percussion is inferior to melody - s += k->isPercussion ? 50 : 0; + s += info.isPercussion ? 50 : 0; } // If there is another channel to which this note @@ -1286,11 +1304,12 @@ int64_t OPNMIDIplay::calculateChipChannelGoodness(size_t c, const MIDIchannel::N // if(opn.four_op_category[c2] // != opn.four_op_category[c]) continue; -// for(OpnChannel::LocationData *m = ch[c2].users_first; m; m = m->next) +// for(AdlChannel::const_users_iterator m = m_chipChannels[c2].users.begin(); !m.is_end(); ++m) // { -// if(m->sustained != OpnChannel::LocationData::Sustain_None) continue; -// if(m->vibdelay >= 200000) continue; -// if(m->ins != j->second.ins) continue; +// const AdlChannel::LocationData &md = m->value; +// if(md.sustained != OpnChannel::LocationData::Sustain_None) continue; +// if(md.vibdelay >= 200000) continue; +// if(md.ins != jd.ins) continue; // n_evacuation_stations += 1; // } // } @@ -1304,25 +1323,28 @@ int64_t OPNMIDIplay::calculateChipChannelGoodness(size_t c, const MIDIchannel::N void OPNMIDIplay::prepareChipChannelForNewNote(size_t c, const MIDIchannel::NoteInfo::Phys &ins) { - if(m_chipChannels[c].users_empty()) return; // Nothing to do + if(m_chipChannels[c].users.empty()) return; // Nothing to do + + Synth &synth = *m_synth; //bool doing_arpeggio = false; - for(OpnChannel::LocationData *jnext = m_chipChannels[c].users_first; jnext;) + for(OpnChannel::users_iterator jnext = m_chipChannels[c].users.begin(); !jnext.is_end();) { - OpnChannel::LocationData *j = jnext; - jnext = jnext->next; + OpnChannel::users_iterator j = jnext; + OpnChannel::LocationData &jd = jnext->value; + ++jnext; - if(!j->sustained) + if(jd.sustained == OpnChannel::LocationData::Sustain_None) { // Collision: Kill old note, // UNLESS we're going to do arpeggio - MIDIchannel::activenoteiterator i - (m_midiChannels[j->loc.MidCh].activenotes_ensure_find(j->loc.note)); + MIDIchannel::notes_iterator i + (m_midiChannels[jd.loc.MidCh].ensure_find_activenote(jd.loc.note)); // Check if we can do arpeggio. - if((j->vibdelay_us < 70000 - || j->kon_time_until_neglible_us > 20000000) - && j->ins == ins) + if((jd.vibdelay_us < 70000 + || jd.kon_time_until_neglible_us > 20000000) + && jd.ins == ins) { // Do arpeggio together with this note. //doing_arpeggio = true; @@ -1341,22 +1363,25 @@ void OPNMIDIplay::prepareChipChannelForNewNote(size_t c, const MIDIchannel::Note // Keyoff the channel so that it can be retriggered, // unless the new note will be introduced as just an arpeggio. - if(m_chipChannels[c].users_empty()) - m_synth.noteOff(c); + if(m_chipChannels[c].users.empty()) + synth.noteOff(c); } void OPNMIDIplay::killOrEvacuate(size_t from_channel, - OpnChannel::LocationData *j, - OPNMIDIplay::MIDIchannel::activenoteiterator i) + OpnChannel::users_iterator j, + OPNMIDIplay::MIDIchannel::notes_iterator i) { + Synth &synth = *m_synth; uint32_t maxChannels = OPN_MAX_CHIPS * 6; + OpnChannel::LocationData &jd = j->value; + MIDIchannel::NoteInfo &info = i->value; // Before killing the note, check if it can be // evacuated to another channel as an arpeggio // instrument. This helps if e.g. all channels // are full of strings and we want to do percussion. // FIXME: This does not care about four-op entanglements. - for(uint32_t c = 0; c < m_synth.m_numChannels; ++c) + for(uint32_t c = 0; c < synth.m_numChannels; ++c) { uint16_t cs = static_cast(c); @@ -1368,33 +1393,38 @@ void OPNMIDIplay::killOrEvacuate(size_t from_channel, // continue; OpnChannel &adlch = m_chipChannels[c]; - if(adlch.users_size == OpnChannel::users_max) + if(adlch.users.size() == adlch.users.capacity()) continue; // no room for more arpeggio on channel - for(OpnChannel::LocationData *m = adlch.users_first; m; m = m->next) + if(!m_chipChannels[cs].find_user(jd.loc).is_end()) + continue; // channel already has this note playing (sustained) + // avoid introducing a duplicate location. + + for(OpnChannel::users_iterator m = adlch.users.begin(); !m.is_end(); ++m) { - if(m->vibdelay_us >= 200000 - && m->kon_time_until_neglible_us < 10000000) continue; - if(m->ins != j->ins) + OpnChannel::LocationData &mv = m->value; + + if(mv.vibdelay_us >= 200000 + && mv.kon_time_until_neglible_us < 10000000) continue; + if(mv.ins != jd.ins) continue; if(hooks.onNote) { hooks.onNote(hooks.onNote_userData, - (int)from_channel, - i->noteTone, - (int)i->midiins, 0, 0.0); + static_cast(from_channel), + info.noteTone, + static_cast(info.midiins), 0, 0.0); hooks.onNote(hooks.onNote_userData, - (int)c, - i->noteTone, - (int)i->midiins, - i->vol, 0.0); + static_cast(c), + info.noteTone, + static_cast(info.midiins), + info.vol, 0.0); } - i->phys_erase(static_cast(from_channel)); - i->phys_ensure_find_or_create(cs)->assign(j->ins); - if(!m_chipChannels[cs].users_insert(*j)) - assert(false); - m_chipChannels[from_channel].users_erase(j); + info.phys_erase(static_cast(from_channel)); + info.phys_ensure_find_or_create(cs)->assign(jd.ins); + m_chipChannels[cs].users.push_back(jd); + m_chipChannels[from_channel].users.erase(j); return; } } @@ -1407,7 +1437,7 @@ void OPNMIDIplay::killOrEvacuate(size_t from_channel, ins );*/ // Kill it - noteUpdate(j->loc.MidCh, + noteUpdate(jd.loc.MidCh, i, Upd_Off, static_cast(from_channel)); @@ -1424,7 +1454,8 @@ void OPNMIDIplay::panic() void OPNMIDIplay::killSustainingNotes(int32_t midCh, int32_t this_adlchn, uint32_t sustain_type) { - uint32_t first = 0, last = m_synth.m_numChannels; + Synth &synth = *m_synth; + uint32_t first = 0, last = synth.m_numChannels; if(this_adlchn >= 0) { @@ -1434,46 +1465,49 @@ void OPNMIDIplay::killSustainingNotes(int32_t midCh, int32_t this_adlchn, uint32 for(uint32_t c = first; c < last; ++c) { - if(m_chipChannels[c].users_empty()) + if(m_chipChannels[c].users.empty()) continue; // Nothing to do - for(OpnChannel::LocationData *jnext = m_chipChannels[c].users_first; jnext;) + for(OpnChannel::users_iterator jnext = m_chipChannels[c].users.begin(); !jnext.is_end();) { - OpnChannel::LocationData *j = jnext; - jnext = jnext->next; + OpnChannel::users_iterator j = jnext; + OpnChannel::LocationData &jd = j->value; + ++jnext; - if((midCh < 0 || j->loc.MidCh == midCh) - && ((j->sustained & sustain_type) != 0)) + if((midCh < 0 || jd.loc.MidCh == midCh) + && ((jd.sustained & sustain_type) != 0)) { int midiins = '?'; if(hooks.onNote) - hooks.onNote(hooks.onNote_userData, (int)c, j->loc.note, midiins, 0, 0.0); - j->sustained &= ~sustain_type; - if(j->sustained == OpnChannel::LocationData::Sustain_None) - m_chipChannels[c].users_erase(j);//Remove only when note is clean from any holders + hooks.onNote(hooks.onNote_userData, static_cast(c), jd.loc.note, midiins, 0, 0.0); + jd.sustained &= ~sustain_type; + if(jd.sustained == OpnChannel::LocationData::Sustain_None) + m_chipChannels[c].users.erase(j);//Remove only when note is clean from any holders } } // Keyoff the channel, if there are no users left. - if(m_chipChannels[c].users_empty()) - m_synth.noteOff(c); + if(m_chipChannels[c].users.empty()) + synth.noteOff(c); } } void OPNMIDIplay::markSostenutoNotes(int32_t midCh) { - uint32_t first = 0, last = m_synth.m_numChannels; + Synth &synth = *m_synth; + uint32_t first = 0, last = synth.m_numChannels; for(uint32_t c = first; c < last; ++c) { - if(m_chipChannels[c].users_empty()) + if(m_chipChannels[c].users.empty()) continue; // Nothing to do - for(OpnChannel::LocationData *jnext = m_chipChannels[c].users_first; jnext;) + for(OpnChannel::users_iterator jnext = m_chipChannels[c].users.begin(); !jnext.is_end();) { - OpnChannel::LocationData *j = jnext; - jnext = jnext->next; - if((j->loc.MidCh == midCh) && (j->sustained == OpnChannel::LocationData::Sustain_None)) - j->sustained |= OpnChannel::LocationData::Sustain_Sostenuto; + OpnChannel::users_iterator j = jnext; + OpnChannel::LocationData &jd = j->value; + ++jnext; + if((jd.loc.MidCh == midCh) && (jd.sustained == OpnChannel::LocationData::Sustain_None)) + jd.sustained |= OpnChannel::LocationData::Sustain_Sostenuto; } } } @@ -1486,11 +1520,11 @@ void OPNMIDIplay::setRPN(size_t midCh, unsigned value, bool MSB) switch(addr + nrpn * 0x10000 + MSB * 0x20000) { case 0x0000 + 0*0x10000 + 1*0x20000: // Pitch-bender sensitivity - m_midiChannels[midCh].bendsense_msb = value; + m_midiChannels[midCh].bendsense_msb = static_cast(value); m_midiChannels[midCh].updateBendSensitivity(); break; case 0x0000 + 0*0x10000 + 0*0x20000: // Pitch-bender sensitivity LSB - m_midiChannels[midCh].bendsense_lsb = value; + m_midiChannels[midCh].bendsense_lsb = static_cast(value); m_midiChannels[midCh].updateBendSensitivity(); break; case 0x0108 + 1*0x10000 + 1*0x20000: // Vibrato speed @@ -1505,13 +1539,13 @@ void OPNMIDIplay::setRPN(size_t midCh, unsigned value, bool MSB) case 0x0109 + 1*0x10000 + 1*0x20000: if((m_synthMode & Mode_XG) != 0) // Vibrato depth { - m_midiChannels[midCh].vibdepth = (((int)value - 64) * 0.15) * 0.01; + m_midiChannels[midCh].vibdepth = ((static_cast(value) - 64) * 0.15) * 0.01; } break; case 0x010A + 1*0x10000 + 1*0x20000: if((m_synthMode & Mode_XG) != 0) // Vibrato delay in millisecons { - m_midiChannels[midCh].vibdelay_us = value ? int64_t(209.2 * std::exp(0.0795 * (double)value)) : 0; + m_midiChannels[midCh].vibdelay_us = value ? int64_t(209.2 * std::exp(0.0795 * static_cast(value))) : 0; } break; default:/* UI.PrintLn("%s %04X <- %d (%cSB) (ch %u)", @@ -1529,13 +1563,19 @@ void OPNMIDIplay::updatePortamento(size_t midCh) m_midiChannels[midCh].portamentoRate = rate; } -void OPNMIDIplay::noteOff(size_t midCh, uint8_t note) +void OPNMIDIplay::noteOff(size_t midCh, uint8_t note, bool forceNow) { - MIDIchannel::activenoteiterator - i = m_midiChannels[midCh].activenotes_find(note); + MIDIchannel &ch = m_midiChannels[midCh]; + MIDIchannel::notes_iterator i = ch.find_activenote(note); - if(i) - noteUpdate(midCh, i, Upd_Off); + if(!i.is_end()) + { + MIDIchannel::NoteInfo &ni = i->value; + if(forceNow || ni.ttl <= 0) + noteUpdate(midCh, i, Upd_Off); + else + ni.isOnExtendedLifeTime = true; + } } @@ -1543,7 +1583,7 @@ void OPNMIDIplay::updateVibrato(double amount) { for(size_t a = 0, b = m_midiChannels.size(); a < b; ++a) { - if(m_midiChannels[a].hasVibrato() && !m_midiChannels[a].activenotes_empty()) + if(m_midiChannels[a].hasVibrato() && !m_midiChannels[a].activenotes.empty()) { noteUpdateAll(static_cast(a), Upd_Pitch); m_midiChannels[a].vibpos += amount * m_midiChannels[a].vibspeed; @@ -1566,6 +1606,7 @@ size_t OPNMIDIplay::chooseDevice(const std::string &name) size_t n = m_midiDevices.size() * 16; m_midiDevices.insert(std::make_pair(name, n)); m_midiChannels.resize(n + 16); + resetMIDIDefaults(n); return n; } @@ -1573,6 +1614,9 @@ void OPNMIDIplay::updateArpeggio(double) // amount = amount of time passed { // If there is an adlib channel that has multiple notes // simulated on the same channel, arpeggio them. + + Synth &synth = *m_synth; + #if 0 const unsigned desired_arpeggio_rate = 40; // Hz (upper limit) #if 1 @@ -1595,17 +1639,17 @@ void OPNMIDIplay::updateArpeggio(double) // amount = amount of time passed ++m_arpeggioCounter; - for(uint32_t c = 0; c < m_synth.m_numChannels; ++c) + for(uint32_t c = 0; c < synth.m_numChannels; ++c) { retry_arpeggio: if(c > uint32_t(std::numeric_limits::max())) break; - size_t n_users = m_chipChannels[c].users_size; + size_t n_users = m_chipChannels[c].users.size(); if(n_users > 1) { - OpnChannel::LocationData *i = m_chipChannels[c].users_first; + OpnChannel::users_iterator i = m_chipChannels[c].users.begin(); size_t rate_reduction = 3; if(n_users >= 3) @@ -1616,23 +1660,24 @@ void OPNMIDIplay::updateArpeggio(double) // amount = amount of time passed for(size_t count = (m_arpeggioCounter / rate_reduction) % n_users, n = 0; n < count; ++n) - i = i->next; + ++i; - if(i->sustained == OpnChannel::LocationData::Sustain_None) + OpnChannel::LocationData &d = i->value; + if(d.sustained == OpnChannel::LocationData::Sustain_None) { - if(i->kon_time_until_neglible_us <= 0) + if(d.kon_time_until_neglible_us <= 0) { noteUpdate( - i->loc.MidCh, - m_midiChannels[ i->loc.MidCh ].activenotes_ensure_find(i->loc.note), + d.loc.MidCh, + m_midiChannels[ d.loc.MidCh ].ensure_find_activenote(d.loc.note), Upd_Off, static_cast(c)); goto retry_arpeggio; } noteUpdate( - i->loc.MidCh, - m_midiChannels[ i->loc.MidCh ].activenotes_ensure_find(i->loc.note), + d.loc.MidCh, + m_midiChannels[ d.loc.MidCh ].ensure_find_activenote(d.loc.note), Upd_Pitch | Upd_Volume | Upd_Pan, static_cast(c)); } @@ -1650,22 +1695,23 @@ void OPNMIDIplay::updateGlide(double amount) if(midiChan.gliding_note_count == 0) continue; - for(MIDIchannel::activenoteiterator it = midiChan.activenotes_begin(); - it; ++it) + for(MIDIchannel::notes_iterator it = midiChan.activenotes.begin(); + !it.is_end(); ++it) { - double finalTone = it->noteTone; - double previousTone = it->currentTone; + MIDIchannel::NoteInfo &info = it->value; + double finalTone = info.noteTone; + double previousTone = info.currentTone; bool directionUp = previousTone < finalTone; - double toneIncr = amount * (directionUp ? +it->glideRate : -it->glideRate); + double toneIncr = amount * (directionUp ? +info.glideRate : -info.glideRate); double currentTone = previousTone + toneIncr; bool glideFinished = !(directionUp ? (currentTone < finalTone) : (currentTone > finalTone)); currentTone = glideFinished ? finalTone : currentTone; - if(currentTone != previousTone) + if(int64_t(currentTone * 1000000.0) != int64_t(previousTone * 1000000.0)) { - it->currentTone = currentTone; + info.currentTone = currentTone; noteUpdate(static_cast(channel), it, Upd_Pitch); } } @@ -1677,7 +1723,7 @@ void OPNMIDIplay::describeChannels(char *str, char *attr, size_t size) if (!str || size <= 0) return; - OPN2 &synth = m_synth; + Synth &synth = *m_synth; uint32_t numChannels = synth.m_numChannels; uint32_t index = 0; @@ -1685,12 +1731,15 @@ void OPNMIDIplay::describeChannels(char *str, char *attr, size_t size) { const OpnChannel &adlChannel = m_chipChannels[index]; - OpnChannel::LocationData *loc = adlChannel.users_first; - if(!loc) // off + OpnChannel::const_users_iterator loc = adlChannel.users.begin(); + OpnChannel::const_users_iterator locnext(loc); + if(!loc.is_end()) ++locnext; + + if(loc.is_end()) // off { str[index] = '-'; } - else if(loc->next) // arpeggio + else if(!locnext.is_end()) // arpeggio { str[index] = '@'; } @@ -1700,10 +1749,10 @@ void OPNMIDIplay::describeChannels(char *str, char *attr, size_t size) } uint8_t attribute = 0; - if (loc) // 4-bit color index of MIDI channel - attribute |= (uint8_t)(loc->loc.MidCh & 0xF); + if (!loc.is_end()) // 4-bit color index of MIDI channel + attribute |= uint8_t(loc->value.loc.MidCh & 0xF); - attr[index] = (char)attribute; + attr[index] = static_cast(attribute); ++index; } @@ -1901,122 +1950,3 @@ void OPNMIDIplay::describeChannels(char *str, char *attr, size_t size) //} //#endif//ADLMIDI_DISABLE_CPP_EXTRAS - -// Implement the user map data structure. - -bool OPNMIDIplay::OpnChannel::users_empty() const -{ - return !users_first; -} - -OPNMIDIplay::OpnChannel::LocationData *OPNMIDIplay::OpnChannel::users_find(Location loc) -{ - LocationData *user = NULL; - for(LocationData *curr = users_first; !user && curr; curr = curr->next) - if(curr->loc == loc) - user = curr; - return user; -} - -OPNMIDIplay::OpnChannel::LocationData *OPNMIDIplay::OpnChannel::users_allocate() -{ - // remove free cells front - LocationData *user = users_free_cells; - if(!user) - return NULL; - users_free_cells = user->next; - if(users_free_cells) - users_free_cells->prev = NULL; - // add to users front - if(users_first) - users_first->prev = user; - user->prev = NULL; - user->next = users_first; - users_first = user; - ++users_size; - return user; -} - -OPNMIDIplay::OpnChannel::LocationData *OPNMIDIplay::OpnChannel::users_find_or_create(Location loc) -{ - LocationData *user = users_find(loc); - if(!user) { - user = users_allocate(); - if(!user) - return NULL; - LocationData *prev = user->prev, *next = user->next; - *user = LocationData(); - user->prev = prev; user->next = next; - user->loc = loc; - } - return user; -} - -OPNMIDIplay::OpnChannel::LocationData *OPNMIDIplay::OpnChannel::users_insert(const LocationData &x) -{ - LocationData *user = users_find(x.loc); - if(!user) - { - user = users_allocate(); - if(!user) - return NULL; - LocationData *prev = user->prev, *next = user->next; - *user = x; - user->prev = prev; user->next = next; - } - return user; -} - -void OPNMIDIplay::OpnChannel::users_erase(LocationData *user) -{ - if(user->prev) - user->prev->next = user->next; - if(user->next) - user->next->prev = user->prev; - if(user == users_first) - users_first = user->next; - user->prev = NULL; - user->next = users_free_cells; - users_free_cells = user; - --users_size; -} - -void OPNMIDIplay::OpnChannel::users_clear() -{ - users_first = NULL; - users_free_cells = users_cells; - users_size = 0; - for(size_t i = 0; i < users_max; ++i) - { - users_cells[i].prev = (i > 0) ? &users_cells[i - 1] : NULL; - users_cells[i].next = (i + 1 < users_max) ? &users_cells[i + 1] : NULL; - } -} - -void OPNMIDIplay::OpnChannel::users_assign(const LocationData *users, size_t count) -{ - ADL_UNUSED(count);//Avoid warning for release builds - assert(count <= users_max); - if(users == users_first && users) { - // self assignment - assert(users_size == count); - return; - } - users_clear(); - const LocationData *src_cell = users; - // move to the last - if(src_cell) { - while(src_cell->next) - src_cell = src_cell->next; - } - // push cell copies in reverse order - while(src_cell) { - LocationData *dst_cell = users_allocate(); - assert(dst_cell); - LocationData *prev = dst_cell->prev, *next = dst_cell->next; - *dst_cell = *src_cell; - dst_cell->prev = prev; dst_cell->next = next; - src_cell = src_cell->prev; - } - assert(users_size == count); -} diff --git a/thirdparty/opnmidi/opnmidi_midiplay.hpp b/thirdparty/opnmidi/opnmidi_midiplay.hpp new file mode 100644 index 0000000..1e7d9d1 --- /dev/null +++ b/thirdparty/opnmidi/opnmidi_midiplay.hpp @@ -0,0 +1,1002 @@ +/* + * libOPNMIDI is a free Software MIDI synthesizer library with OPN2 (YM2612) emulation + * + * MIDI parser and player (Original code from ADLMIDI): Copyright (c) 2010-2014 Joel Yliluoma + * OPNMIDI Library and YM2612 support: Copyright (c) 2017-2020 Vitaly Novichkov + * + * Library is based on the ADLMIDI, a MIDI player for Linux and Windows with OPL3 emulation: + * http://iki.fi/bisqwit/source/adlmidi.html + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +#ifndef OPNMIDI_MIDIPLAY_HPP +#define OPNMIDI_MIDIPLAY_HPP + +#include "opnbank.h" +#include "opnmidi_private.hpp" +#include "opnmidi_ptr.hpp" +#include "structures/pl_list.hpp" + +/** + * @brief Hooks of the internal events + */ +struct MIDIEventHooks +{ + MIDIEventHooks() : + onNote(NULL), + onNote_userData(NULL), + onDebugMessage(NULL), + onDebugMessage_userData(NULL) + {} + + //! Note on/off hooks + typedef void (*NoteHook)(void *userdata, int adlchn, int note, int ins, int pressure, double bend); + NoteHook onNote; + void *onNote_userData; + + //! Library internal debug messages + typedef void (*DebugMessageHook)(void *userdata, const char *fmt, ...); + DebugMessageHook onDebugMessage; + void *onDebugMessage_userData; +}; + +class OPNMIDIplay +{ + friend void opn2_reset(struct OPN2_MIDIPlayer*); +public: + explicit OPNMIDIplay(unsigned long sampleRate = 22050); + ~OPNMIDIplay(); + + void applySetup(); + + void partialReset(); + void resetMIDI(); + +private: + void resetMIDIDefaults(int offset = 0); + +public: + /**********************Internal structures and classes**********************/ + + /** + * @brief Persistent settings for each MIDI channel + */ + struct MIDIchannel + { + //! Default MIDI volume + uint8_t def_volume; + //! Default LSB of a bend sensitivity + int def_bendsense_lsb; + //! Default MSB of a bend sensitivity + int def_bendsense_msb; + + //! LSB Bank number + uint8_t bank_lsb, + //! MSB Bank number + bank_msb; + //! Current patch number + uint8_t patch; + //! Volume level + uint8_t volume, + //! Expression level + expression; + //! Panning level + uint8_t panning, + //! Vibrato level + vibrato, + //! Channel aftertouch level + aftertouch; + //! Portamento time + uint16_t portamento; + //! Is Pedal sustain active + bool sustain; + //! Is Soft pedal active + bool softPedal; + //! Is portamento enabled + bool portamentoEnable; + //! Source note number used by portamento + int8_t portamentoSource; // note number or -1 + //! Portamento rate + double portamentoRate; + //! Per note Aftertouch values + uint8_t noteAftertouch[128]; + //! Is note aftertouch has any non-zero value + bool noteAfterTouchInUse; + //! Reserved + char _padding[6]; + //! Pitch bend value + int bend; + //! Pitch bend sensitivity + double bendsense; + //! Pitch bend sensitivity LSB value + int bendsense_lsb, + //! Pitch bend sensitivity MSB value + bendsense_msb; + //! Vibrato position value + double vibpos, + //! Vibrato speed value + vibspeed, + //! Vibrato depth value + vibdepth; + //! Vibrato delay time + int64_t vibdelay_us; + //! Last LSB part of RPN value received + uint8_t lastlrpn, + //! Last MSB poart of RPN value received + lastmrpn; + //! Interpret RPN value as NRPN + bool nrpn; + //! Brightness level + uint8_t brightness; + + //! Is melodic channel turned into percussion + bool is_xg_percussion; + + /** + * @brief Per-Note information + */ + struct NoteInfo + { + //! Note number + uint8_t note; + //! Current pressure + uint8_t vol; + //! Note vibrato (a part of Note Aftertouch feature) + uint8_t vibrato; + //! Tone selected on noteon: + int16_t noteTone; + //! Current tone (!= noteTone if gliding note) + double currentTone; + //! Gliding rate + double glideRate; + //! Patch selected on noteon; index to bank.ins[] + size_t midiins; + //! Is note the percussion instrument + bool isPercussion; + //! Note that plays missing instrument. Doesn't using any chip channels + bool isBlank; + //! Whether releasing and on extended life time defined by TTL + bool isOnExtendedLifeTime; + //! Time-to-live until release (short percussion note fix) + double ttl; + //! Patch selected + const OpnInstMeta *ains; + enum + { + MaxNumPhysChans = 2, + MaxNumPhysItemCount = MaxNumPhysChans + }; + + struct FindPredicate + { + explicit FindPredicate(unsigned note) + : note(note) {} + bool operator()(const NoteInfo &ni) const + { return ni.note == note; } + unsigned note; + }; + + /** + * @brief Reference to currently using chip channel + */ + struct Phys + { + //! Destination chip channel + uint16_t chip_chan; + //! ins, inde to adl[] + OpnTimbre ains; + + void assign(const Phys &oth) + { + ains = oth.ains; + } + bool operator==(const Phys &oth) const + { + return (ains == oth.ains); + } + bool operator!=(const Phys &oth) const + { + return !operator==(oth); + } + }; + + //! List of OPN2 channels it is currently occupying. + Phys chip_channels[MaxNumPhysItemCount]; + //! Count of used channels. + unsigned chip_channels_count; + + Phys *phys_find(unsigned chip_chan) + { + Phys *ph = NULL; + for(unsigned i = 0; i < chip_channels_count && !ph; ++i) + if(chip_channels[i].chip_chan == chip_chan) + ph = &chip_channels[i]; + return ph; + } + Phys *phys_find_or_create(uint16_t chip_chan) + { + Phys *ph = phys_find(chip_chan); + if(!ph) { + if(chip_channels_count < MaxNumPhysItemCount) { + ph = &chip_channels[chip_channels_count++]; + ph->chip_chan = chip_chan; + } + } + return ph; + } + Phys *phys_ensure_find_or_create(uint16_t chip_chan) + { + Phys *ph = phys_find_or_create(chip_chan); + assert(ph); + return ph; + } + void phys_erase_at(const Phys *ph) + { + intptr_t pos = ph - chip_channels; + assert(pos < static_cast(chip_channels_count)); + for(intptr_t i = pos + 1; i < static_cast(chip_channels_count); ++i) + chip_channels[i - 1] = chip_channels[i]; + --chip_channels_count; + } + void phys_erase(unsigned chip_chan) + { + Phys *ph = phys_find(chip_chan); + if(ph) + phys_erase_at(ph); + } + }; + + //! Reserved + char _padding2[5]; + //! Count of gliding notes in this channel + unsigned gliding_note_count; + //! Count of notes having a TTL countdown in this channel + unsigned extended_note_count; + + //! Active notes in the channel + pl_list activenotes; + typedef pl_list::iterator notes_iterator; + typedef pl_list::const_iterator const_notes_iterator; + + notes_iterator find_activenote(unsigned note) + { + return activenotes.find_if(NoteInfo::FindPredicate(note)); + } + + notes_iterator ensure_find_activenote(unsigned note) + { + notes_iterator it = find_activenote(note); + assert(!it.is_end()); + return it; + } + + notes_iterator find_or_create_activenote(unsigned note) + { + notes_iterator it = find_activenote(note); + if(!it.is_end()) + cleanupNote(it); + else + { + NoteInfo ni; + ni.note = note; + it = activenotes.insert(activenotes.end(), ni); + } + return it; + } + + notes_iterator ensure_find_or_create_activenote(unsigned note) + { + notes_iterator it = find_or_create_activenote(note); + assert(!it.is_end()); + return it; + } + + /** + * @brief Reset channel into initial state + */ + void reset() + { + resetAllControllers(); + patch = 0; + vibpos = 0; + bank_lsb = 0; + bank_msb = 0; + lastlrpn = 0; + lastmrpn = 0; + nrpn = false; + is_xg_percussion = false; + } + + + void resetAllControllers() + { + volume = def_volume; + brightness = 127; + panning = 64; + + resetAllControllers121(); + } + + /** + * @brief Reset all MIDI controllers into initial state + */ + void resetAllControllers121() + { + bend = 0; + bendsense_msb = def_bendsense_msb; + bendsense_lsb = def_bendsense_lsb; + updateBendSensitivity(); + expression = 127; + sustain = false; + softPedal = false; + vibrato = 0; + aftertouch = 0; + std::memset(noteAftertouch, 0, 128); + noteAfterTouchInUse = false; + vibspeed = 2 * 3.141592653 * 5.0; + vibdepth = 0.5 / 127; + vibdelay_us = 0; + portamento = 0; + portamentoEnable = false; + portamentoSource = -1; + portamentoRate = HUGE_VAL; + } + + /** + * @brief Has channel vibrato to process + * @return + */ + bool hasVibrato() + { + return (vibrato > 0) || (aftertouch > 0) || noteAfterTouchInUse; + } + + /** + * @brief Commit pitch bend sensitivity value from MSB and LSB + */ + void updateBendSensitivity() + { + int cent = bendsense_msb * 128 + bendsense_lsb; + bendsense = cent * (1.0 / (128 * 8192)); + } + + /** + * @brief Clean up the state of the active note before removal + */ + void cleanupNote(notes_iterator i) + { + NoteInfo &info = i->value; + if(info.glideRate != HUGE_VAL) + --gliding_note_count; + if(info.ttl > 0) + --extended_note_count; + } + + MIDIchannel() : + def_volume(100), + def_bendsense_lsb(0), + def_bendsense_msb(2), + activenotes(128) + { + gliding_note_count = 0; + extended_note_count = 0; + reset(); + } + }; + + /** + * @brief Additional information about OPN2 channels + */ + struct OpnChannel + { + struct Location + { + uint16_t MidCh; + uint8_t note; + bool operator==(const Location &l) const + { return MidCh == l.MidCh && note == l.note; } + bool operator!=(const Location &l) const + { return !operator==(l); } + char _padding[1]; + }; + struct LocationData + { + Location loc; + enum { + Sustain_None = 0x00, + Sustain_Pedal = 0x01, + Sustain_Sostenuto = 0x02, + Sustain_ANY = Sustain_Pedal | Sustain_Sostenuto + }; + uint32_t sustained; + char _padding[3]; + MIDIchannel::NoteInfo::Phys ins; // a copy of that in phys[] + //! Has fixed sustain, don't iterate "on" timeout + bool fixed_sustain; + //! Timeout until note will be allowed to be killed by channel manager while it is on + int64_t kon_time_until_neglible_us; + int64_t vibdelay_us; + + struct FindPredicate + { + explicit FindPredicate(Location loc) + : loc(loc) {} + bool operator()(const LocationData &ld) const + { return ld.loc == loc; } + Location loc; + }; + }; + + //! Time left until sounding will be muted after key off + int64_t koff_time_until_neglible_us; + + //! Recently passed instrument, improves a goodness of released but busy channel when matching + MIDIchannel::NoteInfo::Phys recent_ins; + + pl_list users; + typedef pl_list::iterator users_iterator; + typedef pl_list::const_iterator const_users_iterator; + + users_iterator find_user(const Location &loc) + { + return users.find_if(LocationData::FindPredicate(loc)); + } + + users_iterator find_or_create_user(const Location &loc) + { + users_iterator it = find_user(loc); + if(it.is_end() && users.size() != users.capacity()) + { + LocationData ld; + ld.loc = loc; + it = users.insert(users.end(), ld); + } + return it; + } + + // For channel allocation: + OpnChannel(): koff_time_until_neglible_us(0), users(128) + { + std::memset(&recent_ins, 0, sizeof(MIDIchannel::NoteInfo::Phys)); + } + + OpnChannel(const OpnChannel &oth): koff_time_until_neglible_us(oth.koff_time_until_neglible_us), users(oth.users) + { + } + + OpnChannel &operator=(const OpnChannel &oth) + { + koff_time_until_neglible_us = oth.koff_time_until_neglible_us; + users = oth.users; + return *this; + } + + /** + * @brief Increases age of active note in microseconds time + * @param us Amount time in microseconds + */ + void addAge(int64_t us); + }; + +#ifndef OPNMIDI_DISABLE_MIDI_SEQUENCER + /** + * @brief MIDI files player sequencer + */ + AdlMIDI_UPtr m_sequencer; + + /** + * @brief Interface between MIDI sequencer and this library + */ + AdlMIDI_UPtr m_sequencerInterface; + + /** + * @brief Initialize MIDI sequencer interface + */ + void initSequencerInterface(); +#endif //OPNMIDI_DISABLE_MIDI_SEQUENCER + + struct Setup + { + int emulator; + bool runAtPcmRate; + unsigned int OpnBank; + unsigned int numChips; + unsigned int LogarithmicVolumes; + int VolumeModel; + int lfoEnable; + int lfoFrequency; + int chipType; + //unsigned int SkipForward; + int ScaleModulators; + bool fullRangeBrightnessCC74; + + double delay; + double carry; + + /* The lag between visual content and audio content equals */ + /* the sum of these two buffers. */ + double mindelay; + double maxdelay; + + /* For internal usage */ + ssize_t tick_skip_samples_delay; /* Skip tick processing after samples count. */ + /* For internal usage */ + + unsigned long PCM_RATE; + }; + + /** + * @brief MIDI Marker entry + */ + struct MIDI_MarkerEntry + { + //! Label of marker + std::string label; + //! Absolute position in seconds + double pos_time; + //! Absolute position in ticks in the track + uint64_t pos_ticks; + }; + + //! Available MIDI Channels + std::vector m_midiChannels; + + //! SysEx device ID + uint8_t m_sysExDeviceId; + + /** + * @brief MIDI Synthesizer mode + */ + enum SynthMode + { + Mode_GM = 0x00, + Mode_GS = 0x01, + Mode_XG = 0x02, + Mode_GM2 = 0x04 + }; + //! MIDI Synthesizer mode + uint32_t m_synthMode; + + //! Installed function hooks + MIDIEventHooks hooks; + +private: + //! Per-track MIDI devices map + std::map m_midiDevices; + //! Current MIDI device per track + std::map m_currentMidiDevice; + + //! Chip channels map + std::vector m_chipChannels; + //! Counter of arpeggio processing + size_t m_arpeggioCounter; + +#if defined(ADLMIDI_AUDIO_TICK_HANDLER) + //! Audio tick counter + uint32_t m_audioTickCounter; +#endif + + //! Local error string + std::string errorStringOut; + + //! Missing instruments catches + std::set caugh_missing_instruments; + //! Missing melodic banks catches + std::set caugh_missing_banks_melodic; + //! Missing percussion banks catches + std::set caugh_missing_banks_percussion; + +public: + + const std::string &getErrorString(); + void setErrorString(const std::string &err); + + //! OPN2 Chip manager + AdlMIDI_UPtr m_synth; + + //! Generator output buffer + int32_t m_outBuf[1024]; + + //! Synthesizer setup + Setup m_setup; + + /** + * @brief Load bank from file + * @param filename Path to bank file + * @return true on succes + */ + bool LoadBank(const std::string &filename); + + /** + * @brief Load bank from memory block + * @param data Pointer to memory block where raw bank file is stored + * @param size Size of given memory block + * @return true on succes + */ + bool LoadBank(const void *data, size_t size); + + /** + * @brief Load bank from opened FileAndMemReader class + * @param fr Instance with opened file + * @return true on succes + */ + bool LoadBank(FileAndMemReader &fr); + +#ifndef OPNMIDI_DISABLE_MIDI_SEQUENCER + /** + * @brief MIDI file loading pre-process + * @return true on success, false on failure + */ + bool LoadMIDI_pre(); + + /** + * @brief MIDI file loading post-process + * @return true on success, false on failure + */ + bool LoadMIDI_post(); + + /** + * @brief Load music file from a file + * @param filename Path to music file + * @return true on success, false on failure + */ + + bool LoadMIDI(const std::string &filename); + + /** + * @brief Load music file from the memory block + * @param data pointer to the memory block + * @param size size of memory block + * @return true on success, false on failure + */ + bool LoadMIDI(const void *data, size_t size); + + /** + * @brief Periodic tick handler. + * @param s seconds since last call + * @param granularity don't expect intervals smaller than this, in seconds + * @return desired number of seconds until next call + */ + double Tick(double s, double granularity); +#endif //OPNMIDI_DISABLE_MIDI_SEQUENCER + + /** + * @brief Process extra iterators like vibrato or arpeggio + * @param s seconds since last call + */ + void TickIterators(double s); + + + /* RealTime event triggers */ + /** + * @brief Reset state of all channels + */ + void realTime_ResetState(); + + /** + * @brief Note On event + * @param channel MIDI channel + * @param note Note key (from 0 to 127) + * @param velocity Velocity level (from 0 to 127) + * @return true if Note On event was accepted + */ + bool realTime_NoteOn(uint8_t channel, uint8_t note, uint8_t velocity); + + /** + * @brief Note Off event + * @param channel MIDI channel + * @param note Note key (from 0 to 127) + */ + void realTime_NoteOff(uint8_t channel, uint8_t note); + + /** + * @brief Note aftertouch event + * @param channel MIDI channel + * @param note Note key (from 0 to 127) + * @param atVal After-Touch level (from 0 to 127) + */ + void realTime_NoteAfterTouch(uint8_t channel, uint8_t note, uint8_t atVal); + + /** + * @brief Channel aftertouch event + * @param channel MIDI channel + * @param atVal After-Touch level (from 0 to 127) + */ + void realTime_ChannelAfterTouch(uint8_t channel, uint8_t atVal); + + /** + * @brief Controller Change event + * @param channel MIDI channel + * @param type Type of controller + * @param value Value of the controller (from 0 to 127) + */ + void realTime_Controller(uint8_t channel, uint8_t type, uint8_t value); + + /** + * @brief Patch change + * @param channel MIDI channel + * @param patch Patch Number (from 0 to 127) + */ + void realTime_PatchChange(uint8_t channel, uint8_t patch); + + /** + * @brief Pitch bend change + * @param channel MIDI channel + * @param pitch Concoctated raw pitch value + */ + void realTime_PitchBend(uint8_t channel, uint16_t pitch); + + /** + * @brief Pitch bend change + * @param channel MIDI channel + * @param msb MSB of pitch value + * @param lsb LSB of pitch value + */ + void realTime_PitchBend(uint8_t channel, uint8_t msb, uint8_t lsb); + + /** + * @brief LSB Bank Change CC + * @param channel MIDI channel + * @param lsb LSB value of bank number + */ + void realTime_BankChangeLSB(uint8_t channel, uint8_t lsb); + + /** + * @brief MSB Bank Change CC + * @param channel MIDI channel + * @param lsb MSB value of bank number + */ + void realTime_BankChangeMSB(uint8_t channel, uint8_t msb); + + /** + * @brief Bank Change (united value) + * @param channel MIDI channel + * @param bank Bank number value + */ + void realTime_BankChange(uint8_t channel, uint16_t bank); + + /** + * @brief Sets the Device identifier + * @param id 7-bit Device identifier + */ + void setDeviceId(uint8_t id); + + /** + * @brief System Exclusive message + * @param msg Raw SysEx Message + * @param size Length of SysEx message + * @return true if message was passed successfully. False on any errors + */ + bool realTime_SysEx(const uint8_t *msg, size_t size); + + /** + * @brief Turn off all notes and mute the sound of releasing notes + */ + void realTime_panic(); + + /** + * @brief Device switch (to extend 16-channels limit of MIDI standard) + * @param track MIDI track index + * @param data Device name + * @param length Length of device name string + */ + void realTime_deviceSwitch(size_t track, const char *data, size_t length); + + /** + * @brief Currently selected device index + * @param track MIDI track index + * @return Multiple 16 value + */ + size_t realTime_currentDevice(size_t track); + +#if defined(ADLMIDI_AUDIO_TICK_HANDLER) + // Audio rate tick handler + void AudioTick(uint32_t chipId, uint32_t rate); +#endif + +private: + /** + * @brief Hardware manufacturer (Used for SysEx) + */ + enum + { + Manufacturer_Roland = 0x41, + Manufacturer_Yamaha = 0x43, + Manufacturer_UniversalNonRealtime = 0x7E, + Manufacturer_UniversalRealtime = 0x7F + }; + + /** + * @brief Roland Mode (Used for SysEx) + */ + enum + { + RolandMode_Request = 0x11, + RolandMode_Send = 0x12 + }; + + /** + * @brief Device model (Used for SysEx) + */ + enum + { + RolandModel_GS = 0x42, + RolandModel_SC55 = 0x45, + YamahaModel_XG = 0x4C + }; + + /** + * @brief Process generic SysEx events + * @param dev Device ID + * @param realtime Is real-time event + * @param data Raw SysEx data + * @param size Size of given SysEx data + * @return true when event was successfully handled + */ + bool doUniversalSysEx(unsigned dev, bool realtime, const uint8_t *data, size_t size); + + /** + * @brief Process events specific to Roland devices + * @param dev Device ID + * @param data Raw SysEx data + * @param size Size of given SysEx data + * @return true when event was successfully handled + */ + bool doRolandSysEx(unsigned dev, const uint8_t *data, size_t size); + + /** + * @brief Process events specific to Yamaha devices + * @param dev Device ID + * @param data Raw SysEx data + * @param size Size of given SysEx data + * @return true when event was successfully handled + */ + bool doYamahaSysEx(unsigned dev, const uint8_t *data, size_t size); + +private: + /** + * @brief Note Update properties + */ + enum + { + Upd_Patch = 0x1, + Upd_Pan = 0x2, + Upd_Volume = 0x4, + Upd_Pitch = 0x8, + Upd_All = Upd_Pan + Upd_Volume + Upd_Pitch, + Upd_Off = 0x20, + Upd_Mute = 0x40, + Upd_OffMute = Upd_Off + Upd_Mute + }; + + /** + * @brief Update active note + * @param MidCh MIDI Channel where note is processing + * @param i Iterator that points to active note in the MIDI channel + * @param props_mask Properties to update + * @param select_adlchn Specify chip channel, or -1 - all chip channels used by the note + */ + void noteUpdate(size_t midCh, + MIDIchannel::notes_iterator i, + unsigned props_mask, + int32_t select_adlchn = -1); + + void noteUpdateAll(size_t midCh, unsigned props_mask); + + /** + * @brief Determine how good a candidate this adlchannel would be for playing a note from this instrument. + * @param c Wanted chip channel + * @param ins Instrument wanted to be used in this channel + * @return Calculated coodness points + */ + int64_t calculateChipChannelGoodness(size_t c, const MIDIchannel::NoteInfo::Phys &ins) const; + + /** + * @brief A new note will be played on this channel using this instrument. + * @param c Wanted chip channel + * @param ins Instrument wanted to be used in this channel + * Kill existing notes on this channel (or don't, if we do arpeggio) + */ + void prepareChipChannelForNewNote(size_t c, const MIDIchannel::NoteInfo::Phys &ins); + + /** + * @brief Kills note that uses wanted channel. When arpeggio is possible, note is evaluating to another channel + * @param from_channel Wanted chip channel + * @param j Chip channel instance + * @param i MIDI Channel active note instance + */ + void killOrEvacuate( + size_t from_channel, + OpnChannel::users_iterator j, + MIDIchannel::notes_iterator i); + + /** + * @brief Off all notes and silence sound + */ + void panic(); + + /** + * @brief Kill note, sustaining by pedal or sostenuto + * @param MidCh MIDI channel, -1 - all MIDI channels + * @param this_adlchn Chip channel, -1 - all chip channels + * @param sustain_type Type of systain to process + */ + void killSustainingNotes(int32_t midCh = -1, + int32_t this_adlchn = -1, + uint32_t sustain_type = OpnChannel::LocationData::Sustain_ANY); + /** + * @brief Find active notes and mark them as sostenuto-sustained + * @param MidCh MIDI channel, -1 - all MIDI channels + */ + void markSostenutoNotes(int32_t midCh = -1); + + /** + * @brief Set RPN event value + * @param MidCh MIDI channel + * @param value 1 byte part of RPN value + * @param MSB is MSB or LSB part of value + */ + void setRPN(size_t midCh, unsigned value, bool MSB); + + /** + * @brief Update portamento setup in MIDI channel + * @param midCh MIDI channel where portamento needed to be updated + */ + void updatePortamento(size_t midCh); + + /** + * @brief Off the note + * @param midCh MIDI channel + * @param note Note to off + * @param forceNow Do not delay the key-off to a later time + */ + void noteOff(size_t midCh, uint8_t note, bool forceNow = false); + + /** + * @brief Update processing of vibrato to amount of seconds + * @param amount Amount value in seconds + */ + void updateVibrato(double amount); + + /** + * @brief Update auto-arpeggio + * @param amount Amount value in seconds [UNUSED] + */ + void updateArpeggio(double /*amount*/); + + /** + * @brief Update Portamento gliding to amount of seconds + * @param amount Amount value in seconds + */ + void updateGlide(double amount); + +public: + /** + * @brief Checks was device name used or not + * @param name Name of MIDI device + * @return Offset of the MIDI Channels, multiple to 16 + */ + size_t chooseDevice(const std::string &name); + + /** + * @brief Gets a textual description of the state of chip channels + * @param text character pointer for text + * @param attr character pointer for text attributes + * @param size number of characters available to write + */ + void describeChannels(char *text, char *attr, size_t size); +}; + +#endif // OPNMIDI_MIDIPLAY_HPP diff --git a/thirdparty/opnmidi/opnmidi_opn2.cpp b/thirdparty/opnmidi/opnmidi_opn2.cpp index a5a60d2..26ef352 100644 --- a/thirdparty/opnmidi/opnmidi_opn2.cpp +++ b/thirdparty/opnmidi/opnmidi_opn2.cpp @@ -1,8 +1,8 @@ /* - * libOPNMIDI is a free MIDI to WAV conversion library with OPN2 (YM2612) emulation + * libOPNMIDI is a free Software MIDI synthesizer library with OPN2 (YM2612) emulation * * MIDI parser and player (Original code from ADLMIDI): Copyright (c) 2010-2014 Joel Yliluoma - * OPNMIDI Library and YM2612 support: Copyright (c) 2017-2018 Vitaly Novichkov + * OPNMIDI Library and YM2612 support: Copyright (c) 2017-2020 Vitaly Novichkov * * Library is based on the ADLMIDI, a MIDI player for Linux and Windows with OPL3 emulation: * http://iki.fi/bisqwit/source/adlmidi.html @@ -21,10 +21,13 @@ * along with this program. If not, see . */ +#include "opnmidi_opn2.hpp" #include "opnmidi_private.hpp" #if defined(OPNMIDI_DISABLE_NUKED_EMULATOR) && defined(OPNMIDI_DISABLE_MAME_EMULATOR) && \ - defined(OPNMIDI_DISABLE_GENS_EMULATOR) && defined(OPNMIDI_DISABLE_GX_EMULATOR) + defined(OPNMIDI_DISABLE_GENS_EMULATOR) && defined(OPNMIDI_DISABLE_GX_EMULATOR) && \ + defined(OPNMIDI_DISABLE_NP2_EMULATOR) && defined(OPNMIDI_DISABLE_MAME_2608_EMULATOR) && \ + defined(OPNMIDI_DISABLE_PMDWIN_EMULATOR) #error "No emulators enabled. You must enable at least one emulator to use this library!" #endif @@ -48,6 +51,26 @@ #include "chips/gx_opn2.h" #endif +// Neko Project II OPNA emulator +#ifndef OPNMIDI_DISABLE_NP2_EMULATOR +#include "chips/np2_opna.h" +#endif + +// MAME YM2608 emulator +#ifndef OPNMIDI_DISABLE_MAME_2608_EMULATOR +#include "chips/mame_opna.h" +#endif + +// PMDWin OPNA emulator +#ifndef OPNMIDI_DISABLE_PMDWIN_EMULATOR +#include "chips/pmdwin_opna.h" +#endif + +// VGM File dumper +#ifdef OPNMIDI_MIDI2VGM +#include "chips/vgm_file_dumper.h" +#endif + static const unsigned opn2_emulatorSupport = 0 #ifndef OPNMIDI_DISABLE_NUKED_EMULATOR | (1u << OPNMIDI_EMU_NUKED) @@ -61,6 +84,18 @@ static const unsigned opn2_emulatorSupport = 0 #ifndef OPNMIDI_DISABLE_GX_EMULATOR | (1u << OPNMIDI_EMU_GX) #endif +#ifndef OPNMIDI_DISABLE_NP2_EMULATOR + | (1u << OPNMIDI_EMU_NP2) +#endif +#ifndef OPNMIDI_DISABLE_MAME_2608_EMULATOR + | (1u << OPNMIDI_EMU_MAME_2608) +#endif +#ifndef OPNMIDI_DISABLE_PMDWIN_EMULATOR + | (1u << OPNMIDI_EMU_PMDWIN) +#endif +#ifdef OPNMIDI_MIDI2VGM + | (1u << OPNMIDI_VGM_DUMPER) +#endif ; //! Check emulator availability @@ -91,6 +126,42 @@ int opn2_getLowestEmulator() return emu; } + + +/*************************************************************** + * Volume model tables * + ***************************************************************/ + +// Mapping from MIDI volume level to OPL level value. + +static const uint_fast32_t s_dmx_volume_model[128] = +{ + 0, 1, 3, 5, 6, 8, 10, 11, + 13, 14, 16, 17, 19, 20, 22, 23, + 25, 26, 27, 29, 30, 32, 33, 34, + 36, 37, 39, 41, 43, 45, 47, 49, + 50, 52, 54, 55, 57, 59, 60, 61, + 63, 64, 66, 67, 68, 69, 71, 72, + 73, 74, 75, 76, 77, 79, 80, 81, + 82, 83, 84, 84, 85, 86, 87, 88, + 89, 90, 91, 92, 92, 93, 94, 95, + 96, 96, 97, 98, 99, 99, 100, 101, + 101, 102, 103, 103, 104, 105, 105, 106, + 107, 107, 108, 109, 109, 110, 110, 111, + 112, 112, 113, 113, 114, 114, 115, 115, + 116, 117, 117, 118, 118, 119, 119, 120, + 120, 121, 121, 122, 122, 123, 123, 123, + 124, 124, 125, 125, 126, 126, 127, 127, +}; + +static const uint_fast32_t W9X_volume_mapping_table[32] = +{ + 63, 63, 40, 36, 32, 28, 23, 21, + 19, 17, 15, 14, 13, 12, 11, 10, + 9, 8, 7, 6, 5, 5, 4, 4, + 3, 3, 2, 2, 1, 1, 0, 0 +}; + static const uint32_t g_noteChannelsMap[6] = { 0, 1, 2, 4, 5, 6 }; static inline void getOpnChannel(size_t in_channel, @@ -104,15 +175,39 @@ static inline void getOpnChannel(size_t in_channel, out_ch = static_cast(ch4 % 3); } -static opnInstMeta2 makeEmptyInstrument() + +/*************************************************************** + * Standard frequency formula * + * *************************************************************/ + +static inline double s_commonFreq(double tone) +{ + return std::exp(0.057762265 * tone); +} + + + +enum { - opnInstMeta2 ins; - memset(&ins, 0, sizeof(opnInstMeta2)); - ins.flags = opnInstMeta::Flag_NoSound; + MasterVolumeDefault = 127 +}; + +enum +{ + OPN_PANNING_LEFT = 0x80, + OPN_PANNING_RIGHT = 0x40, + OPN_PANNING_BOTH = 0xC0 +}; + +static OpnInstMeta makeEmptyInstrument() +{ + OpnInstMeta ins; + memset(&ins, 0, sizeof(OpnInstMeta)); + ins.flags = OpnInstMeta::Flag_NoSound; return ins; } -const opnInstMeta2 OPN2::m_emptyInstrument = makeEmptyInstrument(); +const OpnInstMeta OPN2::m_emptyInstrument = makeEmptyInstrument(); OPN2::OPN2() : m_regLFOSetup(0), @@ -120,14 +215,17 @@ OPN2::OPN2() : m_scaleModulators(false), m_runAtPcmRate(false), m_softPanning(false), + m_masterVolume(MasterVolumeDefault), m_musicMode(MODE_MIDI), m_volumeScale(VOLUME_Generic), m_lfoEnable(false), - m_lfoFrequency(0) + m_lfoFrequency(0), + m_chipFamily(OPNChip_OPN2) { m_insBankSetup.volumeModel = OPN2::VOLUME_Generic; m_insBankSetup.lfoEnable = false; m_insBankSetup.lfoFrequency = 0; + m_insBankSetup.chipType = OPNChip_OPN2; // Initialize blank instruments banks m_insBanks.clear(); @@ -170,19 +268,32 @@ void OPN2::noteOff(size_t c) writeRegI(chip, 0, 0x28, g_noteChannelsMap[ch4]); } -void OPN2::noteOn(size_t c, double hertz) // Hertz range: 0..131071 +void OPN2::noteOn(size_t c, double tone) { + // Hertz range: 0..131071 + double hertz = s_commonFreq(tone); + + if(hertz < 0) // Avoid infinite loop + return; + + double coef; + switch(m_chipFamily) + { + case OPNChip_OPN2: default: + coef = 321.88557; break; + case OPNChip_OPNA: + coef = 309.12412; break; + } + hertz *= coef; + size_t chip; uint8_t port; uint32_t cc; size_t ch4 = c % 6; getOpnChannel(c, chip, port, cc); - if(hertz < 0) // Avoid infinite loop - return; - uint32_t octave = 0, ftone = 0, mul_offset = 0; - const opnInstData &adli = m_insCache[c]; + const OpnTimbre &adli = m_insCache[c]; //Basic range until max of octaves reaching while((hertz >= 1023.75) && (octave < 0x3800)) @@ -224,16 +335,20 @@ void OPN2::noteOn(size_t c, double hertz) // Hertz range: 0..131071 writeRegI(chip, 0, 0x28, 0xF0 + g_noteChannelsMap[ch4]); } -void OPN2::touchNote(size_t c, uint8_t volume, uint8_t brightness) +void OPN2::touchNote(size_t c, + uint_fast32_t velocity, + uint_fast32_t channelVolume, + uint_fast32_t channelExpression, + uint8_t brightness) { - if(volume > 127) volume = 127; - size_t chip; uint8_t port; uint32_t cc; getOpnChannel(c, chip, port, cc); - const opnInstData &adli = m_insCache[c]; + const OpnTimbre &adli = m_insCache[c]; + + uint_fast32_t volume = 0; uint8_t op_vol[4] = { @@ -261,12 +376,87 @@ void OPN2::touchNote(size_t c, uint8_t volume, uint8_t brightness) {true ,true ,true ,true},//Algorithm #7: W = 1 + 2 + 3 + 4 }; + switch(m_volumeScale) + { + default: + case Synth::VOLUME_Generic: + { + volume = velocity * m_masterVolume * + channelVolume * channelExpression; + + /* If the channel has arpeggio, the effective volume of + * *this* instrument is actually lower due to timesharing. + * To compensate, add extra volume that corresponds to the + * time this note is *not* heard. + * Empirical tests however show that a full equal-proportion + * increment sounds wrong. Therefore, using the square root. + */ + //volume = (int)(volume * std::sqrt( (double) ch[c].users.size() )); + const double c1 = 11.541560327111707; + const double c2 = 1.601379199767093e+02; + const uint_fast32_t minVolume = 1108075; // 8725 * 127 + + // The formula below: SOLVE(V=127^4 * 2^( (A-63.49999) / 8), A) + if(volume > minVolume) + { + double lv = std::log(static_cast(volume)); + volume = static_cast(lv * c1 - c2) * 2.0; + } + else + volume = 0; + } + break; + + case Synth::VOLUME_NATIVE: + { + volume = velocity * channelVolume * channelExpression; + //volume = volume * m_masterVolume / (127 * 127 * 127) / 2; + volume = (volume * m_masterVolume) / 4096766; + } + break; + + case Synth::VOLUME_DMX: + { + volume = (channelVolume * channelExpression * m_masterVolume) / 16129; + volume = (s_dmx_volume_model[volume] + 1) << 1; + volume = (s_dmx_volume_model[(velocity < 128) ? velocity : 127] * volume) >> 9; + + if(volume > 0) + volume += 64;//OPN has 0~127 range. As 0...63 is almost full silence, but at 64 to 127 is very closed to OPL3, just add 64. + } + break; + + case Synth::VOLUME_APOGEE: + { + volume = (channelVolume * channelExpression * m_masterVolume / 16129); + volume = ((64 * (velocity + 0x80)) * volume) >> 15; + //volume = ((63 * (vol + 0x80)) * Ch[MidCh].volume) >> 15; + if(volume > 0) + volume += 64;//OPN has 0~127 range. As 0...63 is almost full silence, but at 64 to 127 is very closed to OPL3, just add 64. + } + break; + + case Synth::VOLUME_9X: + { + //volume = 63 - W9X_volume_mapping_table[(((vol * Ch[MidCh].volume /** Ch[MidCh].expression*/) * 127 / 16129 /*2048383*/) >> 2)]; + volume = 63 - W9X_volume_mapping_table[((velocity * channelVolume * channelExpression * m_masterVolume / 2048383) >> 2)]; + //volume = W9X_volume_mapping_table[vol >> 2] + volume; + if(volume > 0) + volume += 64;//OPN has 0~127 range. As 0...63 is almost full silence, but at 64 to 127 is very closed to OPL3, just add 64. + } + break; + } + + + if(volume > 127) + volume = 127; + uint8_t alg = adli.fbalg & 0x07; for(uint8_t op = 0; op < 4; op++) { bool do_op = alg_do[alg][op] || m_scaleModulators; uint32_t x = op_vol[op]; - uint32_t vol_res = do_op ? (127 - (static_cast(volume) * (127 - (x & 127)))/127) : x; + uint32_t vol_res = do_op ? (127 - (static_cast(volume) * (127 - (x & 127))) / 127) : x; if(brightness != 127) { brightness = static_cast(::round(127.0 * ::sqrt((static_cast(brightness)) * (1.0 / 127.0)))); @@ -283,7 +473,7 @@ void OPN2::touchNote(size_t c, uint8_t volume, uint8_t brightness) // 63 + chanvol * (instrvol / 63.0 - 1) } -void OPN2::setPatch(size_t c, const opnInstData &instrument) +void OPN2::setPatch(size_t c, const OpnTimbre &instrument) { size_t chip; uint8_t port; @@ -307,7 +497,7 @@ void OPN2::setPan(size_t c, uint8_t value) uint8_t port; uint32_t cc; getOpnChannel(c, chip, port, cc); - const opnInstData &adli = m_insCache[c]; + const OpnTimbre &adli = m_insCache[c]; uint8_t val = 0; if(m_softPanning) { @@ -398,7 +588,7 @@ void OPN2::clearChips() m_chips.clear(); } -void OPN2::reset(int emulator, unsigned long PCM_RATE, void *audioTickHandler) +void OPN2::reset(int emulator, unsigned long PCM_RATE, OPNFamily family, void *audioTickHandler) { #if !defined(ADLMIDI_AUDIO_TICK_HANDLER) ADL_UNUSED(audioTickHandler); @@ -406,8 +596,19 @@ void OPN2::reset(int emulator, unsigned long PCM_RATE, void *audioTickHandler) clearChips(); m_insCache.clear(); m_regLFOSens.clear(); +#ifdef OPNMIDI_MIDI2VGM + if(emulator == OPNMIDI_VGM_DUMPER && (m_numChips > 2)) + m_numChips = 2;// VGM Dumper can't work in multichip mode +#endif m_chips.resize(m_numChips, AdlMIDI_SPtr()); +#ifdef OPNMIDI_MIDI2VGM + m_loopStartHook = NULL; + m_loopStartHookData = NULL; + m_loopEndHook = NULL; + m_loopEndHookData = NULL; +#endif + for(size_t i = 0; i < m_chips.size(); i++) { OPNChipBase *chip; @@ -419,37 +620,66 @@ void OPN2::reset(int emulator, unsigned long PCM_RATE, void *audioTickHandler) abort(); #ifndef OPNMIDI_DISABLE_MAME_EMULATOR case OPNMIDI_EMU_MAME: - chip = new MameOPN2; + chip = new MameOPN2(family); break; #endif #ifndef OPNMIDI_DISABLE_NUKED_EMULATOR case OPNMIDI_EMU_NUKED: - chip = new NukedOPN2; + chip = new NukedOPN2(family); break; #endif #ifndef OPNMIDI_DISABLE_GENS_EMULATOR case OPNMIDI_EMU_GENS: - chip = new GensOPN2; + chip = new GensOPN2(family); break; #endif #ifndef OPNMIDI_DISABLE_GX_EMULATOR case OPNMIDI_EMU_GX: - chip = new GXOPN2; + chip = new GXOPN2(family); + break; +#endif +#ifndef OPNMIDI_DISABLE_NP2_EMULATOR + case OPNMIDI_EMU_NP2: + chip = new NP2OPNA<>(family); + break; +#endif +#ifndef OPNMIDI_DISABLE_MAME_2608_EMULATOR + case OPNMIDI_EMU_MAME_2608: + chip = new MameOPNA(family); + break; +#endif +#ifndef OPNMIDI_DISABLE_PMDWIN_EMULATOR + case OPNMIDI_EMU_PMDWIN: + chip = new PMDWinOPNA(family); + break; +#endif +#ifdef OPNMIDI_MIDI2VGM + case OPNMIDI_VGM_DUMPER: + chip = new VGMFileDumper(family); + if(i == 0)//Set hooks for first chip only + { + m_loopStartHook = &VGMFileDumper::loopStartHook; + m_loopStartHookData = chip; + m_loopEndHook = &VGMFileDumper::loopEndHook; + m_loopEndHookData = chip; + } break; #endif } m_chips[i].reset(chip); - chip->setChipId((uint32_t)i); - chip->setRate((uint32_t)PCM_RATE, 7670454); + chip->setChipId(static_cast(i)); + chip->setRate(static_cast(PCM_RATE), chip->nativeClockRate()); if(m_runAtPcmRate) chip->setRunningAtPcmRate(true); #if defined(ADLMIDI_AUDIO_TICK_HANDLER) chip->setAudioTickHandlerInstance(audioTickHandler); #endif + family = chip->family(); } + m_chipFamily = family; m_numChannels = m_numChips * 6; - m_insCache.resize(m_numChannels, m_emptyInstrument.opn[0]); + m_insCache.resize(m_numChannels, m_emptyInstrument.op[0]); m_regLFOSens.resize(m_numChannels, 0); uint8_t regLFOSetup = (m_lfoEnable ? 8 : 0) | (m_lfoFrequency & 7); @@ -470,4 +700,13 @@ void OPN2::reset(int emulator, unsigned long PCM_RATE, void *audioTickHandler) } silenceAll(); +#ifdef OPNMIDI_MIDI2VGM + if(m_loopStartHook) // Post-initialization Loop Start hook (fix for loop edge passing clicks) + m_loopStartHook(m_loopStartHookData); +#endif +} + +OPNFamily OPN2::chipFamily() const +{ + return m_chipFamily; } diff --git a/thirdparty/opnmidi/opnmidi_opn2.hpp b/thirdparty/opnmidi/opnmidi_opn2.hpp new file mode 100644 index 0000000..c0e9db1 --- /dev/null +++ b/thirdparty/opnmidi/opnmidi_opn2.hpp @@ -0,0 +1,286 @@ +/* + * libOPNMIDI is a free Software MIDI synthesizer library with OPN2 (YM2612) emulation + * + * MIDI parser and player (Original code from ADLMIDI): Copyright (c) 2010-2014 Joel Yliluoma + * OPNMIDI Library and YM2612 support: Copyright (c) 2017-2020 Vitaly Novichkov + * + * Library is based on the ADLMIDI, a MIDI player for Linux and Windows with OPL3 emulation: + * http://iki.fi/bisqwit/source/adlmidi.html + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +#ifndef OPNMIDI_OPN2_HPP +#define OPNMIDI_OPN2_HPP + +#include "opnbank.h" +#include "opnmidi_ptr.hpp" +#include "opnmidi_private.hpp" +#include "opnmidi_bankmap.h" +#include "chips/opn_chip_family.h" + +/** + * @brief OPN2 Chip management class + */ +class OPN2 +{ + friend class OPNMIDIplay; +public: + enum { PercussionTag = 1 << 15 }; + + //! Total number of chip channels between all running emulators + uint32_t m_numChannels; + //! Just a padding. Reserved. + char _padding[4]; + //! Running chip emulators + std::vector > m_chips; +#ifdef OPNMIDI_MIDI2VGM + //! Loop Start hook + void (*m_loopStartHook)(void*); + //! Loop Start hook data + void *m_loopStartHookData; + //! Loop End hook + void (*m_loopEndHook)(void*); + //! Loop End hook data + void *m_loopEndHookData; +#endif +private: + //! Cached patch data, needed by Touch() + std::vector m_insCache; + //! Cached per-channel LFO sensitivity flags + std::vector m_regLFOSens; + //! LFO setup registry cache + uint8_t m_regLFOSetup; + +public: + /** + * @brief MIDI bank entry + */ + struct Bank + { + //! MIDI Bank instruments + OpnInstMeta ins[128]; + }; + typedef BasicBankMap BankMap; + //! MIDI bank instruments data + BankMap m_insBanks; + //! MIDI bank-wide setup + OpnBankSetup m_insBankSetup; + +public: + //! Blank instrument template + static const OpnInstMeta m_emptyInstrument; + + //! Total number of running concurrent emulated chips + uint32_t m_numChips; + //! Carriers-only are scaled by default by volume level. This flag will tell to scale modulators too. + bool m_scaleModulators; + //! Run emulator at PCM rate if that possible. Reduces sounding accuracy, but decreases CPU usage on lower rates. + bool m_runAtPcmRate; + //! Enable soft panning + bool m_softPanning; + //! Master volume, controlled via SysEx (0...127) + uint8_t m_masterVolume; + + //! Just a padding. Reserved. + char _padding2[3]; + + /** + * @brief Music playing mode + */ + enum MusicMode + { + //! MIDI mode + MODE_MIDI, + //! MIDI mode + MODE_XMIDI, + //! Id-Software Music mode + MODE_IMF, + //! Creative Music Files mode + MODE_CMF, + //! EA-MUS (a.k.a. RSXX) mode + MODE_RSXX + } m_musicMode; + + /** + * @brief Volume models enum + */ + enum VolumesScale + { + //! Generic volume model (linearization of logarithmic scale) + VOLUME_Generic, + //! OPN2 native logarithmic scale + VOLUME_NATIVE, + //! DMX volume scale logarithmic table + VOLUME_DMX, + //! Apoge Sound System volume scaling model + VOLUME_APOGEE, + //! Windows 9x driver volume scale table + VOLUME_9X + } m_volumeScale; + + //! Reserved + bool m_lfoEnable; + uint8_t m_lfoFrequency; + + //! Category of the channel + /*! 1 = DAC, 0 = regular + */ + std::vector m_channelCategory; + + //! Chip family + OPNFamily m_chipFamily; + + /** + * @brief C.O. Constructor + */ + OPN2(); + + /** + * @brief C.O. Destructor + */ + ~OPN2(); + + /** + * @brief Checks are setup locked to be changed on the fly or not + * @return true when setup on the fly is locked + */ + bool setupLocked(); + + /** + * @brief Write data to OPN2 chip register + * @param chip Index of emulated chip. In hardware OPN2 builds, this parameter is ignored + * @param port Port of the chip to write + * @param index Register address to write + * @param value Value to write + */ + void writeReg(size_t chip, uint8_t port, uint8_t index, uint8_t value); + + /** + * @brief Write data to OPN2 chip register + * @param chip Index of emulated chip. In hardware OPN2 builds, this parameter is ignored + * @param port Port of the chip to write + * @param index Register address to write + * @param value Value to write + */ + void writeRegI(size_t chip, uint8_t port, uint32_t index, uint32_t value); + + /** + * @brief Write to soft panning control of OPN2 chip emulator + * @param chip Index of emulated chip. + * @param address Register of channel to write + * @param value Value to write + */ + void writePan(size_t chip, uint32_t index, uint32_t value); + + /** + * @brief Off the note in specified chip channel + * @param c Channel of chip (Emulated chip choosing by next formula: [c = ch + (chipId * 23)]) + */ + void noteOff(size_t c); + + /** + * @brief On the note in specified chip channel with specified frequency of the tone + * @param c Channel of chip (Emulated chip choosing by next formula: [c = ch + (chipId * 23)]) + * @param tone The tone to play (integer part - MIDI halftone, decimal part - relative bend offset) + */ + void noteOn(size_t c, double tone); + + /** + * @brief Change setup of instrument in specified chip channel + * @param c Channel of chip (Emulated chip choosing by next formula: [c = ch + (chipId * 23)]) + * @param volume Volume level (from 0 to 127) + * @param brightness CC74 Brightness level (from 0 to 127) + */ + void touchNote(size_t c, + uint_fast32_t velocity, + uint_fast32_t channelVolume = 127, + uint_fast32_t channelExpression = 127, + uint8_t brightness = 127); + + /** + * @brief Set the instrument into specified chip channel + * @param c Channel of chip (Emulated chip choosing by next formula: [c = ch + (chipId * 23)]) + * @param instrument Instrument data to set into the chip channel + */ + void setPatch(size_t c, const OpnTimbre &instrument); + + /** + * @brief Set panpot position + * @param c Channel of chip (Emulated chip choosing by next formula: [c = ch + (chipId * 23)]) + * @param value 3-bit panpot value + */ + void setPan(size_t c, uint8_t value); + + /** + * @brief Shut up all chip channels + */ + void silenceAll(); + + /** + * @brief commit LFO enable and frequency + */ + void commitLFOSetup(); + + /** + * @brief Set the volume scaling model + * @param volumeModel Type of volume scale model scale + */ + void setVolumeScaleModel(OPNMIDI_VolumeModels volumeModel); + + /** + * @brief Get the volume scaling model + */ + OPNMIDI_VolumeModels getVolumeScaleModel(); + + /** + * @brief Clean up all running emulated chip instances + */ + void clearChips(); + + /** + * @brief Reset chip properties and initialize them + * @param emulator Type of chip emulator + * @param PCM_RATE Output sample rate to generate on output + * @param audioTickHandler PCM-accurate clock hook + */ + void reset(int emulator, unsigned long PCM_RATE, OPNFamily family, void *audioTickHandler); + + /** + * @brief Gets the family of current chips + * @return the chip family + */ + OPNFamily chipFamily() const; +}; + +/** + * @brief Check emulator availability + * @param emulator Emulator ID (Opn2_Emulator) + * @return true when emulator is available + */ +extern bool opn2_isEmulatorAvailable(int emulator); + +/** + * @brief Find highest emulator + * @return The Opn2_Emulator enum value which contains ID of highest emulator + */ +extern int opn2_getHighestEmulator(); + +/** + * @brief Find lowest emulator + * @return The Opn2_Emulator enum value which contains ID of lowest emulator + */ +extern int opn2_getLowestEmulator(); + +#endif // OPNMIDI_OPN2_HPP diff --git a/thirdparty/opnmidi/opnmidi_private.cpp b/thirdparty/opnmidi/opnmidi_private.cpp index 47c2c87..8d65c44 100644 --- a/thirdparty/opnmidi/opnmidi_private.cpp +++ b/thirdparty/opnmidi/opnmidi_private.cpp @@ -1,8 +1,8 @@ /* - * libOPNMIDI is a free MIDI to WAV conversion library with OPN2 (YM2612) emulation + * libOPNMIDI is a free Software MIDI synthesizer library with OPN2 (YM2612) emulation * * MIDI parser and player (Original code from ADLMIDI): Copyright (c) 2010-2014 Joel Yliluoma - * OPNMIDI Library and YM2612 support: Copyright (c) 2017-2018 Vitaly Novichkov + * OPNMIDI Library and YM2612 support: Copyright (c) 2017-2020 Vitaly Novichkov * * Library is based on the ADLMIDI, a MIDI player for Linux and Windows with OPL3 emulation: * http://iki.fi/bisqwit/source/adlmidi.html @@ -21,6 +21,8 @@ * along with this program. If not, see . */ +#include "opnmidi_midiplay.hpp" +#include "opnmidi_opn2.hpp" #include "opnmidi_private.hpp" std::string OPN2MIDI_ErrorString; diff --git a/thirdparty/opnmidi/opnmidi_private.hpp b/thirdparty/opnmidi/opnmidi_private.hpp index 353cc3d..97b8bfc 100644 --- a/thirdparty/opnmidi/opnmidi_private.hpp +++ b/thirdparty/opnmidi/opnmidi_private.hpp @@ -1,8 +1,8 @@ /* - * libADLMIDI is a free MIDI to WAV conversion library with OPL3 emulation + * libADLMIDI is a free Software MIDI synthesizer library with OPL3 emulation * * Original ADLMIDI code: Copyright (c) 2010-2014 Joel Yliluoma - * ADLMIDI Library API: Copyright (c) 2017-2018 Vitaly Novichkov + * ADLMIDI Library API: Copyright (c) 2017-2020 Vitaly Novichkov * * Library is based on the ADLMIDI, a MIDI player for Linux and Windows with OPL3 emulation: * http://iki.fi/bisqwit/source/adlmidi.html @@ -50,7 +50,6 @@ typedef __int64 ssize_t; # else typedef __int32 ssize_t; # endif -# define NOMINMAX 1 //Don't override std::min and std::max # else # ifdef _WIN64 typedef int64_t ssize_t; @@ -110,16 +109,20 @@ typedef int32_t ssize_t; #define INT32_MAX 0x7fffffff #endif -#include "file_reader.hpp" +class FileAndMemReader; #ifndef OPNMIDI_DISABLE_MIDI_SEQUENCER // Rename class to avoid ABI collisions #define BW_MidiSequencer OpnMidiSequencer -#include "midi_sequencer.hpp" +class BW_MidiSequencer; typedef BW_MidiSequencer MidiSequencer; +typedef struct BW_MidiRtInterface BW_MidiRtInterface; #endif//OPNMIDI_DISABLE_MIDI_SEQUENCER -#include "chips/opn_chip_base.h" +class OPN2; +class OPNChipBase; + +typedef class OPN2 Synth; #include "opnbank.h" @@ -127,13 +130,10 @@ typedef BW_MidiSequencer MidiSequencer; #include "opnmidi.h" //Main API #include "opnmidi_ptr.hpp" -#include "opnmidi_bankmap.h" -#define ADL_UNUSED(x) (void)x +class MIDIplay; -#define OPN_PANNING_LEFT 0x80 -#define OPN_PANNING_RIGHT 0x40 -#define OPN_PANNING_BOTH 0xC0 +#define ADL_UNUSED(x) (void)x #define OPN_MAX_CHIPS 100 #define OPN_MAX_CHIPS_STR "100" @@ -185,1203 +185,8 @@ inline int32_t opn2_cvtU32(int32_t x) return (uint32_t)opn2_cvtS32(x) - (uint32_t)INT32_MIN; } -class OPNMIDIplay; -/** - * @brief OPN2 Chip management class - */ -class OPN2 -{ - friend class OPNMIDIplay; -public: - enum { PercussionTag = 1 << 15 }; - - //! Total number of chip channels between all running emulators - uint32_t m_numChannels; - //! Just a padding. Reserved. - char _padding[4]; - //! Running chip emulators - std::vector > m_chips; -private: - //! Cached patch data, needed by Touch() - std::vector m_insCache; - //! Cached per-channel LFO sensitivity flags - std::vector m_regLFOSens; - //! LFO setup registry cache - uint8_t m_regLFOSetup; - -public: - /** - * @brief MIDI bank entry - */ - struct Bank - { - //! MIDI Bank instruments - opnInstMeta2 ins[128]; - }; - typedef BasicBankMap BankMap; - //! MIDI bank instruments data - BankMap m_insBanks; - //! MIDI bank-wide setup - OpnBankSetup m_insBankSetup; - -public: - //! Blank instrument template - static const opnInstMeta2 m_emptyInstrument; - - //! Total number of running concurrent emulated chips - uint32_t m_numChips; - //! Carriers-only are scaled by default by volume level. This flag will tell to scale modulators too. - bool m_scaleModulators; - //! Run emulator at PCM rate if that possible. Reduces sounding accuracy, but decreases CPU usage on lower rates. - bool m_runAtPcmRate; - //! Enable soft panning - bool m_softPanning; - - //! Just a padding. Reserved. - char _padding2[3]; - - /** - * @brief Music playing mode - */ - enum MusicMode - { - //! MIDI mode - MODE_MIDI, - //! Id-Software Music mode - MODE_IMF, - //! Creative Music Files mode - MODE_CMF, - //! EA-MUS (a.k.a. RSXX) mode - MODE_RSXX - } m_musicMode; - - /** - * @brief Volume models enum - */ - enum VolumesScale - { - //! Generic volume model (linearization of logarithmic scale) - VOLUME_Generic, - //! OPN2 native logarithmic scale - VOLUME_NATIVE, - //! DMX volume scale logarithmic table - VOLUME_DMX, - //! Apoge Sound System volume scaling model - VOLUME_APOGEE, - //! Windows 9x driver volume scale table - VOLUME_9X - } m_volumeScale; - - //! Reserved - bool m_lfoEnable; - uint8_t m_lfoFrequency; - - //! Category of the channel - /*! 1 = DAC, 0 = regular - */ - std::vector m_channelCategory; - - - /** - * @brief C.O. Constructor - */ - OPN2(); - - /** - * @brief C.O. Destructor - */ - ~OPN2(); - - /** - * @brief Checks are setup locked to be changed on the fly or not - * @return true when setup on the fly is locked - */ - bool setupLocked(); - - /** - * @brief Write data to OPN2 chip register - * @param chip Index of emulated chip. In hardware OPN2 builds, this parameter is ignored - * @param port Port of the chip to write - * @param index Register address to write - * @param value Value to write - */ - void writeReg(size_t chip, uint8_t port, uint8_t index, uint8_t value); - - /** - * @brief Write data to OPN2 chip register - * @param chip Index of emulated chip. In hardware OPN2 builds, this parameter is ignored - * @param port Port of the chip to write - * @param index Register address to write - * @param value Value to write - */ - void writeRegI(size_t chip, uint8_t port, uint32_t index, uint32_t value); - - /** - * @brief Write to soft panning control of OPN2 chip emulator - * @param chip Index of emulated chip. - * @param address Register of channel to write - * @param value Value to write - */ - void writePan(size_t chip, uint32_t index, uint32_t value); - - /** - * @brief Off the note in specified chip channel - * @param c Channel of chip (Emulated chip choosing by next formula: [c = ch + (chipId * 23)]) - */ - void noteOff(size_t c); - - /** - * @brief On the note in specified chip channel with specified frequency of the tone - * @param c Channel of chip (Emulated chip choosing by next formula: [c = ch + (chipId * 23)]) - * @param hertz Frequency of the tone in hertzes - */ - void noteOn(size_t c, double hertz); - - /** - * @brief Change setup of instrument in specified chip channel - * @param c Channel of chip (Emulated chip choosing by next formula: [c = ch + (chipId * 23)]) - * @param volume Volume level (from 0 to 127) - * @param brightness CC74 Brightness level (from 0 to 127) - */ - void touchNote(size_t c, uint8_t volume, uint8_t brightness = 127); - - /** - * @brief Set the instrument into specified chip channel - * @param c Channel of chip (Emulated chip choosing by next formula: [c = ch + (chipId * 23)]) - * @param instrument Instrument data to set into the chip channel - */ - void setPatch(size_t c, const opnInstData &instrument); - - /** - * @brief Set panpot position - * @param c Channel of chip (Emulated chip choosing by next formula: [c = ch + (chipId * 23)]) - * @param value 3-bit panpot value - */ - void setPan(size_t c, uint8_t value); - - /** - * @brief Shut up all chip channels - */ - void silenceAll(); - - /** - * @brief commit LFO enable and frequency - */ - void commitLFOSetup(); - - /** - * @brief Set the volume scaling model - * @param volumeModel Type of volume scale model scale - */ - void setVolumeScaleModel(OPNMIDI_VolumeModels volumeModel); - - /** - * @brief Get the volume scaling model - */ - OPNMIDI_VolumeModels getVolumeScaleModel(); - - /** - * @brief Clean up all running emulated chip instances - */ - void clearChips(); - - /** - * @brief Reset chip properties and initialize them - * @param emulator Type of chip emulator - * @param PCM_RATE Output sample rate to generate on output - * @param audioTickHandler PCM-accurate clock hook - */ - void reset(int emulator, unsigned long PCM_RATE, void *audioTickHandler); -}; - - -/** - * @brief Hooks of the internal events - */ -struct MIDIEventHooks -{ - MIDIEventHooks() : - onNote(NULL), - onNote_userData(NULL), - onDebugMessage(NULL), - onDebugMessage_userData(NULL) - {} - - //! Note on/off hooks - typedef void (*NoteHook)(void *userdata, int adlchn, int note, int ins, int pressure, double bend); - NoteHook onNote; - void *onNote_userData; - - //! Library internal debug messages - typedef void (*DebugMessageHook)(void *userdata, const char *fmt, ...); - DebugMessageHook onDebugMessage; - void *onDebugMessage_userData; -}; - - -class OPNMIDIplay -{ - friend void opn2_reset(struct OPN2_MIDIPlayer*); -public: - explicit OPNMIDIplay(unsigned long sampleRate = 22050); - - ~OPNMIDIplay() - {} - - void applySetup(); - - void partialReset(); - void resetMIDI(); - - /**********************Internal structures and classes**********************/ - - /** - * @brief Persistent settings for each MIDI channel - */ - struct MIDIchannel - { - //! LSB Bank number - uint8_t bank_lsb, - //! MSB Bank number - bank_msb; - //! Current patch number - uint8_t patch; - //! Volume level - uint8_t volume, - //! Expression level - expression; - //! Panning level - uint8_t panning, - //! Vibrato level - vibrato, - //! Channel aftertouch level - aftertouch; - //! Portamento time - uint16_t portamento; - //! Is Pedal sustain active - bool sustain; - //! Is Soft pedal active - bool softPedal; - //! Is portamento enabled - bool portamentoEnable; - //! Source note number used by portamento - int8_t portamentoSource; // note number or -1 - //! Portamento rate - double portamentoRate; - //! Per note Aftertouch values - uint8_t noteAftertouch[128]; - //! Is note aftertouch has any non-zero value - bool noteAfterTouchInUse; - //! Reserved - char _padding[6]; - //! Pitch bend value - int bend; - //! Pitch bend sensitivity - double bendsense; - //! Pitch bend sensitivity LSB value - int bendsense_lsb, - //! Pitch bend sensitivity MSB value - bendsense_msb; - //! Vibrato position value - double vibpos, - //! Vibrato speed value - vibspeed, - //! Vibrato depth value - vibdepth; - //! Vibrato delay time - int64_t vibdelay_us; - //! Last LSB part of RPN value received - uint8_t lastlrpn, - //! Last MSB poart of RPN value received - lastmrpn; - //! Interpret RPN value as NRPN - bool nrpn; - //! Brightness level - uint8_t brightness; - - //! Is melodic channel turned into percussion - bool is_xg_percussion; - - /** - * @brief Per-Note information - */ - struct NoteInfo - { - //! Note number - uint8_t note; - //! Is note active - bool active; - //! Current pressure - uint8_t vol; - //! Note vibrato (a part of Note Aftertouch feature) - uint8_t vibrato; - //! Tone selected on noteon: - int16_t noteTone; - //! Current tone (!= noteTone if gliding note) - double currentTone; - //! Gliding rate - double glideRate; - //! Patch selected on noteon; index to bank.ins[] - size_t midiins; - //! Is note the percussion instrument - bool isPercussion; - //! Note that plays missing instrument. Doesn't using any chip channels - bool isBlank; - //! Patch selected - const opnInstMeta2 *ains; - enum - { - MaxNumPhysChans = 2, - MaxNumPhysItemCount = MaxNumPhysChans, - }; - - /** - * @brief Reference to currently using chip channel - */ - struct Phys - { - //! Destination chip channel - uint16_t chip_chan; - //! ins, inde to adl[] - opnInstData ains; - - void assign(const Phys &oth) - { - ains = oth.ains; - } - bool operator==(const Phys &oth) const - { - return (ains == oth.ains); - } - bool operator!=(const Phys &oth) const - { - return !operator==(oth); - } - }; - - //! List of OPN2 channels it is currently occupying. - Phys chip_channels[MaxNumPhysItemCount]; - //! Count of used channels. - unsigned chip_channels_count; - - Phys *phys_find(unsigned chip_chan) - { - Phys *ph = NULL; - for(unsigned i = 0; i < chip_channels_count && !ph; ++i) - if(chip_channels[i].chip_chan == chip_chan) - ph = &chip_channels[i]; - return ph; - } - Phys *phys_find_or_create(uint16_t chip_chan) - { - Phys *ph = phys_find(chip_chan); - if(!ph) { - if(chip_channels_count < MaxNumPhysItemCount) { - ph = &chip_channels[chip_channels_count++]; - ph->chip_chan = chip_chan; - } - } - return ph; - } - Phys *phys_ensure_find_or_create(uint16_t chip_chan) - { - Phys *ph = phys_find_or_create(chip_chan); - assert(ph); - return ph; - } - void phys_erase_at(const Phys *ph) - { - intptr_t pos = ph - chip_channels; - assert(pos < static_cast(chip_channels_count)); - for(intptr_t i = pos + 1; i < static_cast(chip_channels_count); ++i) - chip_channels[i - 1] = chip_channels[i]; - --chip_channels_count; - } - void phys_erase(unsigned chip_chan) - { - Phys *ph = phys_find(chip_chan); - if(ph) - phys_erase_at(ph); - } - }; - - //! Reserved - char _padding2[5]; - //! Count of gliding notes in this channel - unsigned gliding_note_count; - - //! Active notes in the channel - NoteInfo activenotes[128]; - - struct activenoteiterator - { - explicit activenoteiterator(NoteInfo *info = NULL) - : ptr(info) {} - activenoteiterator &operator++() - { - if(ptr->note == 127) - ptr = NULL; - else - for(++ptr; ptr && !ptr->active;) - ptr = (ptr->note == 127) ? NULL : (ptr + 1); - return *this; - } - activenoteiterator operator++(int) - { - activenoteiterator pos = *this; - ++*this; - return pos; - } - NoteInfo &operator*() const - { return *ptr; } - NoteInfo *operator->() const - { return ptr; } - bool operator==(activenoteiterator other) const - { return ptr == other.ptr; } - bool operator!=(activenoteiterator other) const - { return ptr != other.ptr; } - operator NoteInfo *() const - { return ptr; } - private: - NoteInfo *ptr; - }; - - activenoteiterator activenotes_begin() - { - activenoteiterator it(activenotes); - return (it->active) ? it : ++it; - } - - activenoteiterator activenotes_find(uint8_t note) - { - assert(note < 128); - return activenoteiterator( - activenotes[note].active ? &activenotes[note] : NULL); - } - - activenoteiterator activenotes_ensure_find(uint8_t note) - { - activenoteiterator it = activenotes_find(note); - assert(it); - return it; - } - - std::pair activenotes_insert(uint8_t note) - { - assert(note < 128); - NoteInfo &info = activenotes[note]; - bool inserted = !info.active; - if(inserted) info.active = true; - return std::pair(activenoteiterator(&info), inserted); - } - - void activenotes_erase(activenoteiterator pos) - { - if(pos) - pos->active = false; - } - - bool activenotes_empty() - { - return !activenotes_begin(); - } - - void activenotes_clear() - { - for(uint8_t i = 0; i < 128; ++i) { - activenotes[i].note = i; - activenotes[i].active = false; - } - } - - /** - * @brief Reset channel into initial state - */ - void reset() - { - resetAllControllers(); - patch = 0; - vibpos = 0; - bank_lsb = 0; - bank_msb = 0; - lastlrpn = 0; - lastmrpn = 0; - nrpn = false; - is_xg_percussion = false; - } - - /** - * @brief Reset all MIDI controllers into initial state - */ - void resetAllControllers() - { - bend = 0; - bendsense_msb = 2; - bendsense_lsb = 0; - updateBendSensitivity(); - volume = 100; - expression = 127; - sustain = false; - softPedal = false; - vibrato = 0; - aftertouch = 0; - std::memset(noteAftertouch, 0, 128); - noteAfterTouchInUse = false; - vibspeed = 2 * 3.141592653 * 5.0; - vibdepth = 0.5 / 127; - vibdelay_us = 0; - panning = 64; - portamento = 0; - portamentoEnable = false; - portamentoSource = -1; - portamentoRate = HUGE_VAL; - brightness = 127; - } - - /** - * @brief Has channel vibrato to process - * @return - */ - bool hasVibrato() - { - return (vibrato > 0) || (aftertouch > 0) || noteAfterTouchInUse; - } - - /** - * @brief Commit pitch bend sensitivity value from MSB and LSB - */ - void updateBendSensitivity() - { - int cent = bendsense_msb * 128 + bendsense_lsb; - bendsense = cent * (1.0 / (128 * 8192)); - } - - MIDIchannel() - { - activenotes_clear(); - gliding_note_count = 0; - reset(); - } - }; - - /** - * @brief Additional information about OPN2 channels - */ - struct OpnChannel - { - struct Location - { - uint16_t MidCh; - uint8_t note; - bool operator==(const Location &l) const - { return MidCh == l.MidCh && note == l.note; } - bool operator!=(const Location &l) const - { return !operator==(l); } - char _padding[1]; - }; - struct LocationData - { - LocationData *prev, *next; - Location loc; - enum { - Sustain_None = 0x00, - Sustain_Pedal = 0x01, - Sustain_Sostenuto = 0x02, - Sustain_ANY = Sustain_Pedal | Sustain_Sostenuto, - }; - uint32_t sustained; - char _padding[3]; - MIDIchannel::NoteInfo::Phys ins; // a copy of that in phys[] - //! Has fixed sustain, don't iterate "on" timeout - bool fixed_sustain; - //! Timeout until note will be allowed to be killed by channel manager while it is on - int64_t kon_time_until_neglible_us; - int64_t vibdelay_us; - }; - - //! Time left until sounding will be muted after key off - int64_t koff_time_until_neglible_us; - - //! Recently passed instrument, improves a goodness of released but busy channel when matching - MIDIchannel::NoteInfo::Phys recent_ins; - - enum { users_max = 128 }; - LocationData *users_first, *users_free_cells; - LocationData users_cells[users_max]; - unsigned users_size; - - bool users_empty() const; - LocationData *users_find(Location loc); - LocationData *users_allocate(); - LocationData *users_find_or_create(Location loc); - LocationData *users_insert(const LocationData &x); - void users_erase(LocationData *user); - void users_clear(); - void users_assign(const LocationData *users, size_t count); - - // For channel allocation: - OpnChannel(): koff_time_until_neglible_us(0) - { - users_clear(); - std::memset(&recent_ins, 0, sizeof(MIDIchannel::NoteInfo::Phys)); - } - - OpnChannel(const OpnChannel &oth): koff_time_until_neglible_us(oth.koff_time_until_neglible_us) - { - if(oth.users_first) - { - users_first = NULL; - users_assign(oth.users_first, oth.users_size); - } - else - users_clear(); - } - - OpnChannel &operator=(const OpnChannel &oth) - { - koff_time_until_neglible_us = oth.koff_time_until_neglible_us; - users_assign(oth.users_first, oth.users_size); - return *this; - } - - /** - * @brief Increases age of active note in microseconds time - * @param us Amount time in microseconds - */ - void addAge(int64_t us); - }; - -#ifndef OPNMIDI_DISABLE_MIDI_SEQUENCER - /** - * @brief MIDI files player sequencer - */ - MidiSequencer m_sequencer; - - /** - * @brief Interface between MIDI sequencer and this library - */ - BW_MidiRtInterface m_sequencerInterface; - - /** - * @brief Initialize MIDI sequencer interface - */ - void initSequencerInterface(); -#endif //OPNMIDI_DISABLE_MIDI_SEQUENCER - - struct Setup - { - int emulator; - bool runAtPcmRate; - unsigned int OpnBank; - unsigned int numChips; - unsigned int LogarithmicVolumes; - int VolumeModel; - int lfoEnable; - int lfoFrequency; - //unsigned int SkipForward; - int ScaleModulators; - bool fullRangeBrightnessCC74; - - double delay; - double carry; - - /* The lag between visual content and audio content equals */ - /* the sum of these two buffers. */ - double mindelay; - double maxdelay; - - /* For internal usage */ - ssize_t tick_skip_samples_delay; /* Skip tick processing after samples count. */ - /* For internal usage */ - - unsigned long PCM_RATE; - }; - - /** - * @brief MIDI Marker entry - */ - struct MIDI_MarkerEntry - { - //! Label of marker - std::string label; - //! Absolute position in seconds - double pos_time; - //! Absolute position in ticks in the track - uint64_t pos_ticks; - }; - - //! Available MIDI Channels - std::vector m_midiChannels; - - //! Master volume, controlled via SysEx - uint8_t m_masterVolume; - - //! SysEx device ID - uint8_t m_sysExDeviceId; - - /** - * @brief MIDI Synthesizer mode - */ - enum SynthMode - { - Mode_GM = 0x00, - Mode_GS = 0x01, - Mode_XG = 0x02, - Mode_GM2 = 0x04, - }; - //! MIDI Synthesizer mode - uint32_t m_synthMode; - - //! Installed function hooks - MIDIEventHooks hooks; - -private: - //! Per-track MIDI devices map - std::map m_midiDevices; - //! Current MIDI device per track - std::map m_currentMidiDevice; - - //! Chip channels map - std::vector m_chipChannels; - //! Counter of arpeggio processing - size_t m_arpeggioCounter; - -#if defined(ADLMIDI_AUDIO_TICK_HANDLER) - //! Audio tick counter - uint32_t m_audioTickCounter; -#endif - - //! Local error string - std::string errorStringOut; - - //! Missing instruments catches - std::set caugh_missing_instruments; - //! Missing melodic banks catches - std::set caugh_missing_banks_melodic; - //! Missing percussion banks catches - std::set caugh_missing_banks_percussion; - -public: - - const std::string &getErrorString(); - void setErrorString(const std::string &err); - - //! OPN2 Chip manager - OPN2 m_synth; - - //! Generator output buffer - int32_t m_outBuf[1024]; - - //! Synthesizer setup - Setup m_setup; - - /** - * @brief Load bank from file - * @param filename Path to bank file - * @return true on succes - */ - bool LoadBank(const std::string &filename); - - /** - * @brief Load bank from memory block - * @param data Pointer to memory block where raw bank file is stored - * @param size Size of given memory block - * @return true on succes - */ - bool LoadBank(const void *data, size_t size); - - /** - * @brief Load bank from opened FileAndMemReader class - * @param fr Instance with opened file - * @return true on succes - */ - bool LoadBank(FileAndMemReader &fr); - -#ifndef OPNMIDI_DISABLE_MIDI_SEQUENCER - /** - * @brief MIDI file loading pre-process - * @return true on success, false on failure - */ - bool LoadMIDI_pre(); - - /** - * @brief MIDI file loading post-process - * @return true on success, false on failure - */ - bool LoadMIDI_post(); - - /** - * @brief Load music file from a file - * @param filename Path to music file - * @return true on success, false on failure - */ - - bool LoadMIDI(const std::string &filename); - - /** - * @brief Load music file from the memory block - * @param data pointer to the memory block - * @param size size of memory block - * @return true on success, false on failure - */ - bool LoadMIDI(const void *data, size_t size); - - /** - * @brief Periodic tick handler. - * @param s seconds since last call - * @param granularity don't expect intervals smaller than this, in seconds - * @return desired number of seconds until next call - */ - double Tick(double s, double granularity); -#endif //OPNMIDI_DISABLE_MIDI_SEQUENCER - - /** - * @brief Process extra iterators like vibrato or arpeggio - * @param s seconds since last call - */ - void TickIterators(double s); - - - /* RealTime event triggers */ - /** - * @brief Reset state of all channels - */ - void realTime_ResetState(); - - /** - * @brief Note On event - * @param channel MIDI channel - * @param note Note key (from 0 to 127) - * @param velocity Velocity level (from 0 to 127) - * @return true if Note On event was accepted - */ - bool realTime_NoteOn(uint8_t channel, uint8_t note, uint8_t velocity); - - /** - * @brief Note Off event - * @param channel MIDI channel - * @param note Note key (from 0 to 127) - */ - void realTime_NoteOff(uint8_t channel, uint8_t note); - - /** - * @brief Note aftertouch event - * @param channel MIDI channel - * @param note Note key (from 0 to 127) - * @param atVal After-Touch level (from 0 to 127) - */ - void realTime_NoteAfterTouch(uint8_t channel, uint8_t note, uint8_t atVal); - - /** - * @brief Channel aftertouch event - * @param channel MIDI channel - * @param atVal After-Touch level (from 0 to 127) - */ - void realTime_ChannelAfterTouch(uint8_t channel, uint8_t atVal); - - /** - * @brief Controller Change event - * @param channel MIDI channel - * @param type Type of controller - * @param value Value of the controller (from 0 to 127) - */ - void realTime_Controller(uint8_t channel, uint8_t type, uint8_t value); - - /** - * @brief Patch change - * @param channel MIDI channel - * @param patch Patch Number (from 0 to 127) - */ - void realTime_PatchChange(uint8_t channel, uint8_t patch); - - /** - * @brief Pitch bend change - * @param channel MIDI channel - * @param pitch Concoctated raw pitch value - */ - void realTime_PitchBend(uint8_t channel, uint16_t pitch); - - /** - * @brief Pitch bend change - * @param channel MIDI channel - * @param msb MSB of pitch value - * @param lsb LSB of pitch value - */ - void realTime_PitchBend(uint8_t channel, uint8_t msb, uint8_t lsb); - - /** - * @brief LSB Bank Change CC - * @param channel MIDI channel - * @param lsb LSB value of bank number - */ - void realTime_BankChangeLSB(uint8_t channel, uint8_t lsb); - - /** - * @brief MSB Bank Change CC - * @param channel MIDI channel - * @param lsb MSB value of bank number - */ - void realTime_BankChangeMSB(uint8_t channel, uint8_t msb); - - /** - * @brief Bank Change (united value) - * @param channel MIDI channel - * @param bank Bank number value - */ - void realTime_BankChange(uint8_t channel, uint16_t bank); - - /** - * @brief Sets the Device identifier - * @param id 7-bit Device identifier - */ - void setDeviceId(uint8_t id); - - /** - * @brief System Exclusive message - * @param msg Raw SysEx Message - * @param size Length of SysEx message - * @return true if message was passed successfully. False on any errors - */ - bool realTime_SysEx(const uint8_t *msg, size_t size); - - /** - * @brief Turn off all notes and mute the sound of releasing notes - */ - void realTime_panic(); - - /** - * @brief Device switch (to extend 16-channels limit of MIDI standard) - * @param track MIDI track index - * @param data Device name - * @param length Length of device name string - */ - void realTime_deviceSwitch(size_t track, const char *data, size_t length); - - /** - * @brief Currently selected device index - * @param track MIDI track index - * @return Multiple 16 value - */ - size_t realTime_currentDevice(size_t track); - -#if defined(ADLMIDI_AUDIO_TICK_HANDLER) - // Audio rate tick handler - void AudioTick(uint32_t chipId, uint32_t rate); -#endif - -private: - /** - * @brief Hardware manufacturer (Used for SysEx) - */ - enum - { - Manufacturer_Roland = 0x41, - Manufacturer_Yamaha = 0x43, - Manufacturer_UniversalNonRealtime = 0x7E, - Manufacturer_UniversalRealtime = 0x7F - }; - - /** - * @brief Roland Mode (Used for SysEx) - */ - enum - { - RolandMode_Request = 0x11, - RolandMode_Send = 0x12 - }; - - /** - * @brief Device model (Used for SysEx) - */ - enum - { - RolandModel_GS = 0x42, - RolandModel_SC55 = 0x45, - YamahaModel_XG = 0x4C - }; - - /** - * @brief Process generic SysEx events - * @param dev Device ID - * @param realtime Is real-time event - * @param data Raw SysEx data - * @param size Size of given SysEx data - * @return true when event was successfully handled - */ - bool doUniversalSysEx(unsigned dev, bool realtime, const uint8_t *data, size_t size); - - /** - * @brief Process events specific to Roland devices - * @param dev Device ID - * @param data Raw SysEx data - * @param size Size of given SysEx data - * @return true when event was successfully handled - */ - bool doRolandSysEx(unsigned dev, const uint8_t *data, size_t size); - - /** - * @brief Process events specific to Yamaha devices - * @param dev Device ID - * @param data Raw SysEx data - * @param size Size of given SysEx data - * @return true when event was successfully handled - */ - bool doYamahaSysEx(unsigned dev, const uint8_t *data, size_t size); - -private: - /** - * @brief Note Update properties - */ - enum - { - Upd_Patch = 0x1, - Upd_Pan = 0x2, - Upd_Volume = 0x4, - Upd_Pitch = 0x8, - Upd_All = Upd_Pan + Upd_Volume + Upd_Pitch, - Upd_Off = 0x20, - Upd_Mute = 0x40, - Upd_OffMute = Upd_Off + Upd_Mute - }; - - /** - * @brief Update active note - * @param MidCh MIDI Channel where note is processing - * @param i Iterator that points to active note in the MIDI channel - * @param props_mask Properties to update - * @param select_adlchn Specify chip channel, or -1 - all chip channels used by the note - */ - void noteUpdate(size_t midCh, - MIDIchannel::activenoteiterator i, - unsigned props_mask, - int32_t select_adlchn = -1); - - void noteUpdateAll(size_t midCh, unsigned props_mask); - - /** - * @brief Determine how good a candidate this adlchannel would be for playing a note from this instrument. - * @param c Wanted chip channel - * @param ins Instrument wanted to be used in this channel - * @return Calculated coodness points - */ - int64_t calculateChipChannelGoodness(size_t c, const MIDIchannel::NoteInfo::Phys &ins) const; - - /** - * @brief A new note will be played on this channel using this instrument. - * @param c Wanted chip channel - * @param ins Instrument wanted to be used in this channel - * Kill existing notes on this channel (or don't, if we do arpeggio) - */ - void prepareChipChannelForNewNote(size_t c, const MIDIchannel::NoteInfo::Phys &ins); - - /** - * @brief Kills note that uses wanted channel. When arpeggio is possible, note is evaluating to another channel - * @param from_channel Wanted chip channel - * @param j Chip channel instance - * @param i MIDI Channel active note instance - */ - void killOrEvacuate( - size_t from_channel, - OpnChannel::LocationData *j, - MIDIchannel::activenoteiterator i); - - /** - * @brief Off all notes and silence sound - */ - void panic(); - - /** - * @brief Kill note, sustaining by pedal or sostenuto - * @param MidCh MIDI channel, -1 - all MIDI channels - * @param this_adlchn Chip channel, -1 - all chip channels - * @param sustain_type Type of systain to process - */ - void killSustainingNotes(int32_t midCh = -1, - int32_t this_adlchn = -1, - uint32_t sustain_type = OpnChannel::LocationData::Sustain_ANY); - /** - * @brief Find active notes and mark them as sostenuto-sustained - * @param MidCh MIDI channel, -1 - all MIDI channels - */ - void markSostenutoNotes(int32_t midCh = -1); - - /** - * @brief Set RPN event value - * @param MidCh MIDI channel - * @param value 1 byte part of RPN value - * @param MSB is MSB or LSB part of value - */ - void setRPN(size_t midCh, unsigned value, bool MSB); - - /** - * @brief Update portamento setup in MIDI channel - * @param midCh MIDI channel where portamento needed to be updated - */ - void updatePortamento(size_t midCh); - - /** - * @brief Off the note - * @param midCh MIDI channel - * @param note Note to off - */ - void noteOff(size_t midCh, uint8_t note); - - /** - * @brief Update processing of vibrato to amount of seconds - * @param amount Amount value in seconds - */ - void updateVibrato(double amount); - - /** - * @brief Update auto-arpeggio - * @param amount Amount value in seconds [UNUSED] - */ - void updateArpeggio(double /*amount*/); - - /** - * @brief Update Portamento gliding to amount of seconds - * @param amount Amount value in seconds - */ - void updateGlide(double amount); - -public: - /** - * @brief Checks was device name used or not - * @param name Name of MIDI device - * @return Offset of the MIDI Channels, multiple to 16 - */ - size_t chooseDevice(const std::string &name); - - /** - * @brief Gets a textual description of the state of chip channels - * @param text character pointer for text - * @param attr character pointer for text attributes - * @param size number of characters available to write - */ - void describeChannels(char *text, char *attr, size_t size); -}; - #if defined(ADLMIDI_AUDIO_TICK_HANDLER) extern void opn2_audioTickHandler(void *instance, uint32_t chipId, uint32_t rate); #endif -/** - * @brief Check emulator availability - * @param emulator Emulator ID (Opn2_Emulator) - * @return true when emulator is available - */ -extern bool opn2_isEmulatorAvailable(int emulator); - -/** - * @brief Find highest emulator - * @return The Opn2_Emulator enum value which contains ID of highest emulator - */ -extern int opn2_getHighestEmulator(); - -/** - * @brief Find lowest emulator - * @return The Opn2_Emulator enum value which contains ID of lowest emulator - */ -extern int opn2_getLowestEmulator(); - #endif // ADLMIDI_PRIVATE_HPP diff --git a/thirdparty/opnmidi/opnmidi_ptr.hpp b/thirdparty/opnmidi/opnmidi_ptr.hpp index 14e7591..590fa55 100644 --- a/thirdparty/opnmidi/opnmidi_ptr.hpp +++ b/thirdparty/opnmidi/opnmidi_ptr.hpp @@ -1,8 +1,8 @@ /* - * libOPNMIDI is a free MIDI to WAV conversion library with OPN2 (YM2612) emulation + * libOPNMIDI is a free Software MIDI synthesizer library with OPN2 (YM2612) emulation * * MIDI parser and player (Original code from ADLMIDI): Copyright (c) 2010-2014 Joel Yliluoma - * ADLMIDI Library API: Copyright (c) 2015-2018 Vitaly Novichkov + * ADLMIDI Library API: Copyright (c) 2015-2020 Vitaly Novichkov * * Library is based on the ADLMIDI, a MIDI player for Linux and Windows with OPL3 emulation: * http://iki.fi/bisqwit/source/adlmidi.html @@ -54,7 +54,7 @@ class AdlMIDI_UPtr { T *m_p; public: - explicit AdlMIDI_UPtr(T *p) + explicit AdlMIDI_UPtr(T *p = NULL) : m_p(p) {} ~AdlMIDI_UPtr() { diff --git a/thirdparty/opnmidi/structures/pl_list.hpp b/thirdparty/opnmidi/structures/pl_list.hpp new file mode 100644 index 0000000..0cbd233 --- /dev/null +++ b/thirdparty/opnmidi/structures/pl_list.hpp @@ -0,0 +1,133 @@ +// Copyright Jean Pierre Cimalando 2018. +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#ifndef PL_LIST_HPP +#define PL_LIST_HPP + +#include +#include + +/* + pl_cell: the linked list cell + */ +template +struct pl_cell; + +template +struct pl_basic_cell +{ + pl_cell *prev, *next; +}; + +template +struct pl_cell : pl_basic_cell +{ + T value; +}; + +/* + pl_iterator: the linked list iterator + */ +template +class pl_iterator +{ +public: + typedef std::bidirectional_iterator_tag iterator_category; + typedef Cell value_type; + typedef Cell &reference; + typedef Cell *pointer; + typedef std::ptrdiff_t difference_type; + + pl_iterator(Cell *cell = NULL); + bool is_end() const; + Cell &operator*() const; + Cell *operator->() const; + bool operator==(const pl_iterator &i) const; + bool operator!=(const pl_iterator &i) const; + pl_iterator &operator++(); + pl_iterator operator++(int); + pl_iterator &operator--(); + pl_iterator operator--(int); + +private: + Cell *cell_; +}; + +/* + pl_list: the preallocated linked list + */ +template +class pl_list +{ +public: + typedef pl_cell value_type; + typedef value_type *pointer; + typedef value_type &reference; + typedef const value_type *const_pointer; + typedef const value_type &const_reference; + typedef pl_iterator< pl_cell > iterator; + typedef pl_iterator< const pl_cell > const_iterator; + + pl_list(std::size_t capacity = 0); + ~pl_list(); + + struct external_storage_policy {}; + pl_list(pl_cell *cells, std::size_t ncells, external_storage_policy); + + pl_list(const pl_list &other); + pl_list &operator=(const pl_list &other); + + std::size_t size() const; + std::size_t capacity() const; + bool empty() const; + + iterator begin(); + iterator end(); + const_iterator begin() const; + const_iterator end() const; + + void clear(); + + pl_cell &front(); + const pl_cell &front() const; + pl_cell &back(); + const pl_cell &back() const; + + iterator insert(iterator pos, const T &x); + iterator erase(iterator pos); + void push_front(const T &x); + void push_back(const T &x); + void pop_front(); + void pop_back(); + + iterator find(const T &x); + const_iterator find(const T &x) const; + template iterator find_if(const Pred &p); + template const_iterator find_if(const Pred &p) const; + +private: + // number of cells in the list + std::size_t size_; + // number of cells allocated + std::size_t capacity_; + // array of cells allocated + pl_cell *cells_; + // pointer to the head cell + pl_cell *first_; + // pointer to the next free cell + pl_cell *free_; + // value-less cell which terminates the linked list + pl_basic_cell endcell_; + // whether cell storage is allocated + bool cells_allocd_; + + void initialize(std::size_t capacity, pl_cell *extcells = NULL); + pl_cell *allocate(pl_cell *pos); + void deallocate(pl_cell *cell); +}; + +#include "pl_list.tcc" + +#endif // PL_LIST_HPP diff --git a/thirdparty/opnmidi/structures/pl_list.tcc b/thirdparty/opnmidi/structures/pl_list.tcc new file mode 100644 index 0000000..959b085 --- /dev/null +++ b/thirdparty/opnmidi/structures/pl_list.tcc @@ -0,0 +1,338 @@ +// Copyright Jean Pierre Cimalando 2018. +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include "pl_list.hpp" + +template +pl_iterator::pl_iterator(Cell *cell) + : cell_(cell) +{ +} + +template +bool pl_iterator::is_end() const +{ + return cell_->next == NULL; +} + +template +Cell &pl_iterator::operator*() const +{ + return *cell_; +} + +template +Cell *pl_iterator::operator->() const +{ + return cell_; +} + +template +bool pl_iterator::operator==(const pl_iterator &i) const +{ + return cell_ == i.cell_; +} + +template +bool pl_iterator::operator!=(const pl_iterator &i) const +{ + return cell_ != i.cell_; +} + +template +pl_iterator &pl_iterator::operator++() +{ + cell_ = cell_->next; + return *this; +} + +template +pl_iterator pl_iterator::operator++(int) +{ + pl_iterator i(cell_); + cell_ = cell_->next; + return i; +} + +template +pl_iterator &pl_iterator::operator--() +{ + cell_ = cell_->prev; + return *this; +} + +template +pl_iterator pl_iterator::operator--(int) +{ + pl_iterator i(cell_); + cell_ = cell_->prev; + return i; +} + +template +pl_list::pl_list(std::size_t capacity) +{ + initialize(capacity); +} + +template +pl_list::~pl_list() +{ + if (cells_allocd_) + delete[] cells_; +} + +template +pl_list::pl_list(pl_cell *cells, std::size_t ncells, external_storage_policy) +{ + initialize(ncells, cells); +} + +template +pl_list::pl_list(const pl_list &other) +{ + initialize(other.capacity()); + for(const_iterator i = other.end(), b = other.begin(); i-- != b;) + push_front(i->value); +} + +template +pl_list &pl_list::operator=(const pl_list &other) +{ + if(this != &other) + { + std::size_t size = other.size(); + if(size > capacity()) + { + pl_cell *oldcells = cells_; + bool allocd = cells_allocd_; + initialize(other.capacity()); + if (allocd) + delete[] oldcells; + } + clear(); + for(const_iterator i = other.end(), b = other.begin(); i-- != b;) + push_front(i->value); + } + return *this; +} + +template +std::size_t pl_list::size() const +{ + return size_; +} + +template +std::size_t pl_list::capacity() const +{ + return capacity_; +} + +template +bool pl_list::empty() const +{ + return size_ == 0; +} + +template +typename pl_list::iterator pl_list::begin() +{ + return iterator(first_); +} + +template +typename pl_list::iterator pl_list::end() +{ + return iterator(reinterpret_cast *>(&endcell_)); +} + +template +typename pl_list::const_iterator pl_list::begin() const +{ + return const_iterator(first_); +} + +template +typename pl_list::const_iterator pl_list::end() const +{ + return const_iterator(reinterpret_cast *>(&endcell_)); +} + +template +void pl_list::clear() +{ + std::size_t capacity = capacity_; + pl_cell *cells = cells_; + pl_cell *endcell = &*end(); + size_ = 0; + first_ = endcell; + free_ = cells; + endcell->prev = NULL; + for(std::size_t i = 0; i < capacity; ++i) + { + cells[i].prev = (i > 0) ? &cells[i - 1] : NULL; + cells[i].next = (i + 1 < capacity) ? &cells[i + 1] : NULL; + cells[i].value = T(); + } +} + +template +pl_cell &pl_list::front() +{ + return *first_; +} + +template +const pl_cell &pl_list::front() const +{ + return *first_; +} + +template +pl_cell &pl_list::back() +{ + iterator i = end(); + return *--i; +} + +template +const pl_cell &pl_list::back() const +{ + const_iterator i = end(); + return *--i; +} + +template +typename pl_list::iterator pl_list::insert(iterator pos, const T &x) +{ + pl_cell *cell = allocate(&*pos); + if (!cell) + throw std::bad_alloc(); + cell->value = x; + return iterator(cell); +} + +template +typename pl_list::iterator pl_list::erase(iterator pos) +{ + deallocate(&*(pos++)); + return pos; +} + +template +void pl_list::push_front(const T &x) +{ + insert(begin(), x); +} + +template +void pl_list::push_back(const T &x) +{ + insert(end(), x); +} + +template +void pl_list::pop_front() +{ + deallocate(first_); +} + +template +void pl_list::pop_back() +{ + iterator i(&*end()); + deallocate(&*--i); +} + +template +typename pl_list::iterator pl_list::find(const T &x) +{ + const_iterator i = const_cast *>(this)->find(x); + return iterator(&const_cast(*i)); +} + +template +typename pl_list::const_iterator pl_list::find(const T &x) const +{ + const_iterator e = end(); + for (const_iterator i = begin(); i != e; ++i) + { + if(i->value == x) + return i; + } + return e; +} + +template +template +typename pl_list::iterator pl_list::find_if(const Pred &p) +{ + const_iterator i = const_cast *>(this)->find_if(p); + return iterator(&const_cast(*i)); +} + +template +template +typename pl_list::const_iterator pl_list::find_if(const Pred &p) const +{ + const_iterator e = end(); + for (const_iterator i = begin(); i != e; ++i) + { + if(p(i->value)) + return i; + } + return e; +} + +template +void pl_list::initialize(std::size_t capacity, pl_cell *extcells) +{ + cells_ = extcells ? extcells : new pl_cell[capacity]; + cells_allocd_ = extcells ? false : true; + capacity_ = capacity; + endcell_.next = NULL; + clear(); +} + +template +pl_cell *pl_list::allocate(pl_cell *pos) +{ + // remove free cells front + pl_cell *cell = free_; + if(!cell) + return NULL; + free_ = cell->next; + if(free_) + free_->prev = NULL; + + // insert at position + if (pos == first_) + first_ = cell; + cell->prev = pos->prev; + if (cell->prev) + cell->prev->next = cell; + cell->next = pos; + pos->prev = cell; + + ++size_; + return cell; +} + +template +void pl_list::deallocate(pl_cell *cell) +{ + if(cell->prev) + cell->prev->next = cell->next; + if(cell->next) + cell->next->prev = cell->prev; + if(cell == first_) + first_ = cell->next; + cell->prev = NULL; + cell->next = free_; + cell->value = T(); + free_ = cell; + --size_; +} diff --git a/thirdparty/opnmidi/wopn/wopn_file.c b/thirdparty/opnmidi/wopn/wopn_file.c index f2bea78..8c0cd1f 100644 --- a/thirdparty/opnmidi/wopn/wopn_file.c +++ b/thirdparty/opnmidi/wopn/wopn_file.c @@ -1,7 +1,7 @@ /* * Wohlstand's OPN2 Bank File - a bank format to store OPN2 timbre data and setup * - * Copyright (c) 2018 Vitaly Novichkov + * Copyright (c) 2018-2020 Vitaly Novichkov * * Permission is hereby granted, free of charge, to any person obtaining * a copy of this software and associated documentation files (the "Software"), @@ -82,18 +82,30 @@ static void fromSint16BE(int16_t in, uint8_t *arr) WOPNFile *WOPN_Init(uint16_t melodic_banks, uint16_t percussive_banks) { - WOPNFile *file = NULL; - if(melodic_banks == 0) - return NULL; - if(percussive_banks == 0) - return NULL; - file = (WOPNFile*)calloc(1, sizeof(WOPNFile)); + WOPNFile *file = (WOPNFile*)calloc(1, sizeof(WOPNFile)); if(!file) return NULL; - file->banks_count_melodic = melodic_banks; - file->banks_count_percussion = percussive_banks; - file->banks_melodic = (WOPNBank*)calloc(1, sizeof(WOPNBank) * melodic_banks ); - file->banks_percussive = (WOPNBank*)calloc(1, sizeof(WOPNBank) * percussive_banks ); + + file->banks_count_melodic = (melodic_banks != 0) ? melodic_banks : 1; + file->banks_melodic = (WOPNBank*)calloc(file->banks_count_melodic, sizeof(WOPNBank)); + + if(melodic_banks == 0) + { + unsigned i; + for(i = 0; i < 128; ++i) + file->banks_melodic[0].ins[i].inst_flags = WOPN_Ins_IsBlank; + } + + file->banks_count_percussion = (percussive_banks != 0) ? percussive_banks : 1; + file->banks_percussive = (WOPNBank*)calloc(file->banks_count_percussion, sizeof(WOPNBank)); + + if(percussive_banks == 0) + { + unsigned i; + for(i = 0; i < 128; ++i) + file->banks_percussive[0].ins[i].inst_flags = WOPN_Ins_IsBlank; + } + return file; } @@ -115,6 +127,7 @@ int WOPN_BanksCmp(const WOPNFile *bank1, const WOPNFile *bank2) res &= (bank1->version == bank2->version); res &= (bank1->lfo_freq == bank2->lfo_freq); + res &= (bank1->chip_type == bank2->chip_type); res &= (bank1->volume_model == bank2->volume_model); res &= (bank1->banks_count_melodic == bank2->banks_count_melodic); res &= (bank1->banks_count_percussion == bank2->banks_count_percussion); @@ -285,7 +298,9 @@ WOPNFile *WOPN_LoadBankFromMem(void *mem, size_t length, int *error) } outFile->version = version; - outFile->lfo_freq = head[4]; + outFile->lfo_freq = head[4] & 0xf; + if(version >= 2) + outFile->chip_type = (head[4] >> 4) & 1; outFile->volume_model = 0; } @@ -516,7 +531,9 @@ int WOPN_SaveBankToMem(WOPNFile *file, void *dest_mem, size_t length, uint16_t v if(length < 1) return WOPN_ERR_UNEXPECTED_ENDING; - cursor[0] = file->lfo_freq; + cursor[0] = file->lfo_freq & 0xf; + if (version >= 2) + cursor[0] |= (file->chip_type & 1) << 4; GO_FORWARD(1); bankslots[0] = file->banks_melodic; diff --git a/thirdparty/opnmidi/wopn/wopn_file.h b/thirdparty/opnmidi/wopn/wopn_file.h index cd0d6b4..86fc453 100644 --- a/thirdparty/opnmidi/wopn/wopn_file.h +++ b/thirdparty/opnmidi/wopn/wopn_file.h @@ -1,7 +1,7 @@ /* * Wohlstand's OPN2 Bank File - a bank format to store OPN2 timbre data and setup * - * Copyright (c) 2018 Vitaly Novichkov + * Copyright (c) 2018-2020 Vitaly Novichkov * * Permission is hereby granted, free of charge, to any person obtaining * a copy of this software and associated documentation files (the "Software"), @@ -40,6 +40,15 @@ typedef signed short int int16_t; typedef unsigned short int uint16_t; #endif +/* Type of chip for which a bank has been designed */ +typedef enum WOPN_ChipType +{ + /* The Yamaha OPN2 chip, alias YM2612 YM3438 */ + WOPN_Chip_OPN2 = 0, + /* The Yamaha OPNA chip, alias YM2608 */ + WOPN_Chip_OPNA = 1 +} WOPN_ChipType; + /* Volume scaling model implemented in the libOPNMIDI */ typedef enum WOPN_VolumeModel { @@ -154,6 +163,8 @@ typedef struct WOPNFile uint16_t banks_count_percussion; /* Chip global LFO enable flag and frequency register data */ uint8_t lfo_freq; + /* Chip type this bank is designed for */ + uint8_t chip_type; /* Reserved (Enum WOPN_VolumeModel) */ uint8_t volume_model; /* dynamically allocated data Melodic banks array */ @@ -199,7 +210,7 @@ extern WOPNFile *WOPN_LoadBankFromMem(void *mem, size_t length, int *error); /** * @brief Load WOPI instrument file from the memory. * You must allocate OPNIFile structure by yourself and give the pointer to it. - * @param file Pointer to destinition OPNIFile structure to fill it with parsed data. + * @param file Pointer to destination OPNIFile structure to fill it with parsed data. * @param mem Pointer to memory block contains raw WOPI instrument file data * @param length Length of given memory block * @return 0 if no errors occouped, or an error code of WOPN_ErrorCodes enumeration @@ -209,7 +220,7 @@ extern int WOPN_LoadInstFromMem(OPNIFile *file, void *mem, size_t length); /** * @brief Calculate the size of the output memory block * @param file Heap-allocated WOPN file data structure - * @param version Destinition version of the file + * @param version Destination version of the file * @return Size of the raw WOPN file data */ extern size_t WOPN_CalculateBankFileSize(WOPNFile *file, uint16_t version); @@ -217,7 +228,7 @@ extern size_t WOPN_CalculateBankFileSize(WOPNFile *file, uint16_t version); /** * @brief Calculate the size of the output memory block * @param file Pointer to WOPI file data structure - * @param version Destinition version of the file + * @param version Destination version of the file * @return Size of the raw WOPI file data */ extern size_t WOPN_CalculateInstFileSize(OPNIFile *file, uint16_t version); @@ -225,8 +236,8 @@ extern size_t WOPN_CalculateInstFileSize(OPNIFile *file, uint16_t version); /** * @brief Write raw WOPN into given memory block * @param file Heap-allocated WOPN file data structure - * @param dest_mem Destinition memory block pointer - * @param length Length of destinition memory block + * @param dest_mem Destination memory block pointer + * @param length Length of destination memory block * @param version Wanted WOPN version * @param force_gm Force GM set in saved bank file * @return Error code or 0 on success @@ -236,8 +247,8 @@ extern int WOPN_SaveBankToMem(WOPNFile *file, void *dest_mem, size_t length, uin /** * @brief Write raw WOPI into given memory block * @param file Pointer to WOPI file data structure - * @param dest_mem Destinition memory block pointer - * @param length Length of destinition memory block + * @param dest_mem Destination memory block pointer + * @param length Length of destination memory block * @param version Wanted WOPI version * @return Error code or 0 on success */