////////////////////////////////////////////////////////////////
// CAmiDion - MIDI Chord Helper Mobile
////////////////////////////////////////////////////////////////

#include <avr/pgmspace.h>
#include <MIDI.h>
#include <FlexiTimer2.h>
#include "YMZ294_Serial.h"

// Analog pin #0 = digital pin #14
#define ANALOG_FIRST_PIN  (14)

// 74HC595 shift register to LED
#define LED_DATA_PIN    (2)  // SER(14)
#define LED_CLOCK_PIN   (3)  // SRCLK(11)
#define LED_LATCH_PIN   (4)  // RCLK(12)
#define MIDI_ENABLE_PIN (13) // OE(13) and MIDI ON/OFF

// Button input x 3
#define FIRST_BUTTON_PIN (10) // 10,11,12

#define SSG_WRITE_PIN_0        (8) // 294 CS/WR
#define SSG_WRITE_PIN_1        (14) // 294 CS/WR

// Others
#define VELOCITY_VR_PIN         (5)
#define TILT_SENSOR_PIN         (4 + ANALOG_FIRST_PIN)
#define OCTAVE_VR_PIN           (3)
#define ENVELOPE_PERIOD_VR_PIN  (2)

////////////////////////////////////////////////////////////////
// Tools
////////////////////////////////////////////////////////////////
#define NumberOf(a) (sizeof(a)/sizeof((a)[0]))

unsigned long BigEndian(const byte *a, size_t n) {
  unsigned long result = 0L;
  while(n) { result += *a++; if(--n) result <<= 8; }
  return result;
}

class LoopedValue {
  protected:
    void (*callback)(int value, void *ref);
    void *reference;
    int value, minValue, maxValue;
    unsigned int width;
    void normalize() {
      if( value < minValue ) value += width;
      else if( value > maxValue ) value -= width;
      if( callback != NULL ) (*callback)(value,reference);
    }
  public:
    LoopedValue(
      int initial = 0, int min_value = 0, int max_value = 10,
      unsigned int width = 0,
      void (*change_callback)(int value, void *ref) = NULL,
      void *ref = NULL
    ) {
      value = initial;
      minValue = min_value;
      maxValue = max_value;
      this->width = (width==0) ? 1 + abs(maxValue - minValue) : width;
      callback = change_callback;
      reference = ref;
      normalize();
    }
    int getValue() { return value; }
    void setValue(int value) { this->value = value; normalize(); }
    void setValue(byte value) {
      int v = value;
      if( value >= 0x80 ) v -= 0x100;
      setValue(v);
    }
    void add(int n) { value += n; normalize(); }
};

////////////////////////////////////////////////////////////////
// LED buffer
////////////////////////////////////////////////////////////////
typedef union _LED16 { // Colored 16-LEDs
  unsigned int d2; // 16bit
  byte d1[2];      // 8bit x 2
  struct {
    byte color13:13;
    byte extra0:1;
    byte extra1:1;
    byte extra2:1;
  } b16;
} LED16;
typedef union _LED7seg { // 7-segment LED x 4
  unsigned long d4;    // 4-digit
  unsigned int d2[2];  // 2-digit x 2
  byte d1[4];          // 1-digit x 4, left->right : 0->3
} LED7seg;
typedef union _LEDs { // All LEDs
  unsigned int b16[3]; // 16bit x 3
  struct {
    union _LED16 color16;
    union _LED7seg seg7;
  } screen;
} LEDs;
PROGMEM const prog_char digitsOn7seg[] = {
  // 0     1     2     3     4     5     6     7     8     9
  0x3F, 0x06, 0x5B, 0x4F, 0x66, 0x6D, 0x7D, 0x07, 0x7F, 0x6F,
};
#define DIGIT_7SEG(n) pgm_read_byte(digitsOn7seg+(n))
void LEDprint(byte *out_bufp, byte sz, int n, int zeros=1) {
  out_bufp += sz;
  while( (n > 0 || zeros > 0) && sz > 0 ) {
    *(--out_bufp) = pgm_read_byte( digitsOn7seg + n % 10 );
    n /= 10; zeros--; sz--;
  }
}
void LEDprint(union _LED7seg *led_7seg, int n, int zeros=1) {
  LEDprint( led_7seg->d1, sizeof(led_7seg->d1), n, zeros );
}
void turnLed( byte *dest, byte src ) {
  static PROGMEM const prog_char upsideDown[] = {3,4,5,0,1,2,6,7,};
  byte i=0; PGM_P p=upsideDown;
  for( *dest=0; i<NumberOf(upsideDown); i++, p++ )
    if( bitRead( src, pgm_read_byte(p) ) != 0 )
      bitWrite( *dest, i, 1 );
}
void turnAndSwapLed( byte *b1, byte *b2 ) {
  byte b;
  turnLed( &b, *b1 );
  turnLed( b1, *b2 );
  *b2 = b;
}
void turnLed( union _LED7seg *seg7 ) {
  turnAndSwapLed( &(seg7->d1[0]), &(seg7->d1[3]) );
  turnAndSwapLed( &(seg7->d1[1]), &(seg7->d1[2]) );
}

LED7seg led7seg;
LED16 led16_flags;

////////////////////////////////////////////////////////////////
// Synthesizer
////////////////////////////////////////////////////////////////
PROGMEM const prog_uint32_t envelope_shape_7seg[] = {
  0x18031803, // ~_~_ 0101 000 ATT|ALT|HOLD
  0x08081803, // ~___ 0001 001
  0x210C1803, // ~__~ 1001 010
  0x01011803, // ~_~~ 1101 011
  0x210C210C, // _~_~ 1010 100
  0x0101210C, // _~~~ 1110 101
  0x1803210C, // _~~_ 0110 110
  0x0808210C, // _~__ 0010 111
  0x01010101, // ~~~~ 1111
};
void showEnvelopeShape(int value, void *ref) {
  led7seg.d4 = pgm_read_dword( envelope_shape_7seg + value - 8 );
}
LoopedValue envelope_shape = LoopedValue(9,8,16,0,showEnvelopeShape);


unsigned int getEnvelopePeriod() {
  // output = 0 - 65535
  double v = analogRead(ENVELOPE_PERIOD_VR_PIN) / 64.0;
  return pow(2,v);
}

//
// 12-bit Tone Period
//    f = Clock(4MHz) / (16 * TP)
PROGMEM const prog_uint16_t tp12_table[] = {
  // Max = 4095 (0x0FFF)
  3822, // C (65.41Hz, MIDI note 36)
  3608,
  3405, // D
  3214,
  3034, // E
  2863, // F
  2703,
  2551, // G
  2408,
  2273, // A (110Hz, MIDI note 45)
  2145,
  2025, // B
  // Min = 0 (0x0000)
};
class MidiSSG : public SSG {
  public:
    float pitch_multiplier;
    unsigned int tp12s[SSG_CHANNELS_PER_CHIP];
    MidiSSG(byte writePin) : SSG(writePin) {
      pitch_multiplier = 1;
      memset( (void *)tp12s, 0, sizeof(tp12s) );
    }
    void begin() { SSG::begin(); }
    void noteOn( byte channel, byte note ) {
      unsigned int tp12 = pgm_read_word(tp12_table + note%12);
      byte octave_position = note/12;
      if( octave_position > 2 ) tp12 >>= octave_position - 2;
      tp12s[channel] = tp12;
      setTonePeriod( channel, tp12 * pitch_multiplier );
      byte vol = 0x0F;
      byte es = envelope_shape.getValue();
      if( es < 16 ) {
        vol++; setEnvelopePeriod( getEnvelopePeriod() );
      }
      setVolume( channel, vol );
      startEnvelope( es );
      setMixer( channel, true );
    }
    void noteOff(byte channel) {
      setMixer( channel, false );
      setVolume( channel, 0 ); // To cut clicky envelope noise
    }
    void allNotesOff() { allMixerOff(); setVolume(0); }
    void changePitchBend(int value) {
      pitch_multiplier = pow( 2, -(float)(value>>8) / (float)(3<<6) );
      for( byte channel=0; channel<NumberOf(tp12s); channel++ ) {
        setTonePeriod( channel, tp12s[channel] * pitch_multiplier );
      }
    }
};

#define NUM_SSG_CHANNELS (SSG_CHANNELS_PER_CHIP * NumberOf(ssgs))
MidiSSG ssgs[2] = {
  MidiSSG(SSG_WRITE_PIN_0),
  MidiSSG(SSG_WRITE_PIN_1)
};
class MidiSynthesizer {
  public:
    char activeList[NUM_SSG_CHANNELS];
  private:
    char searchSsgChannel(char note) {
      char offset = random(NUM_SSG_CHANNELS);
      char *p, i, ioffset;
      p = activeList + offset;
      for( i=0, ioffset=offset; i < NUM_SSG_CHANNELS ; i++, ioffset++ ) {
        if( ioffset >= NUM_SSG_CHANNELS ) { ioffset = 0; p = activeList; }
        if( *p++ == note ) return ioffset;
      }
      return -1;
    }
  public:
    MidiSynthesizer() {
      memset( (void *)activeList, -1, sizeof(activeList) );
    }
    void begin() {
      ssgs[0].begin();
      ssgs[1].begin();
    }
    void noteOff(byte noteNumber) {
      noteNumber &= 0x7F;
      int ssgCh = searchSsgChannel( (char)noteNumber );
      if( ssgCh < 0 ) return;
      ssgs[ssgCh & 1].noteOff( ssgCh/2 );
      activeList[ssgCh] = -1;
    }
    void noteOn(byte noteNumber) {
      noteNumber &= 0x7F;
      int ssgCh = searchSsgChannel(-1);
      if( ssgCh < 0 ) { // SSG channel full
        // Search new channel to force note off
        char *p = activeList; char c = NUM_SSG_CHANNELS;
        for( ; c>0; c--, p++ ) if( (*p - noteNumber) % 12 == 0 ) {
          ssgCh = NUM_SSG_CHANNELS - c; break;
        }
        if( ssgCh < 0 ) ssgCh = random(NUM_SSG_CHANNELS);
        ssgs[ssgCh & 1].noteOff( ssgCh/2 );
      }
      activeList[ssgCh] = (char)noteNumber;
      ssgs[ssgCh & 1].noteOn( ssgCh/2, noteNumber );
    }
    void allNotesOff() {
      ssgs[0].allNotesOff();
      ssgs[1].allNotesOff();
      memset( (void *)activeList, -1, sizeof(activeList) );
    }
    void changePitchBend(int value) {
      ssgs[0].changePitchBend(value);
      ssgs[1].changePitchBend(value);
    }
};
MidiSynthesizer synth = MidiSynthesizer();

void showMidiCh(int value, void *ref) {
  led7seg.d4 = 0xF439; // Ch.
  LEDprint( &led7seg, value );
}
class MidiOut {
  private:
    LoopedValue midiChannel;
  public:
    MidiOut() {
      midiChannel = LoopedValue(1, 1, 16, 0, showMidiCh);
    }
    LoopedValue *getChannel() { return &midiChannel; }
    byte getVelocity() {
      byte vout = analogRead(VELOCITY_VR_PIN) / 8;
      return vout == 0 ? 1 : vout;
    }
    void noteOff(byte noteNumber) {
      MIDI.sendNoteOff( noteNumber, getVelocity(), midiChannel.getValue() );
    }
    void noteOn(byte noteNumber) {
      MIDI.sendNoteOn( noteNumber, getVelocity(), midiChannel.getValue() );
    }
};
MidiOut midiOut = MidiOut();

////////////////////////////////////////////////////////////////
// Musical note/key/chord classes with LED display function
////////////////////////////////////////////////////////////////
// co5 : is a value of the Circle-of-fifths position
// offset3 :
//    -1 = minor 3rd (Xm)
//    0 = major 3rd (Y)
//    1 = suspended 4th (Ysus4)
// offset5:
//    -1 = -5 or dim
//    0 = parfect 5th
//    1 = +5 (aug)
// offset7:
//    0 = No 7th
//    -1 = Major 7th
//    -2 = 7th
//    -3 = 6th or dim7th
// has9: add 9th tone
////////////////////////////////////////////////////////////////
PROGMEM const prog_char fcgdaebOn7seg[] = {
  // F     C     G     d     A     E     b
  0x71, 0x39, 0x3D, 0x5E, 0x77, 0x79, 0x7C,
};
PROGMEM const prog_char flatSharpOn7seg[] = {
  0x7E, // Double flat (bb -> b|)
  0x7C, // Flat (b)
  0x00, // Natural
  0x76, // Sharp (# -> H)
  0x36, // Double sharp (## -> x -> ||)
};
int toggleCo5(int v) { // Toggles The Circle of Fifths value <-> MIDI note # (chromatic value)
  if( v & 1 != 0 ) v += 6; if( (v %= 12) < 0 ) v += 12; return v;
}
#define LED16_MASK (0x1FFF)  // == ((1<<13) - 1)
LED16 led16_keysig;
void showKeySignature(int value, void *ref) {
  // Redraw 7-segment LED
  led7seg.d4 = 0;
  byte *bufp = (byte *)(&led7seg);
  int n = value;
  if( n == 0 ) {
    *bufp = 0x37; // N |~|
  }
  else {
    byte sharp_flat;
    if( n < 0 ) { n = -n; sharp_flat = 1; }
    else if( n > 0 ) sharp_flat = 3;
    sharp_flat = pgm_read_byte( flatSharpOn7seg + sharp_flat );
    if( n <= 4 ) while( --n >= 0 ) *bufp++ = sharp_flat;
    else { *bufp++ = DIGIT_7SEG(n); *bufp++ = sharp_flat; }
  }
  // Redraw 16-pieces LED
  led16_keysig.d2 = LED16_MASK;
  int pos = 6 - value;
  if( pos < 0 ) pos += 12; else if( pos > 12 ) pos -= 12;
  led16_keysig.d2 &= ~(1<<pos);
}
class KeySignature : public LoopedValue {
  public:
    KeySignature() : LoopedValue(0,-7,7,12,showKeySignature) {}
    char getNote() { return toggleCo5(value); }
};
class MusicalNote {
  protected:
    int co5value; // position of major key in the circle-of-fifths
    byte *LEDprint(byte *bufp) {
      char co5p15 = co5value + 15;
      *bufp++ = pgm_read_byte( fcgdaebOn7seg + co5p15 % 7 );
      byte sharp_flat = pgm_read_byte( flatSharpOn7seg + co5p15 / 7 );
      if( sharp_flat ) *bufp++ = sharp_flat;
      return bufp;
    }
  public:
    MusicalNote(int v) { co5value = v; }
    int getNote() { return toggleCo5(co5value); }
    void showValue() {
      led7seg.d4 = 0;
      LEDprint( (byte *)(&(led7seg.d4)) );
    }
};
class MusicalChord : public MusicalNote {
  protected:
    byte *LEDprint(byte *bufp) {
      bufp = MusicalNote::LEDprint(bufp);
      if(offset3 == -1) {
        if( offset5 == -1 && (offset7 == 0 && ! has9 || offset7 == -3) ) {
          *bufp++ = 0x5E; // dim -> din (dim, dim7, dim9)
          *bufp++ = 0x04;
        }
        *bufp++ = 0x54; // m -> n
      }
      else if( offset5 == 1 ) {
        *bufp++ = 0x77; // Aug
        *bufp++ = 0x1C;
        *bufp++ = 0x3D;
      }
      switch(offset7) {
        case -1: *bufp++ = 0x37; // M -> |~|
          // fallthurough
        case -2:
          if( has9 ) break;
          *bufp++ = DIGIT_7SEG(7); // 7
          break;
        case -3:
          if( offset3 == -1 && offset5 == -1 ) {
            if( ! has9 ) *bufp++ = DIGIT_7SEG(7); // 7 for dim7
          }
          else *bufp++ = DIGIT_7SEG(6); // 6
          break;
      }
      if( has9 ) {
        if( offset7 == 0 ) *bufp++ = 0x77; // add9 -> A9
        *bufp++ = DIGIT_7SEG(9); // 9
      }
      if( offset3 == 1 ) {
        *bufp++ = 0x1C; // sus4 -> u4
        *bufp++ = DIGIT_7SEG(4);
      }
      else if(
        offset5 == -1 && (
          offset3 == 0 ||
          offset3 == -1 && (
            offset7 == -2 ||
            offset7 == -1 ||
            offset7 == 0 && has9
          )
        )
      ) {
        *bufp++ = 0x40; // -5 for Xm(M)7(-5), X(-5), Xm(M)9(-5)
        *bufp++ = DIGIT_7SEG(5);
      }
      return bufp;
    }
  public:
    int offset3, offset5, offset7; boolean has9;
    MusicalChord(int v) : MusicalNote(v) { /* Nothing to do here */ }
    void showValue() {
      byte chordOn7seg[16];
      memset( (void *)chordOn7seg, 0, sizeof(chordOn7seg) );
      LEDprint(chordOn7seg);
      memcpy( (void *)(&(led7seg.d4)), (const void *)chordOn7seg, sizeof(led7seg.d4) );      
    }
};
KeySignature keySig = KeySignature();

///////////////////////////////////////////////////
// Metronome
///////////////////////////////////////////////////
void showTimeSignature(int value, void *ref) {
  byte *d1 = led7seg.d1;
  d1[0] = 0;
  LEDprint( d1, 2, value );
  d1[2] = 0x52;
  d1[3] = DIGIT_7SEG(4); // Lower digit
}
void showTempo(int value, void *ref) {
  led7seg.d4 = 0x000000F8; // t.__1 - t.120 - t.999
  LEDprint( &led7seg, value );
}
#define US_PER_MINUTE  (60000000ul) // microseconds per minute
#define DEFAULT_BPM    (120)
#define LOG2_QUARTER   (-2) // ==log2(1/4)
class Metronome : public LoopedValue {
  public:
    unsigned long us;
    unsigned long usPerQuarter;
    unsigned long last_adjusted_us;
    LoopedValue timesig_upper; // upper digit
    // Time signature lower digit is already 4 (2/4, 4/4, etc.)
    Metronome() : LoopedValue(DEFAULT_BPM,1,999,0,showTempo) {
      reset();
      timesig_upper = LoopedValue(4,2,5,0,showTimeSignature);
      add(0);
    }
    void reset() { us = last_adjusted_us = 0L; }
    void add(int n) {
      LoopedValue::add(n);
      usPerQuarter = US_PER_MINUTE / value;
      adjustBeat();
    }
    void setTempoInMicrosecondsPerQuarter(unsigned long mpq) {
      setValue( (int)(US_PER_MINUTE / (usPerQuarter = mpq)) );
      adjustBeat();
    }
    void adjustBeat() {
      us /= usPerQuarter;
      us *= usPerQuarter;
    }
    void adjustTempo() {
      unsigned long us_diff = us - last_adjusted_us;
      if( us_diff < US_PER_MINUTE / 30 ) // 2 second
        setTempoInMicrosecondsPerQuarter( (us_diff + usPerQuarter) / 2 );
      last_adjusted_us = us;
    }
    unsigned int getBeat(byte resolution_index = -LOG2_QUARTER) {
      resolution_index += LOG2_QUARTER;
      return (us / (usPerQuarter >> resolution_index)) % (timesig_upper.getValue() << resolution_index);
    }
};
Metronome metronome = Metronome();

///////////////////////////////////////////////////
// MIDI sequencer
///////////////////////////////////////////////////

typedef struct _SMFHeader {
  byte chunk_type[4]; // Always "MThd"
  byte data_length[4]; // Always 00 00 00 06
  byte format[2];
  byte n_tracks[2];
  byte tpq[2]; // Ticks Per Quarter
} SMFHeader;

typedef struct _SMFTrackHeader {
  byte chunk_type[4]; // Always "MTrk"
  byte data_length[4];
} SMFTrackHeader;

typedef struct _SMFTrack {
  unsigned long data_length;
  unsigned long done_tick;
  byte status;
  PGM_P data;
  PGM_P current;
  PGM_P nexttop;
} SMFTrack;

typedef struct _SMF {
  PGM_P top;
  unsigned int n_tracks;
  SMFTrack *tracks;
  SMFTrack *current_track;
  SMFTrack *nexttop_track;
} SMF;

// MIDI sequence entry
extern PROGMEM const prog_char sequence01[];
extern PROGMEM const prog_char sequence02[];
extern PROGMEM const prog_char sequence03[];
extern PROGMEM const prog_char sequence04[];
extern PROGMEM const prog_char sequence05[];
extern PROGMEM const prog_char sequence06[];
extern PROGMEM const prog_char sequence07[];
PGM_P sequenceList[] = {
  sequence01,
  sequence02,
  sequence03,
  sequence04,
  sequence05,
  sequence06,
  sequence07,
};
void showSongTitle(int value, void *ref) {
  switch(value) {
    case 0: led7seg.d4 = 0x53491307; break;
    case 1: led7seg.d4 = 0x0F090F09; break;
    case 2:
      {
        byte *beatp = (byte *)ref;
        led7seg.d4 = 0x635C6304;
        if( *beatp & 1 ) led7seg.d1[0] = 0x08; // leekshake
      }
      break;
    case 3: led7seg.d4 = 0x3D5C5477; break;
    case 4: led7seg.d4 = 0x54776E37; break;
    case 5: led7seg.d4 = 0x79785C73; break;
    case 6: led7seg.d4 = 0x546D5476; break;
    default: led7seg.d4 = 0;
  }
}
class MidiSequencer : public LoopedValue {
  protected:
    SMF smf; byte beat; boolean is_repeat_mode, is_animation_mode;
    unsigned int ticksPerQuarter;
    boolean is_running;
  public:
    MidiSequencer() : LoopedValue( 0, 0, NumberOf(sequenceList)-1, 0, showSongTitle, (void *)(&beat) ) {
      ticksPerQuarter = 48;
      is_running = is_repeat_mode = is_animation_mode = false;
      smf.n_tracks = 0; smf.tracks = NULL;
      setSequence(sequenceList[value]);
    }
    boolean isRunning() { return is_running; }
    void toggleStart() {
      if( is_running ) stop(); else start();
    }
    void add(int n) {
      LoopedValue::add(n);
      setSequence(sequenceList[value]);
      showSongTitle(value,reference);
    }
    PGM_P getSequence() { return smf.top; }
    void setSequence(const prog_char data[]) {
      if( smf.top == data ) return;
      boolean was_running = is_running;
      if( was_running ) stop();
      smf.top = data;
      SMFHeader header;
      memcpy_P( (void *)&header, (PGM_VOID_P)smf.top, sizeof(SMFHeader) );
      ticksPerQuarter = BigEndian( header.tpq, sizeof(ticksPerQuarter) );
      smf.n_tracks = BigEndian( header.n_tracks, sizeof(smf.n_tracks) );
      if( smf.tracks != NULL ) free(smf.tracks);
      smf.tracks = (SMFTrack *)malloc( sizeof(SMFTrack) * smf.n_tracks );
      smf.nexttop_track = smf.tracks + smf.n_tracks;
      SMFTrackHeader track_header;
      PGM_P datap = smf.top + sizeof(SMFHeader);
      for(
        smf.current_track = smf.tracks;
        smf.current_track < smf.nexttop_track;
        smf.current_track++
      ) {
        memcpy_P( (void *)&track_header, (PGM_VOID_P)datap, sizeof(SMFTrackHeader) );
        smf.current_track->data_length = BigEndian(
          track_header.data_length,
          sizeof(smf.current_track->data_length)
        );
        smf.current_track->data = (datap += sizeof(SMFTrackHeader));
        smf.current_track->nexttop = (datap += smf.current_track->data_length);
      }
      moveToTop();
      is_animation_mode = ( smf.top == sequence03 );
      if( was_running ) start();
    }
    void moveToTop() {
      for(
        smf.current_track = smf.tracks;
        smf.current_track < smf.nexttop_track;
        smf.current_track++
      ) {
        smf.current_track->current = smf.current_track->data;
        smf.current_track->done_tick = 0;
        smf.current_track->status = 0;
      }
    }
    boolean isRepeatMode() { return is_repeat_mode; }
    void toggleRepeat() {
      is_repeat_mode = ! is_repeat_mode;
      led16_flags.b16.extra1 = is_repeat_mode;
    }
    void start() {
      moveToTop(); metronome.reset();
      led16_flags.b16.extra0 = is_running = true;
    }
    void stop() {
      led16_flags.b16.extra0 = is_running = false;
      for( int i=0; i<NUM_SSG_CHANNELS; i++ ) {
        midiOut.noteOff(synth.activeList[i]);
      }
      synth.allNotesOff();
    }
    void doEvent() {
      if( ! is_running || ! smf.n_tracks ) return;
      byte old_beat = beat;
      unsigned long currentTick = metronome.us / (metronome.usPerQuarter/ticksPerQuarter);
      beat = metronome.getBeat();
      if( is_animation_mode && beat != old_beat ) {
        showSongTitle(value,reference);
      }
      boolean is_done = false;
      for(
        smf.current_track = smf.tracks;
        smf.current_track < smf.nexttop_track;
        smf.current_track++
      ) {
        while( smf.current_track->current < smf.current_track->nexttop ) {
          if( ! is_done ) is_done = true;
          unsigned long t = 0UL; char c;
          PGM_P p = smf.current_track->current;
          for(;;) {
            t += (c=pgm_read_byte(p++)) & 0x7F;
            if( (c & 0x80) == 0 ) break;
            t <<= 7;
          }
          if( (t += smf.current_track->done_tick) > currentTick ) break;
          if( ( (c=pgm_read_byte(p)) & 0x80 ) != 0 ) {
            smf.current_track->status = c; p++;
          }
          byte note, velocity;
          byte ch = smf.current_track->status & 0x0F;
          switch( smf.current_track->status & 0xF0 ) {
            case 0x80:
              note = pgm_read_byte(p++);
              p++; // Ignore velocity
              midiOut.noteOff( note );
              synth.noteOff( note );
              break;
            case 0x90:
              note = pgm_read_byte(p++);
              velocity = pgm_read_byte(p++);
              if( velocity == 0 ) {
                midiOut.noteOff( note );
                synth.noteOff( note );
              }
              else {
                midiOut.noteOn( note );
                synth.noteOn( note );
              }
              break;
            case 0xA0: // Polyphonic Key Pressure
            case 0xB0: // Control Change
            case 0xE0: // Pitch Bend Change
              p++; // Fallthrough
            case 0xC0: // Program Change
            case 0xD0: // Channel Pressure
              p++; break;
            case 0xF0:
              switch(ch) {
                case 0x0F :// Meta message
                  {
                    byte type = pgm_read_byte(p++);
                    unsigned long length = 0;
                    for(;;) {
                      length += (c = pgm_read_byte(p++)) & 0x7F;
                      if( (c & 0x80) == 0 ) break;
                      length <<= 7;
                    }
                    switch(type) {
                      case 0x51: // Tempo change
                        {
                          byte t[4];
                          memcpy_P( (void *)t, (PGM_VOID_P)p, length );
                          metronome.setTempoInMicrosecondsPerQuarter(BigEndian(t,length));
                        }
                        break;
                      case 0x58: // Time signature change
                        metronome.timesig_upper.setValue(pgm_read_byte(p));
                        break;
                      case 0x59: // Key signature change
                        keySig.setValue(pgm_read_byte(p));
                        break;
                    }
                    p += length;
                  }
                  break;
                case 0x00: // System Exclusive
                  // Skip until EOX (End-Of-eXclusive)
                  while( pgm_read_byte(p++) != 0xF7 );
                  break;
                case 0x02: // Song Position Pointer
                  p++; // Fallthrough
                case 0x01: // Quarter Frame
                case 0x03: // Song Select
                  p++; break;
              }
              break;
          }
          smf.current_track->current = p;
          smf.current_track->done_tick = t;
        }
      }
      if( ! is_done ) { // No job to do
        if( is_repeat_mode ) start(); else stop();
      }
    }
};
MidiSequencer sequencer = MidiSequencer();

//////////////////////////////////////////////////////////////
// Button control
//////////////////////////////////////////////////////////////

byte shiftOctave(char note, int analog_offset, int chromatic_offset = 0) {
  int lowest_note = 0;
  int highest_note = 116; // == 127 - 12
  if( chromatic_offset ) {
    lowest_note += chromatic_offset;
    highest_note += chromatic_offset;
  }
  int min_note = map(analog_offset,0,1023,lowest_note,highest_note);
  if( min_note > 116 || min_note < 0 ) min_note -= chromatic_offset;
  int max_note = min_note + 11;
  if( max_note < note ) {
    note -= ((note - max_note) / 12 + 1) * 12;
  }
  else if( min_note > note ) {
    note += ((min_note - note - 1) / 12 + 1) * 12;
  }
  return note;
}

PROGMEM const prog_uint32_t simultaneous_pattern_7seg[] = {
  0x08080808, // ____
  0x49494949, // ====
};
void showSimultaneousPattern(int value, void *ref) {
  led7seg.d4 = pgm_read_dword( simultaneous_pattern_7seg + value );
}
class SimultaneousPattern : public LoopedValue {
  public:
    SimultaneousPattern() : LoopedValue(
      1, 0, NumberOf(simultaneous_pattern_7seg)-1, 0, showSimultaneousPattern
    ) {}
};
PROGMEM const prog_uint32_t arpeggio_pattern_7seg[] = {
  0x00000040, // -
  0x01400108, // _~-~
};
void showArpeggioPattern(int value, void *ref) {
  led7seg.d4 = pgm_read_dword( arpeggio_pattern_7seg + value );
}
class ArpeggioPattern : public LoopedValue {
  public:
    ArpeggioPattern() : LoopedValue(
      0, 0, NumberOf(arpeggio_pattern_7seg)-1, 0, showArpeggioPattern
    ) {}
};

#define HAS_AUTO_ARPEGGIO_NOTE(p) ((p).arpeggio_pattern.getValue()==1)
#define IS_SINGLE_NOTE_MODE(p) ((p).arpeggio_pattern.getValue()==0 && (p).simultaneous_pattern.getValue()==0)
#define HAS_ONESHOT_NOTE(p) ((p).arpeggio_pattern.getValue()==0 || (p).simultaneous_pattern.getValue()==1)
typedef struct _NotePattern {
  SimultaneousPattern simultaneous_pattern;
  ArpeggioPattern arpeggio_pattern;
} NotePattern;
NotePattern note_pattern;

typedef struct _ButtonNote {
  byte n_notes; char *notes;
  char row, col;
  int analog;
  NotePattern note_pattern;
  char chromatic_offset;
} ButtonNote;

class ButtonTriggeredSequencer {
  protected:
    ButtonNote button_notes[6];
    char active_note;
    int active_analog;
    byte beat16;
    boolean is_running;
    ButtonNote *searchButtonNote(char row, char col) {
      ButtonNote *bnp = button_notes; char i=NumberOf(button_notes);
      for( ; i>0; i--, bnp++ ) if( bnp->row == row && bnp->col == col ) return bnp;
      return NULL;
    }
    ButtonNote *getActiveNote() {
      ButtonNote *bnp = button_notes; char i=NumberOf(button_notes);
      for( ; i>0; i--, bnp++ ) if( bnp->n_notes ) return bnp;
      return NULL;
    }
    void freeButtonNote(ButtonNote *bnp) {
      bnp->row = bnp->col = -1;
      bnp->n_notes = 0;
      if( bnp->notes != NULL ) { free(bnp->notes); bnp->notes = NULL; }
    }
    void noteOn(byte note) {
      midiOut.noteOn(note); synth.noteOn(note);
    }
    void noteOff(byte note) {
      midiOut.noteOff(note); synth.noteOff(note);
    }
    void startRandomNote(ButtonNote *bnp) {
      active_analog = analogRead(OCTAVE_VR_PIN);
      active_note = bnp->notes[random(bnp->n_notes)];
      noteOn(shiftOctave(active_note,active_analog));
    }
    void stopRandomNote() {
      if( active_note >= 0 ) {
        noteOff(shiftOctave(active_note,active_analog));
        active_note = active_analog = -1;
      }
    }
    void start(ButtonNote *bnp) {
      char n = bnp->n_notes, *notep = bnp->notes;
      bnp->analog = analogRead(OCTAVE_VR_PIN);
      if( n > 1 ) noteOn( shiftOctave( *notep, bnp->analog - 192 ) );
      for( ; n>0; n--, notep++ ) {
        noteOn( shiftOctave(*notep,bnp->analog,bnp->chromatic_offset) );
      }
    }
    void stop(ButtonNote *bnp) {
      char n = bnp->n_notes, *notep = bnp->notes;
      if( n > 1 ) noteOff( shiftOctave( *notep, bnp->analog - 192 ) );
      for( ; n>0; n--, notep++ ) {
        noteOff( shiftOctave(*notep,bnp->analog,bnp->chromatic_offset) );
      }
      freeButtonNote(bnp);
    }
  public:
    boolean is_hold_mode;
    ButtonTriggeredSequencer() {
      is_hold_mode = is_running = false; beat16 = 0;
      ButtonNote *bnp = button_notes; char i=NumberOf(button_notes);
      for( ; i>0; i--, bnp++ ) { bnp->notes = NULL; freeButtonNote(bnp); }
      active_note = active_analog = -1;
    }
    void stop() {
      ButtonNote *bnp = button_notes; char i = NumberOf(button_notes);
      for( ; i>0; i--, bnp++ ) if( bnp->n_notes ) stop(bnp);
      stopRandomNote();
      is_running = false;
    }
    void toggleHoldMode() {
      if( is_hold_mode ) stop();
      is_hold_mode = ! is_hold_mode;
      led16_flags.b16.extra2 = is_hold_mode;
    }
    void buttonPressed(ButtonNote new_bn) {
      if( is_hold_mode ) stop();
      // Check if the same button already pressed
      ButtonNote *bnp = searchButtonNote( new_bn.row, new_bn.col );
      if( bnp != NULL ) { // Already pressed - cancel it
        stop(bnp); stopRandomNote();
      }
      else if( (bnp = searchButtonNote(-1,-1)) == NULL ) return; // Button note table full - reject it
      *bnp = new_bn; is_running = true;
      if( HAS_ONESHOT_NOTE(bnp->note_pattern) ) start(bnp); // perform note-on immidiately
      if( HAS_AUTO_ARPEGGIO_NOTE(bnp->note_pattern) ) startRandomNote(bnp);
    }
    void buttonReleased(byte row, byte col) {
      if( is_hold_mode ) return;
      ButtonNote *bnp = searchButtonNote(row,col);
      if( bnp == NULL ) return;
      stop(bnp); stopRandomNote(); is_running = false;
    }
    void doEvent() {
      byte old_beat16 = beat16;
      if( (beat16 = metronome.getBeat(4)) == old_beat16 ) return;
      stopRandomNote();
      if( ! is_running ) return;
      ButtonNote *bnp = getActiveNote();
      if( bnp == NULL || ! HAS_AUTO_ARPEGGIO_NOTE(bnp->note_pattern) )
        return;
      startRandomNote(bnp);
    }
};
ButtonTriggeredSequencer buttonSequencer = ButtonTriggeredSequencer();

#define BUTTON_STATUS_OFF          0x00
#define BUTTON_STATUS_ON           0x03

char buttonStatus[16][3];
#define SHIFT_BUTTON_7_ON     (buttonStatus[15][2]==BUTTON_STATUS_ON)
#define SHIFT_BUTTON_FLAT5_ON (buttonStatus[15][1]==BUTTON_STATUS_ON)
#define SHIFT_BUTTON_M7_ON    (buttonStatus[15][0]==BUTTON_STATUS_ON)
#define SHIFT_BUTTON_ADD9_ON  (buttonStatus[14][2]==BUTTON_STATUS_ON)
#define SHIFT_BUTTON_CTRL_ON  (buttonStatus[14][1]==BUTTON_STATUS_ON)
#define SHIFT_BUTTON_KEY_ON   (buttonStatus[14][0]==BUTTON_STATUS_ON)

boolean drum_switch = false;

void buttonAction(byte row, byte col, boolean is_pressed) {
  if( ! is_pressed ) { // released
    if( row < 13 ) buttonSequencer.buttonReleased(row,col);
    return;
  }
  if( row == 13 ) {
    switch(col) {
      case 0:
        if( SHIFT_BUTTON_CTRL_ON ) sequencer.toggleRepeat();
        else sequencer.toggleStart();
        break;
      case 1:
        if( SHIFT_BUTTON_CTRL_ON )
          note_pattern.simultaneous_pattern.add(1);
        else buttonSequencer.toggleHoldMode();
        break;
      case 2:
        if( SHIFT_BUTTON_CTRL_ON )
          note_pattern.arpeggio_pattern.add(1);
        else drum_switch = ! drum_switch;
        break;
    }
    return;
  }
  if( row < 13 ) {
    int center0_row = (int)row - 6;
    int center0_col = col - 1;
    if( SHIFT_BUTTON_CTRL_ON ) {
      switch( center0_row ) {
        case -1:
          if( SHIFT_BUTTON_KEY_ON ) {
            if( !center0_col ) {
              metronome.adjustTempo(); break;
            }
            center0_col *= 10;
          }
          metronome.add(center0_col);
          break;
        case  1: sequencer.add(center0_col);  break;
        case  0: envelope_shape.add(center0_col); break;
        case -2: metronome.timesig_upper.add(center0_col); break;
        case  2: midiOut.getChannel()->add(center0_col);   break;
        default: led7seg.d4 = 0;     break;
      }
    }
    else if( SHIFT_BUTTON_KEY_ON ) {
      if( center0_row == 0 ) keySig.add( center0_col * 7 );
      else keySig.add( center0_row );
    }
    else {
      int co5 = keySig.getValue() + center0_row;
      if( col == 0 ) co5 += 3; // Shift 3 sharp if minor chord button
      ButtonNote bn;
      bn.chromatic_offset = 0;
      char *notep;
      if( IS_SINGLE_NOTE_MODE(note_pattern) ) {
        if( col == 2 ) bn.chromatic_offset = 12; // sus4 button to shift a octave up
        MusicalNote note = MusicalNote(co5);
        note.showValue();
        if( (bn.notes = (char *)malloc( 2 * sizeof(char) )) != NULL )
          *(notep = bn.notes) = note.getNote();
      }
      else {
        MusicalChord chord = MusicalChord(co5);
        chord.offset3 = col - 1;
        if( SHIFT_BUTTON_FLAT5_ON ) { // -5
          if( col==2 ) { chord.offset3 = 0; chord.offset5 = 1; }
          else chord.offset5 = -1;
        }
        else chord.offset5 = 0;
        chord.offset7 = 0;
        if( SHIFT_BUTTON_M7_ON ) chord.offset7--;
        if( SHIFT_BUTTON_7_ON ) chord.offset7 -= 2;
        chord.has9 = SHIFT_BUTTON_ADD9_ON;
        chord.showValue();
        if( (bn.notes = (char *)malloc( 7 * sizeof(char) )) != NULL ) {
          int rootnote = chord.getNote();
          *(notep = bn.notes) = rootnote;
          *++notep = rootnote + 4 + chord.offset3;
          *++notep = rootnote + 7 + chord.offset5;
          if( chord.offset7 ) {
            *++notep = rootnote + 12 + chord.offset7;
          }
          if( chord.has9 ) {
            *++notep = rootnote + 2;
          }
        }
      }
      if( bn.notes == NULL ) return;
      bn.row = row; bn.col = col;
      bn.note_pattern = note_pattern;
      bn.n_notes = (++notep) - bn.notes;
      buttonSequencer.buttonPressed(bn);
    }
  } // row < 13
}

void HandleNoteOff(byte channel, byte pitch, byte velocity) {
  synth.noteOff(pitch);
}
void HandleNoteOn(byte channel, byte pitch, byte velocity) { 
  if( velocity == 0 ) {
    HandleNoteOff(channel,pitch,velocity);
    return;
  }
  synth.noteOn(pitch);
}
void HandlePitchBend(byte channel, int value) {
  synth.changePitchBend(value);
}
/////////////////////////////////////////////////
//  LED display / button scanner
/////////////////////////////////////////////////
#define TIMER2_INTERVAL_FREQ    (2500L)
// data in binary = MyyyXXXX
//    Low 4 bits:
//      XXXX: 74HC154 DCBA input (for LED cathode)
//    High 4 bits:
//      yyy:  Low-active bits to PNP-Tr base (for LED anode)
//      M: Rhythm pulse on(1)/off(0)
struct {
  boolean locked;
  boolean row_changed;
  byte row;
  byte high4bit_mask;
  LEDs leds;
} scan_status = {false,false,0,0x70};
void timer2Triggered() {
  metronome.us += 1000000L / TIMER2_INTERVAL_FREQ ;
  if( scan_status.locked ) return;
  static volatile byte col = 0;
  static volatile byte prev_data = 0;
  if( ++col >= 3 ) {
    col = 0;
    if( ++scan_status.row & 0x10 ) scan_status.row = 0;
    scan_status.row_changed = true;
  }
  byte data = scan_status.high4bit_mask | scan_status.row;
  if( scan_status.leds.b16[col] & (1<<scan_status.row) )
    data &= ((char)0xBF >> col); // LED anode bit on
  if( data == prev_data ) return; // Data not changed
  shiftOut(LED_DATA_PIN, LED_CLOCK_PIN, MSBFIRST, data);
  digitalWrite(LED_LATCH_PIN,LOW);
  prev_data = data;
  digitalWrite(LED_LATCH_PIN,HIGH);
}
/////////////////////////////////////////////////
//  Main program
/////////////////////////////////////////////////
void setup() {
  memset((void *)buttonStatus,BUTTON_STATUS_OFF,sizeof(buttonStatus));
  pinMode(LED_DATA_PIN,OUTPUT);
  pinMode(LED_CLOCK_PIN,OUTPUT);
  pinMode(LED_LATCH_PIN,OUTPUT);
  setupSSG();
  char i; byte pin;
  for( i=0, pin = FIRST_BUTTON_PIN; i<3; i++, pin++ ) { 
    // Enables internal 20K pullup resistor for chord buttons
    digitalWrite(pin,HIGH);
  }
  // Enables internal 20K pullup resistor for tile sensor
  digitalWrite(TILT_SENSOR_PIN,HIGH);
  FlexiTimer2::set(1, 1.0/TIMER2_INTERVAL_FREQ, timer2Triggered);
  FlexiTimer2::start();
  synth.begin();
  MIDI.begin(MIDI_CHANNEL_OMNI); // receives all MIDI channels
  MIDI.turnThruOff(); // Disable MIDI IN -> MIDI OUT mirroring
  MIDI.setHandleNoteOff(HandleNoteOff);
  MIDI.setHandleNoteOn(HandleNoteOn);
  MIDI.setHandlePitchBend(HandlePitchBend);
  pinMode(MIDI_ENABLE_PIN,OUTPUT);
  digitalWrite(MIDI_ENABLE_PIN,HIGH);
  sequencer.start();
}
void loop() {
  static int tilt_sensor_on_times = 0;
  LEDs leds;
  if( metronome.getBeat(5) % 8 ) {
    scan_status.high4bit_mask = 0x70;
    leds.screen.color16.d2 = led16_keysig.d2;
  }
  else {
    if( drum_switch ) scan_status.high4bit_mask = 0xF0;
    leds.screen.color16.d2 = LED16_MASK;
  }
  leds.screen.color16.d2 |= led16_flags.d2;
  leds.screen.seg7 = led7seg;
  if( tilt_sensor_on_times > 128 ) turnLed(&(leds.screen.seg7));
  scan_status.leds = leds;
  if( scan_status.row_changed ) {
    scan_status.locked = true;
    scan_status.row_changed = false;
    byte row = scan_status.row;
    byte port_b = PINB >> 2; // get button status (PB2-4)
    scan_status.locked = false;
    for( byte col=0; col<3; col++, port_b>>=1 ) {
      char *bsp = &buttonStatus[row][col];
      if( (port_b & 1) == 0 ) { // LOW (ON)
        if( *bsp < BUTTON_STATUS_ON && ++(*bsp) >= BUTTON_STATUS_ON )
          buttonAction(row,col,true);
      }
      else { // HIGH (OFF)
        if( *bsp > BUTTON_STATUS_OFF && --(*bsp) <= BUTTON_STATUS_OFF )
          buttonAction(row,col,false);
      }
    }
    if( digitalRead(TILT_SENSOR_PIN) == HIGH ) { // TILT_SENSOR_PIN
      if( tilt_sensor_on_times > 0 ) tilt_sensor_on_times--;
    }
    else {
      if( tilt_sensor_on_times < 256 ) tilt_sensor_on_times++;
    }
  }
  sequencer.doEvent();
  buttonSequencer.doEvent();
  MIDI.read();
} // void loop() 

///////////////////////////////////////////////////
// MIDI sequence data
///////////////////////////////////////////////////

PROGMEM const prog_char sequence01[] = { // Famima
0x4D, 0x54, 0x68, 0x64, 0x00, 0x00, 0x00, 0x06,
0x00, 0x01, 0x00, 0x02, 0x00, 0x30, 0x4D, 0x54,
0x72, 0x6B, 0x00, 0x00, 0x00, 0x19, 0x00, 0xFF,
0x51, 0x03, 0x0B, 0x07, 0xC9, 0x00, 0xFF, 0x58,
0x04, 0x04, 0x02, 0x18, 0x08, 0x00, 0xFF, 0x59,
0x02, 0xFD, 0x00, 0x00, 0xFF, 0x2F, 0x00, 0x4D,
0x54, 0x72, 0x6B, 0x00, 0x00, 0x00, 0x82, 0x00,
0x93, 0x4F, 0x46, 0x18, 0x83, 0x4F, 0x00, 0x00,
0x93, 0x4B, 0x46, 0x18, 0x83, 0x4B, 0x00, 0x00,
0x93, 0x46, 0x46, 0x00, 0x43, 0x46, 0x18, 0x83,
0x46, 0x00, 0x00, 0x93, 0x4B, 0x46, 0x18, 0x83,
0x43, 0x00, 0x00, 0x4B, 0x00, 0x00, 0x93, 0x4D,
0x46, 0x00, 0x4A, 0x46, 0x18, 0x83, 0x4D, 0x00,
0x00, 0x93, 0x52, 0x46, 0x30, 0x83, 0x4A, 0x00,
0x00, 0x52, 0x00, 0x00, 0x93, 0x46, 0x46, 0x18,
0x83, 0x46, 0x00, 0x00, 0x93, 0x4D, 0x46, 0x00,
0x46, 0x46, 0x18, 0x83, 0x4D, 0x00, 0x00, 0x93,
0x4F, 0x46, 0x18, 0x83, 0x46, 0x00, 0x00, 0x4F,
0x00, 0x00, 0x93, 0x4D, 0x46, 0x00, 0x46, 0x46,
0x18, 0x83, 0x4D, 0x00, 0x00, 0x46, 0x00, 0x00,
0x93, 0x46, 0x46, 0x18, 0x83, 0x46, 0x00, 0x00,
0x93, 0x4B, 0x46, 0x00, 0x43, 0x46, 0x60, 0x83,
0x4B, 0x00, 0x00, 0x43, 0x00, 0x00, 0xFF, 0x2F,
0x00,
};

PROGMEM const prog_char sequence02[] = { // NicoNico
0x4D,0x54,0x68,0x64,0x00,0x00,0x00,0x06,
0x00,0x01,0x00,0x02,0x00,0x30,0x4D,0x54,
0x72,0x6B,0x00,0x00,0x00,0x19,0x00,0xFF,
0x51,0x03,0x07,0xA1,0x20,0x00,0xFF,0x58,
0x04,0x04,0x02,0x18,0x08,0x00,0xFF,0x59,
0x02,0x01,0x00,0x00,0xFF,0x2F,0x00,0x4D,
0x54,0x72,0x6B,0x00,0x00,0x00,0x35,0x00,
0x90,0x47,0x64,0x70,0x80,0x47,0x00,0x10,
0x90,0x43,0x64,0x10,0x80,0x43,0x00,0x00,
0x90,0x45,0x64,0x10,0x80,0x45,0x00,0x10,
0x90,0x47,0x64,0x10,0x80,0x47,0x00,0x00,
0x90,0x45,0x64,0x30,0x80,0x45,0x00,0x00,
0x90,0x43,0x64,0x10,0x80,0x43,0x00,0x81,
0x00,0xFF,0x2F,0x00,
};

PROGMEM const prog_char sequence03[] = { // Ievan Polkka
0x4D,	0x54,	0x68,	0x64,	0x0,	0x0,	0x0,	0x6,	0x0,	0x1,	0x0,	0x3,	0x0,	0x30,	0x4D,	0x54,
0x72,	0x6B,	0x0,	0x0,	0x0,	0x19,	0x0,	0xFF,	0x51,	0x3,	0x7,	0xA1,	0x20,	0x0,	0xFF,	0x58,
0x4,	0x4,	0x2,	0x18,	0x8,	0x0,	0xFF,	0x59,	0x2,	0x3,	0x1,	0x0,	0xFF,	0x2F,	0x0,	0x4D,
0x54,	0x72,	0x6B,	0x0,	0x0,	0x2,	0xAD,	0x81,	0x34,	0x90,	0x42,	0x64,	0x0C,	0x80,	0x42,	0x0,
0x0,	0x90,	0x3D,	0x64,	0x0C,	0x80,	0x3D,	0x0,	0x0C,	0x90,	0x42,	0x64,	0x0C,	0x80,	0x42,	0x0,
0x0C,	0x90,	0x42,	0x64,	0x24,	0x80,	0x42,	0x0,	0x0,	0x90,	0x44,	0x64,	0x0C,	0x80,	0x44,	0x0,
0x0,	0x90,	0x45,	0x64,	0x0C,	0x80,	0x45,	0x0,	0x0,	0x90,	0x45,	0x64,	0x0C,	0x80,	0x45,	0x0,
0x0,	0x90,	0x42,	0x64,	0x0C,	0x80,	0x42,	0x0,	0x0,	0x90,	0x42,	0x64,	0x0C,	0x80,	0x42,	0x0,
0x0,	0x90,	0x42,	0x64,	0x18,	0x80,	0x42,	0x0,	0x0,	0x90,	0x42,	0x64,	0x0C,	0x80,	0x42,	0x0,
0x0,	0x90,	0x45,	0x64,	0x0C,	0x80,	0x45,	0x0,	0x0,	0x90,	0x44,	0x64,	0x0C,	0x80,	0x44,	0x0,
0x0C,	0x90,	0x40,	0x64,	0x18,	0x80,	0x40,	0x0,	0x0,	0x90,	0x40,	0x64,	0x18,	0x80,	0x40,	0x0,
0x0,	0x90,	0x40,	0x64,	0x18,	0x80,	0x40,	0x0,	0x0,	0x90,	0x44,	0x64,	0x18,	0x80,	0x44,	0x0,
0x0,	0x90,	0x42,	0x64,	0x18,	0x80,	0x42,	0x0,	0x0,	0x90,	0x42,	0x64,	0x18,	0x80,	0x42,	0x0,
0x0,	0x90,	0x42,	0x64,	0x0C,	0x80,	0x42,	0x0,	0x0,	0x90,	0x42,	0x64,	0x0C,	0x80,	0x42,	0x0,
0x0,	0x90,	0x3D,	0x64,	0x0C,	0x80,	0x3D,	0x0,	0x0C,	0x90,	0x42,	0x64,	0x0C,	0x80,	0x42,	0x0,
0x0C,	0x90,	0x42,	0x64,	0x24,	0x80,	0x42,	0x0,	0x0,	0x90,	0x44,	0x64,	0x0C,	0x80,	0x44,	0x0,
0x0,	0x90,	0x45,	0x64,	0x0C,	0x80,	0x45,	0x0,	0x0C,	0x90,	0x42,	0x64,	0x0C,	0x80,	0x42,	0x0,
0x0,	0x90,	0x42,	0x64,	0x18,	0x80,	0x42,	0x0,	0x0,	0x90,	0x42,	0x64,	0x0C,	0x80,	0x42,	0x0,
0x0,	0x90,	0x42,	0x64,	0x0C,	0x80,	0x42,	0x0,	0x0,	0x90,	0x45,	0x64,	0x0C,	0x80,	0x45,	0x0,
0x0,	0x90,	0x49,	0x64,	0x0C,	0x80,	0x49,	0x0,	0x0,	0x90,	0x49,	0x64,	0x0C,	0x80,	0x49,	0x0,
0x0,	0x90,	0x49,	0x64,	0x0C,	0x80,	0x49,	0x0,	0x0,	0x90,	0x47,	0x64,	0x0C,	0x80,	0x47,	0x0,
0x0,	0x90,	0x45,	0x64,	0x0C,	0x80,	0x45,	0x0,	0x0,	0x90,	0x45,	0x64,	0x0C,	0x80,	0x45,	0x0,
0x0,	0x90,	0x44,	0x64,	0x18,	0x80,	0x44,	0x0,	0x0,	0x90,	0x45,	0x64,	0x18,	0x80,	0x45,	0x0,
0x0,	0x90,	0x42,	0x64,	0x18,	0x80,	0x42,	0x0,	0x0,	0x90,	0x42,	0x64,	0x18,	0x80,	0x42,	0x0,
0x0,	0x90,	0x42,	0x64,	0x0C,	0x80,	0x42,	0x0,	0x0,	0x90,	0x45,	0x64,	0x0C,	0x80,	0x45,	0x0,
0x0,	0x90,	0x49,	0x64,	0x0C,	0x80,	0x49,	0x0,	0x0C,	0x90,	0x49,	0x64,	0x18,	0x80,	0x49,	0x0,
0x0,	0x90,	0x47,	0x64,	0x18,	0x80,	0x47,	0x0,	0x0,	0x90,	0x45,	0x64,	0x18,	0x80,	0x45,	0x0,
0x0,	0x90,	0x44,	0x64,	0x18,	0x80,	0x44,	0x0,	0x0,	0x90,	0x40,	0x64,	0x0C,	0x80,	0x40,	0x0,
0x0,	0x90,	0x40,	0x64,	0x0C,	0x80,	0x40,	0x0,	0x0,	0x90,	0x40,	0x64,	0x18,	0x80,	0x40,	0x0,
0x0,	0x90,	0x40,	0x64,	0x0C,	0x80,	0x40,	0x0,	0x0,	0x90,	0x44,	0x64,	0x0C,	0x80,	0x44,	0x0,
0x0,	0x90,	0x47,	0x64,	0x0C,	0x80,	0x47,	0x0,	0x0,	0x90,	0x47,	0x64,	0x0C,	0x80,	0x47,	0x0,
0x0,	0x90,	0x47,	0x64,	0x0C,	0x80,	0x47,	0x0,	0x0,	0x90,	0x47,	0x64,	0x0C,	0x80,	0x47,	0x0,
0x0,	0x90,	0x45,	0x64,	0x0C,	0x80,	0x45,	0x0,	0x0,	0x90,	0x45,	0x64,	0x0C,	0x80,	0x45,	0x0,
0x0,	0x90,	0x44,	0x64,	0x0C,	0x80,	0x44,	0x0,	0x0,	0x90,	0x44,	0x64,	0x0C,	0x80,	0x44,	0x0,
0x0,	0x90,	0x45,	0x64,	0x18,	0x80,	0x45,	0x0,	0x0,	0x90,	0x42,	0x64,	0x0C,	0x80,	0x42,	0x0,
0x0,	0x90,	0x42,	0x64,	0x30,	0x80,	0x42,	0x0,	0x0,	0x90,	0x42,	0x64,	0x0C,	0x80,	0x42,	0x0,
0x0,	0x90,	0x49,	0x64,	0x0C,	0x80,	0x49,	0x0,	0x0C,	0x90,	0x49,	0x64,	0x18,	0x80,	0x49,	0x0,
0x0,	0x90,	0x47,	0x64,	0x18,	0x80,	0x47,	0x0,	0x0,	0x90,	0x45,	0x64,	0x18,	0x80,	0x45,	0x0,
0x0,	0x90,	0x44,	0x64,	0x18,	0x80,	0x44,	0x0,	0x0,	0x90,	0x40,	0x64,	0x18,	0x80,	0x40,	0x0,
0x0,	0x90,	0x40,	0x64,	0x18,	0x80,	0x40,	0x0,	0x0,	0x90,	0x40,	0x64,	0x0C,	0x80,	0x40,	0x0,
0x0,	0x90,	0x44,	0x64,	0x0C,	0x80,	0x44,	0x0,	0x0,	0x90,	0x47,	0x64,	0x0C,	0x80,	0x47,	0x0,
0x0,	0x90,	0x47,	0x64,	0x0C,	0x80,	0x47,	0x0,	0x0,	0x90,	0x47,	0x64,	0x0C,	0x80,	0x47,	0x0,
0x0,	0x90,	0x47,	0x64,	0x0C,	0x80,	0x47,	0x0,	0x0,	0x90,	0x45,	0x64,	0x0C,	0x80,	0x45,	0x0,
0x0,	0x90,	0x45,	0x64,	0x0C,	0x80,	0x45,	0x0,	0x0,	0x90,	0x44,	0x64,	0x0C,	0x80,	0x44,	0x0,
0x0,	0x90,	0x44,	0x64,	0x0C,	0x80,	0x44,	0x0,	0x0,	0x90,	0x45,	0x64,	0x18,	0x80,	0x45,	0x0,
0x0,	0x90,	0x42,	0x64,	0x0C,	0x80,	0x42,	0x0,	0x0,	0x90,	0x42,	0x64,	0x30,	0x80,	0x42,	0x0,
0x0C,	0xFF,	0x2F,	0x0,	0x4D,	0x54,	0x72,	0x6B,	0x0,	0x0,	0x1,	0x0D,	0x81,	0x58,	0x91,	0x2A,
0x64,	0x0C,	0x81,	0x2A,	0x0,	0x24,	0x91,	0x2A,	0x64,	0x0C,	0x81,	0x2A,	0x0,	0x24,	0x91,	0x2A,
0x64,	0x0C,	0x81,	0x2A,	0x0,	0x24,	0x91,	0x2A,	0x64,	0x0C,	0x81,	0x2A,	0x0,	0x24,	0x91,	0x28,
0x64,	0x0C,	0x81,	0x28,	0x0,	0x24,	0x91,	0x28,	0x64,	0x0C,	0x81,	0x28,	0x0,	0x24,	0x91,	0x2A,
0x64,	0x0C,	0x81,	0x2A,	0x0,	0x24,	0x91,	0x2A,	0x64,	0x0C,	0x81,	0x2A,	0x0,	0x24,	0x91,	0x2A,
0x64,	0x0C,	0x81,	0x2A,	0x0,	0x24,	0x91,	0x2A,	0x64,	0x0C,	0x81,	0x2A,	0x0,	0x24,	0x91,	0x2A,
0x64,	0x0C,	0x81,	0x2A,	0x0,	0x24,	0x91,	0x2A,	0x64,	0x0C,	0x81,	0x2A,	0x0,	0x24,	0x91,	0x28,
0x64,	0x0C,	0x81,	0x28,	0x0,	0x24,	0x91,	0x28,	0x64,	0x0C,	0x81,	0x28,	0x0,	0x24,	0x91,	0x2A,
0x64,	0x0C,	0x81,	0x2A,	0x0,	0x24,	0x91,	0x2A,	0x64,	0x0C,	0x81,	0x2A,	0x0,	0x24,	0x91,	0x2A,
0x64,	0x0C,	0x81,	0x2A,	0x0,	0x24,	0x91,	0x2A,	0x64,	0x0C,	0x81,	0x2A,	0x0,	0x24,	0x91,	0x28,
0x64,	0x0C,	0x81,	0x28,	0x0,	0x24,	0x91,	0x28,	0x64,	0x0C,	0x81,	0x28,	0x0,	0x24,	0x91,	0x28,
0x64,	0x0C,	0x81,	0x28,	0x0,	0x24,	0x91,	0x28,	0x64,	0x0C,	0x81,	0x28,	0x0,	0x24,	0x91,	0x2A,
0x64,	0x0C,	0x81,	0x2A,	0x0,	0x24,	0x91,	0x2A,	0x64,	0x0C,	0x81,	0x2A,	0x0,	0x24,	0x91,	0x2A,
0x64,	0x0C,	0x81,	0x2A,	0x0,	0x24,	0x91,	0x2A,	0x64,	0x0C,	0x81,	0x2A,	0x0,	0x24,	0x91,	0x28,
0x64,	0x0C,	0x81,	0x28,	0x0,	0x24,	0x91,	0x28,	0x64,	0x0C,	0x81,	0x28,	0x0,	0x24,	0x91,	0x28,
0x64,	0x0C,	0x81,	0x28,	0x0,	0x24,	0x91,	0x28,	0x64,	0x0C,	0x81,	0x28,	0x0,	0x24,	0x91,	0x2A,
0x64,	0x0C,	0x81,	0x2A,	0x0,	0x0,	0x91,	0x2A,	0x64,	0x0C,	0x81,	0x2A,	0x0,	0x0,	0x91,	0x2A,
0x64,	0x30,	0x81,	0x2A,	0x0,	0x0,	0xFF,	0x2F,	0x0,
};

PROGMEM const prog_char sequence04[] = { // Innocence
0x4D,0x54,0x68,0x64,0x0,0x0,0x0,0x6,0x0,0x1,0x0,0x3,0x1,0xE0,0x4D,0x54,
0x72,0x6B,0x0,0x0,0x0,0x1A,0x0,0xFF,0x51,0x3,0x7,0x53,0x0,0x0,0xFF,0x58,
0x4,0x4,0x2,0x18,0x8,0x0,0xFF,0x59,0x2,0x1,0x0,0x8F,0x0,0xFF,0x2F,0x0,
0x4D,0x54,0x72,0x6B,0x0,0x0,0x9,0xDF,0x96,0x2F,0x91,0x3E,0x56,0x74,0x81,0x3E,
0x0,0x82,0x65,0x91,0x43,0x53,0x83,0x16,0x81,0x43,0x0,0x54,0x91,0x45,0x54,0x81,
0x2,0x81,0x45,0x0,0x71,0x91,0x45,0x55,0x45,0x81,0x45,0x0,0x36,0x91,0x45,0x55,
0x76,0x81,0x45,0x0,0x82,0x5,0x91,0x43,0x59,0x5C,0x81,0x43,0x0,0x81,0x13,0x91,
0x45,0x56,0x5D,0x81,0x45,0x0,0x81,0x2,0x91,0x47,0x55,0x78,0x81,0x47,0x0,0x73,
0x91,0x45,0x56,0x79,0x81,0x45,0x0,0x6B,0x91,0x43,0x54,0x81,0x7,0x81,0x43,0x0,
0x77,0x91,0x45,0x54,0x81,0x6B,0x81,0x45,0x0,0x81,0x0E,0x91,0x45,0x53,0x70,0x81,
0x45,0x0,0x81,0x71,0x91,0x47,0x55,0x5E,0x81,0x47,0x0,0x81,0x4,0x91,0x47,0x57,
0x67,0x81,0x47,0x0,0x82,0x73,0x91,0x3E,0x55,0x7D,0x81,0x3E,0x0,0x76,0x91,0x43,
0x54,0x67,0x81,0x43,0x0,0x81,0x4,0x91,0x45,0x57,0x72,0x81,0x45,0x0,0x81,0x5,
0x91,0x45,0x56,0x4C,0x81,0x45,0x0,0x81,0x14,0x91,0x45,0x56,0x61,0x81,0x45,0x0,
0x81,0x0E,0x91,0x45,0x59,0x4D,0x81,0x45,0x0,0x32,0x91,0x45,0x57,0x81,0x24,0x81,
0x45,0x0,0x81,0x59,0x91,0x43,0x54,0x6C,0x81,0x43,0x0,0x81,0x0,0x91,0x42,0x57,
0x60,0x81,0x42,0x0,0x81,0x0B,0x91,0x43,0x53,0x69,0x81,0x43,0x0,0x81,0x6,0x91,
0x4A,0x59,0x81,0x10,0x81,0x4A,0x0,0x82,0x45,0x91,0x47,0x53,0x7F,0x81,0x47,0x0,
0x82,0x64,0x91,0x45,0x51,0x6F,0x81,0x45,0x0,0x83,0x0B,0x91,0x47,0x4C,0x56,0x81,
0x47,0x0,0x7A,0x91,0x47,0x55,0x76,0x81,0x47,0x0,0x79,0x91,0x40,0x56,0x6,0x45,
0x53,0x3,0x3C,0x57,0x4B,0x81,0x3C,0x0,0x6,0x40,0x0,0x0A,0x45,0x0,0x76,0x91,
0x43,0x53,0x4E,0x81,0x43,0x0,0x48,0x91,0x43,0x54,0x87,0x34,0x81,0x43,0x0,0x82,
0x6E,0x91,0x3E,0x51,0x79,0x81,0x3E,0x0,0x6B,0x91,0x3E,0x53,0x9,0x4A,0x4E,0x2,
0x43,0x54,0x81,0x4,0x81,0x3E,0x0,0x11,0x43,0x0,0x1A,0x4A,0x0,0x82,0x35,0x91,
0x47,0x50,0x7A,0x81,0x47,0x0,0x82,0x5A,0x91,0x45,0x54,0x6B,0x81,0x45,0x0,0x83,
0x9,0x91,0x3E,0x56,0x7D,0x81,0x3E,0x0,0x82,0x69,0x91,0x40,0x54,0x4,0x3C,0x56,
0x2,0x37,0x50,0x45,0x81,0x37,0x0,0x1C,0x3C,0x0,0x13,0x40,0x0,0x81,0x75,0x91,
0x43,0x54,0x81,0x29,0x81,0x43,0x0,0x81,0x49,0x91,0x47,0x56,0x63,0x81,0x47,0x0,
0x81,0x8,0x91,0x40,0x53,0x4,0x3C,0x55,0x1,0x45,0x56,0x63,0x81,0x3C,0x0,0x2,
0x40,0x0,0x30,0x45,0x0,0x82,0x55,0x91,0x43,0x50,0x5E,0x81,0x43,0x0,0x81,0x5,
0x91,0x43,0x55,0x81,0x59,0x3E,0x57,0x2,0x3C,0x57,0x82,0x0,0x81,0x3E,0x0,0x0D,
0x3C,0x0,0x3E,0x91,0x3C,0x52,0x9,0x3E,0x55,0x64,0x81,0x3C,0x0,0x4,0x3E,0x0,
0x81,0x7F,0x91,0x3E,0x54,0x1,0x3B,0x54,0x88,0x0,0x81,0x3E,0x0,0x8,0x3B,0x0,
0x0D,0x43,0x0,0x81,0x40,0x91,0x3B,0x54,0x0,0x37,0x4F,0x0,0x3E,0x55,0x81,0x35,
0x81,0x37,0x0,0x1,0x3B,0x0,0x30,0x3E,0x0,0x83,0x51,0x91,0x3E,0x56,0x65,0x81,
0x3E,0x0,0x81,0x0E,0x91,0x47,0x51,0x81,0x57,0x45,0x50,0x42,0x81,0x47,0x0,0x81,
0x40,0x91,0x43,0x50,0x1C,0x81,0x45,0x0,0x7C,0x43,0x0,0x5A,0x91,0x45,0x4E,0x7D,
0x81,0x45,0x0,0x6F,0x91,0x3E,0x4F,0x4,0x42,0x55,0x1,0x45,0x53,0x82,0x0D,0x81,
0x42,0x0,0x25,0x3E,0x0,0x3E,0x45,0x0,0x82,0x5D,0x91,0x47,0x56,0x2,0x3E,0x54,
0x3,0x42,0x55,0x6E,0x81,0x3E,0x0,0x7,0x42,0x0,0x1F,0x47,0x0,0x88,0x18,0x91,
0x37,0x50,0x3,0x40,0x52,0x2,0x3B,0x55,0x71,0x81,0x3B,0x0,0x4,0x37,0x0,0x1A,
0x40,0x0,0x84,0x48,0x91,0x3E,0x54,0x61,0x81,0x3E,0x0,0x81,0x4,0x91,0x47,0x55,
0x81,0x5F,0x45,0x4E,0x24,0x81,0x47,0x0,0x81,0x4E,0x45,0x0,0x1,0x91,0x43,0x4C,
0x81,0x61,0x45,0x4F,0x35,0x81,0x43,0x0,0x3E,0x45,0x0,0x81,0x0A,0x91,0x45,0x54,
0x0A,0x3E,0x56,0x4,0x3B,0x54,0x81,0x37,0x81,0x3E,0x0,0x45,0x3B,0x0,0x8,0x45,
0x0,0x83,0x60,0x91,0x43,0x54,0x4,0x3B,0x52,0x2,0x3E,0x54,0x71,0x81,0x3E,0x0,
0x1,0x3B,0x0,0x0A,0x43,0x0,0x88,0x8,0x91,0x40,0x50,0x2,0x37,0x51,0x2,0x3C,
0x56,0x68,0x81,0x37,0x0,0x0D,0x3C,0x0,0x1D,0x40,0x0,0x84,0x53,0x91,0x43,0x54,
0x76,0x81,0x43,0x0,0x64,0x91,0x4A,0x56,0x81,0x70,0x48,0x54,0x24,0x81,0x4A,0x0,
0x81,0x55,0x91,0x47,0x4E,0x20,0x81,0x48,0x0,0x81,0x45,0x91,0x48,0x53,0x4C,0x81,
0x47,0x0,0x15,0x48,0x0,0x81,0x0B,0x91,0x47,0x55,0x5,0x3E,0x53,0x3,0x43,0x54,
0x7C,0x81,0x3E,0x0,0x11,0x43,0x0,0x1C,0x47,0x0,0x84,0x4D,0x91,0x43,0x54,0x4F,
0x81,0x43,0x0,0x81,0x17,0x91,0x43,0x53,0x82,0x77,0x81,0x43,0x0,0x6D,0x91,0x45,
0x52,0x6A,0x81,0x45,0x0,0x83,0x0A,0x91,0x3C,0x51,0x2,0x40,0x55,0x3,0x43,0x54,
0x1,0x47,0x50,0x81,0x7,0x81,0x3C,0x0,0x1,0x40,0x0,0x0A,0x43,0x0,0x8,0x47,
0x0,0x87,0x78,0x91,0x48,0x55,0x81,0x66,0x47,0x51,0x52,0x81,0x48,0x0,0x81,0x1B,
0x91,0x45,0x56,0x2C,0x81,0x47,0x0,0x1F,0x45,0x0,0x81,0x24,0x91,0x39,0x56,0x1,
0x37,0x58,0x8,0x3E,0x56,0x84,0x59,0x81,0x3E,0x0,0x1,0x37,0x0,0x28,0x39,0x0,
0x56,0x91,0x39,0x55,0x3,0x36,0x57,0x1,0x3E,0x56,0x82,0x3A,0x81,0x36,0x0,0x13,
0x39,0x0,0x0A,0x3E,0x0,0x86,0x47,0x91,0x37,0x50,0x9,0x3B,0x53,0x5,0x3E,0x54,
0x75,0x81,0x37,0x0,0x10,0x3B,0x0,0x15,0x3E,0x0,0x84,0x35,0x91,0x3E,0x55,0x81,
0x11,0x81,0x3E,0x0,0x5E,0x91,0x47,0x56,0x81,0x61,0x45,0x51,0x32,0x81,0x47,0x0,
0x81,0x39,0x91,0x43,0x53,0x1A,0x81,0x45,0x0,0x81,0x54,0x91,0x45,0x50,0x2D,0x81,
0x43,0x0,0x47,0x45,0x0,0x6E,0x91,0x45,0x55,0x1,0x3E,0x54,0x6,0x42,0x58,0x82,
0x42,0x81,0x42,0x0,0x29,0x3E,0x0,0x21,0x45,0x0,0x82,0x5C,0x91,0x3E,0x56,0x2,
0x47,0x56,0x2,0x42,0x57,0x81,0x15,0x81,0x42,0x0,0x0A,0x3E,0x0,0x15,0x47,0x0,
0x88,0x4,0x91,0x37,0x50,0x7,0x3B,0x56,0x2,0x40,0x51,0x81,0x4,0x81,0x37,0x0,
0x1,0x3B,0x0,0x27,0x40,0x0,0x84,0x1C,0x91,0x3E,0x53,0x62,0x81,0x3E,0x0,0x81,
0x13,0x91,0x47,0x54,0x81,0x5F,0x45,0x51,0x3A,0x81,0x47,0x0,0x81,0x36,0x91,0x43,
0x4F,0x25,0x81,0x45,0x0,0x81,0x36,0x91,0x45,0x52,0x4B,0x81,0x43,0x0,0x23,0x45,
0x0,0x81,0x7,0x91,0x45,0x55,0x3,0x3E,0x57,0x2,0x3B,0x54,0x81,0x57,0x81,0x3E,
0x0,0x39,0x45,0x0,0x25,0x3B,0x0,0x83,0x2C,0x91,0x43,0x53,0x2,0x3B,0x53,0x2,
0x3E,0x53,0x81,0x1,0x81,0x3E,0x0,0x0A,0x43,0x0,0x6,0x3B,0x0,0x87,0x77,0x91,
0x37,0x51,0x5,0x40,0x52,0x2,0x3C,0x55,0x61,0x81,0x37,0x0,0x0E,0x3C,0x0,0x22,
0x40,0x0,0x82,0x4A,0x91,0x43,0x57,0x81,0x1F,0x81,0x43,0x0,0x82,0x4D,0x91,0x45,
0x50,0x81,0x20,0x81,0x45,0x0,0x82,0x44,0x91,0x47,0x52,0x78,0x81,0x47,0x0,0x82,
0x7F,0x91,0x3E,0x49,0x2,0x43,0x55,0x2,0x4A,0x52,0x81,0x46,0x81,0x4A,0x0,0x1,
0x43,0x0,0x15,0x3E,0x0,0x83,0x70,0x91,0x43,0x54,0x75,0x81,0x43,0x0,0x6F,0x91,
0x3B,0x52,0x3,0x43,0x54,0x2,0x3E,0x51,0x72,0x81,0x3B,0x0,0x7,0x3E,0x0,0x9,
0x43,0x0,0x82,0x4A,0x91,0x3E,0x50,0x7D,0x81,0x3E,0x0,0x82,0x4C,0x91,0x40,0x53,
0x9,0x37,0x4E,0x3,0x3C,0x56,0x49,0x81,0x37,0x0,0x15,0x3C,0x0,0x30,0x40,0x0,
0x81,0x6B,0x91,0x43,0x53,0x81,0x0B,0x81,0x43,0x0,0x81,0x6C,0x91,0x47,0x57,0x66,
0x81,0x47,0x0,0x81,0x0D,0x91,0x40,0x51,0x1,0x45,0x56,0x3,0x3C,0x57,0x81,0x6,
0x81,0x40,0x0,0x3,0x3C,0x0,0x1D,0x45,0x0,0x82,0x39,0x91,0x43,0x50,0x66,0x81,
0x43,0x0,0x81,0x8,0x91,0x43,0x54,0x81,0x61,0x3C,0x56,0x3,0x3E,0x55,0x82,0x14,
0x81,0x3E,0x0,0x12,0x3C,0x0,0x41,0x91,0x3C,0x4F,0x3,0x3E,0x56,0x5C,0x81,0x3C,
0x0,0x0A,0x3E,0x0,0x82,0x0D,0x91,0x3B,0x54,0x3,0x3E,0x54,0x72,0x81,0x3E,0x0,
0x5,0x3B,0x0,0x8,0x43,0x0,0x7A,0x91,0x3E,0x59,0x7D,0x81,0x3E,0x0,0x82,0x5B,
0x91,0x43,0x53,0x71,0x81,0x43,0x0,0x82,0x65,0x91,0x45,0x50,0x8,0x3E,0x56,0x4,
0x3B,0x4E,0x3E,0x81,0x3B,0x0,0x9,0x3E,0x0,0x12,0x45,0x0,0x81,0x0A,0x91,0x45,
0x54,0x46,0x81,0x45,0x0,0x32,0x91,0x45,0x54,0x81,0x14,0x81,0x45,0x0,0x81,0x61,
0x91,0x43,0x55,0x5B,0x81,0x43,0x0,0x81,0x0B,0x91,0x45,0x51,0x63,0x81,0x45,0x0,
0x81,0x8,0x91,0x47,0x53,0x7B,0x81,0x47,0x0,0x81,0x0,0x91,0x45,0x53,0x78,0x81,
0x45,0x0,0x66,0x91,0x43,0x51,0x58,0x81,0x43,0x0,0x81,0x0B,0x91,0x45,0x54,0x3,
0x3E,0x53,0x0D,0x42,0x55,0x66,0x81,0x42,0x0,0x7,0x3E,0x0,0x24,0x45,0x0,0x81,
0x58,0x91,0x45,0x54,0x74,0x81,0x45,0x0,0x81,0x77,0x91,0x3E,0x50,0x2,0x47,0x55,
0x3,0x42,0x53,0x4F,0x81,0x42,0x0,0x2,0x3E,0x0,0x7,0x47,0x0,0x81,0x0B,0x91,
0x47,0x54,0x74,0x81,0x47,0x0,0x82,0x78,0x91,0x3E,0x53,0x81,0x5B,0x43,0x54,0x2B,
0x81,0x3E,0x0,0x48,0x43,0x0,0x81,0x0B,0x91,0x3B,0x55,0x2,0x45,0x54,0x3,0x40,
0x57,0x71,0x81,0x3B,0x0,0x0E,0x40,0x0,0x10,0x45,0x0,0x64,0x91,0x45,0x58,0x57,
0x81,0x45,0x0,0x81,0x12,0x91,0x45,0x56,0x5F,0x81,0x45,0x0,0x81,0x6,0x91,0x45,
0x56,0x44,0x81,0x45,0x0,0x41,0x91,0x45,0x56,0x81,0x43,0x81,0x45,0x0,0x81,0x34,
0x91,0x43,0x50,0x73,0x81,0x43,0x0,0x73,0x91,0x42,0x55,0x67,0x81,0x42,0x0,0x81,
0x8,0x91,0x43,0x50,0x5D,0x81,0x43,0x0,0x81,0x1A,0x91,0x42,0x58,0x3,0x3E,0x53,
0x9,0x4A,0x58,0x66,0x81,0x3E,0x0,0x3,0x42,0x0,0x1C,0x4A,0x0,0x82,0x4A,0x91,
0x47,0x56,0x73,0x81,0x47,0x0,0x82,0x68,0x91,0x45,0x54,0x69,0x81,0x45,0x0,0x83,
0x5,0x91,0x47,0x4B,0x63,0x81,0x47,0x0,0x7A,0x91,0x47,0x54,0x76,0x81,0x47,0x0,
0x6F,0x91,0x3C,0x56,0x5,0x40,0x52,0x7,0x45,0x50,0x4D,0x81,0x3C,0x0,0x12,0x40,
0x0,0x0C,0x45,0x0,0x7A,0x91,0x43,0x4E,0x4A,0x81,0x43,0x0,0x39,0x91,0x43,0x55,
0x81,0x35,0x81,0x43,0x0,0x88,0x61,0x91,0x47,0x55,0x6A,0x81,0x47,0x0,0x81,0x1,
0x91,0x3E,0x55,0x5,0x3B,0x57,0x4,0x45,0x50,0x45,0x81,0x3B,0x0,0x0D,0x3E,0x0,
0x1F,0x45,0x0,0x6D,0x91,0x43,0x53,0x65,0x81,0x43,0x0,0x81,0x1C,0x91,0x3E,0x51,
0x81,0x17,0x81,0x3E,0x0,0x86,0x3E,0x91,0x3E,0x56,0x81,0x0F,0x81,0x3E,0x0,0x82,
0x48,0x91,0x40,0x53,0x2,0x3C,0x55,0x0A,0x37,0x4D,0x33,0x81,0x37,0x0,0x18,0x3C,
0x0,0x19,0x40,0x0,0x81,0x0A,0x91,0x43,0x56,0x5B,0x81,0x43,0x0,0x81,0x0C,0x91,
0x43,0x56,0x63,0x81,0x43,0x0,0x81,0x0A,0x91,0x43,0x51,0x7A,0x81,0x43,0x0,0x7D,
0x91,0x40,0x54,0x6F,0x81,0x40,0x0,0x81,0x18,0x91,0x43,0x4F,0x81,0x28,0x81,0x43,
0x0,0x82,0x2D,0x91,0x3E,0x4F,0x5A,0x81,0x3E,0x0,0x81,0x18,0x91,0x43,0x51,0x2,
0x40,0x54,0x0E,0x48,0x53,0x6C,0x81,0x48,0x0,0x9,0x43,0x0,0x10,0x40,0x0,0x42,
0x91,0x47,0x53,0x81,0x2,0x81,0x47,0x0,0x81,0x2,0x91,0x43,0x50,0x5C,0x81,0x43,
0x0,0x81,0x0A,0x91,0x40,0x4F,0x4,0x43,0x53,0x7,0x45,0x51,0x59,0x81,0x43,0x0,
0x1,0x45,0x0,0x8,0x40,0x0,0x84,0x72,0x91,0x3E,0x55,0x81,0x5A,0x43,0x54,0x38,
0x81,0x3E,0x0,0x26,0x43,0x0,0x81,0x18,0x91,0x3B,0x53,0x3,0x45,0x57,0x6,0x3E,
0x55,0x46,0x81,0x3B,0x0,0x2,0x3E,0x0,0x1D,0x45,0x0,0x81,0x7,0x91,0x45,0x56,
0x3B,0x81,0x45,0x0,0x3F,0x91,0x45,0x54,0x7E,0x81,0x45,0x0,0x81,0x7D,0x91,0x43,
0x57,0x51,0x81,0x43,0x0,0x81,0x15,0x91,0x45,0x53,0x67,0x81,0x45,0x0,0x81,0x3,
0x91,0x47,0x52,0x81,0x1A,0x81,0x47,0x0,0x57,0x91,0x45,0x50,0x79,0x81,0x45,0x0,
0x70,0x91,0x43,0x51,0x53,0x81,0x43,0x0,0x81,0x0D,0x91,0x45,0x54,0x3,0x3E,0x54,
0x0E,0x42,0x56,0x74,0x81,0x3E,0x0,0x3,0x42,0x0,0x23,0x45,0x0,0x81,0x4A,0x91,
0x45,0x52,0x6B,0x81,0x45,0x0,0x81,0x6F,0x91,0x3E,0x50,0x3,0x42,0x56,0x2,0x47,
0x56,0x53,0x81,0x3E,0x0,0x1,0x42,0x0,0x6,0x47,0x0,0x7F,0x91,0x47,0x56,0x7F,
0x81,0x47,0x0,0x82,0x57,0x91,0x3E,0x54,0x81,0x4E,0x43,0x51,0x20,0x81,0x3E,0x0,
0x46,0x43,0x0,0x81,0x42,0x91,0x45,0x58,0x7,0x3B,0x4E,0x2,0x40,0x4E,0x5F,0x81,
0x40,0x0,0x2,0x3B,0x0,0x16,0x45,0x0,0x77,0x91,0x45,0x53,0x61,0x81,0x45,0x0,
0x81,0x15,0x91,0x45,0x56,0x64,0x81,0x45,0x0,0x77,0x91,0x45,0x57,0x52,0x81,0x45,
0x0,0x30,0x91,0x45,0x53,0x81,0x69,0x81,0x45,0x0,0x81,0x14,0x91,0x43,0x4C,0x81,
0x9,0x81,0x43,0x0,0x6E,0x91,0x42,0x57,0x6A,0x81,0x42,0x0,0x76,0x91,0x43,0x50,
0x60,0x81,0x43,0x0,0x81,0x0E,0x91,0x42,0x56,0x0E,0x3E,0x53,0x9,0x4A,0x50,0x73,
0x81,0x42,0x0,0x11,0x3E,0x0,0x2,0x4A,0x0,0x82,0x4F,0x91,0x47,0x55,0x2,0x3E,
0x54,0x1,0x42,0x57,0x5D,0x81,0x42,0x0,0x6,0x3E,0x0,0x0A,0x47,0x0,0x82,0x6B,
0x91,0x45,0x55,0x2,0x3E,0x53,0x2,0x42,0x55,0x6A,0x81,0x42,0x0,0x7,0x3E,0x0,
0x6,0x45,0x0,0x82,0x57,0x91,0x3E,0x53,0x2,0x42,0x55,0x2,0x47,0x54,0x58,0x81,
0x3E,0x0,0x2,0x42,0x0,0x6,0x47,0x0,0x81,0x8,0x91,0x47,0x52,0x56,0x81,0x47,
0x0,0x81,0x1D,0x91,0x45,0x57,0x9,0x3C,0x57,0x1,0x40,0x53,0x45,0x81,0x40,0x0,
0x1,0x3C,0x0,0x24,0x45,0x0,0x81,0x0A,0x91,0x43,0x4F,0x44,0x81,0x43,0x0,0x49,
0x91,0x43,0x56,0x86,0x1C,0x81,0x43,0x0,0x84,0x3,0x91,0x3E,0x4A,0x77,0x81,0x3E,
0x0,0x67,0x91,0x3E,0x55,0x2,0x4A,0x51,0x0F,0x43,0x54,0x81,0x0C,0x81,0x43,0x0,
0x6,0x4A,0x0,0x0F,0x3E,0x0,0x82,0x35,0x91,0x47,0x54,0x52,0x81,0x47,0x0,0x83,
0x0,0x91,0x45,0x4C,0x7,0x3B,0x50,0x6,0x3E,0x55,0x6B,0x81,0x3E,0x0,0x3,0x3B,
0x0,0x11,0x45,0x0,0x82,0x53,0x91,0x3E,0x54,0x7B,0x81,0x3E,0x0,0x82,0x65,0x91,
0x40,0x51,0x2,0x3C,0x55,0x2,0x37,0x4F,0x47,0x81,0x37,0x0,0x15,0x3C,0x0,0x19,
0x40,0x0,0x81,0x78,0x91,0x3C,0x52,0x7,0x40,0x4B,0x3,0x43,0x4E,0x54,0x81,0x3C,
0x0,0x5,0x40,0x0,0x28,0x43,0x0,0x81,0x75,0x91,0x3C,0x4C,0x2,0x40,0x4F,0x2,
0x47,0x4C,0x4,0x43,0x51,0x6E,0x81,0x47,0x0,0x7,0x43,0x0,0x0D,0x40,0x0,0x0F,
0x3C,0x0,0x65,0x91,0x3C,0x52,0x2,0x43,0x4E,0x1,0x40,0x50,0x3,0x45,0x50,0x81,
0x16,0x81,0x40,0x0,0x9,0x43,0x0,0x1,0x3C,0x0,0x12,0x45,0x0,0x82,0x35,0x91,
0x43,0x4C,0x3D,0x81,0x43,0x0,0x81,0x25,0x91,0x43,0x56,0x6A,0x81,0x43,0x0,0x81,
0x0B,0x91,0x3E,0x58,0x2,0x3C,0x56,0x82,0x1A,0x81,0x3E,0x0,0x0D,0x3C,0x0,0x36,
0x91,0x3C,0x54,0x5,0x3E,0x59,0x56,0x81,0x3E,0x0,0x2,0x3C,0x0,0x82,0x1,0x91,
0x3B,0x57,0x5,0x3E,0x56,0x89,0x11,0x81,0x3E,0x0,0x0D,0x3B,0x0,0x87,0x49,0x91,
0x43,0x51,0x7,0x3B,0x50,0x1,0x3E,0x56,0x81,0x2B,0x81,0x3E,0x0,0x0E,0x3B,0x0,
0x1,0x43,0x0,0x0,0xFF,0x2F,0x0,0x4D,0x54,0x72,0x6B,0x0,0x0,0x9,0x3E,0x9D,
0x62,0x92,0x2B,0x58,0x8E,0x6C,0x82,0x2B,0x0,0x1F,0x92,0x2A,0x55,0x8F,0x6,0x28,
0x54,0x10,0x82,0x2A,0x0,0x8E,0x57,0x28,0x0,0x6,0x92,0x26,0x54,0x8E,0x15,0x82,
0x26,0x0,0x62,0x92,0x24,0x57,0x82,0x8,0x30,0x4E,0x1D,0x82,0x24,0x0,0x45,0x30,
0x0,0x7B,0x92,0x24,0x58,0x81,0x63,0x30,0x55,0x17,0x82,0x24,0x0,0x4F,0x30,0x0,
0x81,0x0E,0x92,0x24,0x57,0x81,0x6E,0x30,0x56,0x14,0x82,0x24,0x0,0x51,0x30,0x0,
0x81,0x0F,0x92,0x24,0x57,0x81,0x71,0x30,0x55,0x36,0x82,0x24,0x0,0x28,0x30,0x0,
0x81,0x16,0x92,0x23,0x56,0x81,0x72,0x2F,0x55,0x0E,0x82,0x23,0x0,0x4C,0x2F,0x0,
0x81,0x18,0x92,0x23,0x56,0x81,0x6D,0x2F,0x55,0x2A,0x82,0x23,0x0,0x3D,0x2F,0x0,
0x81,0x9,0x92,0x23,0x57,0x81,0x7C,0x2F,0x55,0x18,0x82,0x23,0x0,0x3F,0x2F,0x0,
0x81,0x16,0x92,0x23,0x53,0x81,0x73,0x2F,0x56,0x3D,0x82,0x23,0x0,0x2B,0x2F,0x0,
0x81,0x9,0x92,0x21,0x54,0x81,0x79,0x2D,0x58,0x14,0x82,0x21,0x0,0x51,0x2D,0x0,
0x81,0x1A,0x92,0x21,0x55,0x81,0x60,0x82,0x21,0x0,0x1,0x92,0x2D,0x54,0x7F,0x82,
0x2D,0x0,0x71,0x92,0x26,0x51,0x81,0x72,0x32,0x56,0x27,0x82,0x26,0x0,0x40,0x32,
0x0,0x81,0x1D,0x92,0x26,0x56,0x81,0x65,0x32,0x59,0x2,0x82,0x26,0x0,0x61,0x32,
0x0,0x81,0x10,0x92,0x1F,0x56,0x81,0x5A,0x2B,0x57,0x1A,0x82,0x1F,0x0,0x38,0x2B,
0x0,0x81,0x1F,0x92,0x1F,0x56,0x81,0x65,0x2B,0x5C,0x2A,0x82,0x1F,0x0,0x38,0x2B,
0x0,0x81,0x10,0x92,0x1F,0x56,0x81,0x6B,0x2B,0x56,0x2B,0x82,0x1F,0x0,0x34,0x2B,
0x0,0x81,0x24,0x92,0x1F,0x55,0x81,0x5F,0x2B,0x57,0x26,0x82,0x1F,0x0,0x40,0x2B,
0x0,0x81,0x0F,0x92,0x1F,0x56,0x81,0x78,0x2B,0x54,0x27,0x82,0x1F,0x0,0x3D,0x2B,
0x0,0x81,0x10,0x92,0x1F,0x57,0x81,0x6B,0x2B,0x55,0x1A,0x82,0x1F,0x0,0x51,0x2B,
0x0,0x81,0x1,0x92,0x1F,0x56,0x81,0x65,0x2B,0x53,0x26,0x82,0x1F,0x0,0x43,0x2B,
0x0,0x81,0x8,0x92,0x1F,0x54,0x81,0x69,0x2B,0x56,0x28,0x82,0x1F,0x0,0x3D,0x2B,
0x0,0x77,0x92,0x1E,0x57,0x82,0x0,0x2A,0x5C,0x0A,0x82,0x1E,0x0,0x4E,0x2A,0x0,
0x81,0x0E,0x92,0x1E,0x57,0x81,0x68,0x2A,0x61,0x1D,0x82,0x1E,0x0,0x4E,0x2A,0x0,
0x81,0x19,0x92,0x1E,0x5C,0x81,0x7B,0x2A,0x61,0x1E,0x82,0x1E,0x0,0x40,0x2A,0x0,
0x81,0x27,0x92,0x1E,0x58,0x81,0x62,0x2A,0x57,0x41,0x82,0x1E,0x0,0x15,0x2A,0x0,
0x81,0x1A,0x92,0x1C,0x55,0x81,0x66,0x28,0x4E,0x28,0x82,0x1C,0x0,0x44,0x28,0x0,
0x81,0x9,0x92,0x1C,0x57,0x81,0x6D,0x28,0x56,0x26,0x82,0x1C,0x0,0x51,0x28,0x0,
0x7B,0x92,0x1C,0x57,0x81,0x69,0x28,0x55,0x2B,0x82,0x1C,0x0,0x4F,0x28,0x0,0x76,
0x92,0x1C,0x56,0x81,0x64,0x28,0x54,0x49,0x82,0x1C,0x0,0x47,0x28,0x0,0x69,0x92,
0x1A,0x57,0x81,0x6F,0x26,0x52,0x3E,0x82,0x1A,0x0,0x2F,0x26,0x0,0x81,0x8,0x92,
0x1A,0x55,0x81,0x6A,0x26,0x54,0x13,0x82,0x1A,0x0,0x67,0x26,0x0,0x7E,0x92,0x1A,
0x55,0x81,0x69,0x26,0x54,0x13,0x82,0x1A,0x0,0x65,0x26,0x0,0x81,0x7,0x92,0x1A,
0x54,0x81,0x55,0x82,0x1A,0x0,0x0B,0x92,0x26,0x57,0x81,0x7E,0x24,0x56,0x30,0x82,
0x26,0x0,0x81,0x62,0x92,0x30,0x4F,0x8,0x82,0x24,0x0,0x4C,0x30,0x0,0x81,0x12,
0x92,0x24,0x55,0x81,0x65,0x30,0x57,0x31,0x82,0x24,0x0,0x2C,0x30,0x0,0x81,0x1F,
0x92,0x24,0x57,0x81,0x5B,0x30,0x58,0x27,0x82,0x24,0x0,0x3D,0x30,0x0,0x7F,0x92,
0x24,0x56,0x81,0x5E,0x30,0x56,0x3E,0x82,0x24,0x0,0x23,0x30,0x0,0x81,0x4,0x92,
0x23,0x56,0x81,0x72,0x2F,0x56,0x2D,0x82,0x23,0x0,0x2D,0x2F,0x0,0x81,0x2B,0x92,
0x23,0x55,0x81,0x57,0x2F,0x55,0x27,0x82,0x23,0x0,0x47,0x2F,0x0,0x81,0x1A,0x92,
0x23,0x55,0x82,0x0,0x2F,0x54,0x18,0x82,0x23,0x0,0x46,0x2F,0x0,0x81,0x1E,0x92,
0x23,0x55,0x81,0x67,0x2F,0x53,0x25,0x82,0x23,0x0,0x3A,0x2F,0x0,0x81,0x1,0x92,
0x21,0x54,0x81,0x7C,0x2D,0x51,0x21,0x82,0x21,0x0,0x48,0x2D,0x0,0x81,0x15,0x92,
0x21,0x54,0x81,0x76,0x2D,0x54,0x14,0x82,0x21,0x0,0x55,0x2D,0x0,0x81,0x7,0x92,
0x21,0x53,0x81,0x5B,0x2D,0x55,0x0B,0x82,0x21,0x0,0x6D,0x2D,0x0,0x78,0x92,0x21,
0x54,0x81,0x59,0x82,0x21,0x0,0x9,0x92,0x2D,0x56,0x81,0x59,0x82,0x2D,0x0,0x0D,
0x92,0x26,0x4A,0x81,0x6B,0x32,0x43,0x17,0x82,0x26,0x0,0x75,0x32,0x0,0x81,0x2,
0x92,0x26,0x59,0x81,0x63,0x32,0x56,0x11,0x82,0x26,0x0,0x4F,0x32,0x0,0x81,0x27,
0x92,0x26,0x57,0x81,0x67,0x32,0x57,0x0F,0x82,0x26,0x0,0x55,0x32,0x0,0x81,0x24,
0x92,0x26,0x56,0x81,0x57,0x32,0x54,0x39,0x82,0x26,0x0,0x2E,0x32,0x0,0x81,0x15,
0x92,0x1F,0x53,0x81,0x61,0x2B,0x4F,0x36,0x82,0x1F,0x0,0x2A,0x2B,0x0,0x81,0x18,
0x92,0x1F,0x56,0x81,0x61,0x2B,0x54,0x1D,0x82,0x1F,0x0,0x4F,0x2B,0x0,0x81,0x15,
0x92,0x1F,0x55,0x81,0x5E,0x2B,0x57,0x29,0x82,0x1F,0x0,0x44,0x2B,0x0,0x81,0x0A,
0x92,0x1F,0x54,0x81,0x65,0x2B,0x57,0x0E,0x82,0x1F,0x0,0x4F,0x2B,0x0,0x7F,0x92,
0x1E,0x5C,0x81,0x71,0x2A,0x58,0x9,0x82,0x1E,0x0,0x56,0x2A,0x0,0x81,0x32,0x92,
0x1E,0x61,0x81,0x66,0x2A,0x58,0x1B,0x82,0x1E,0x0,0x46,0x2A,0x0,0x81,0x19,0x92,
0x1E,0x57,0x81,0x6C,0x2A,0x54,0x14,0x82,0x1E,0x0,0x4E,0x2A,0x0,0x81,0x21,0x92,
0x1E,0x57,0x81,0x64,0x2A,0x57,0x42,0x82,0x1E,0x0,0x14,0x2A,0x0,0x81,0x1B,0x92,
0x1C,0x4C,0x81,0x78,0x28,0x4B,0x12,0x82,0x1C,0x0,0x4E,0x28,0x0,0x81,0x12,0x92,
0x1C,0x55,0x81,0x6E,0x28,0x54,0x2B,0x82,0x1C,0x0,0x3B,0x28,0x0,0x81,0x17,0x92,
0x1C,0x56,0x81,0x66,0x28,0x50,0x31,0x82,0x1C,0x0,0x2F,0x28,0x0,0x81,0x0D,0x92,
0x1C,0x53,0x81,0x70,0x28,0x53,0x3D,0x82,0x1C,0x0,0x28,0x28,0x0,0x6C,0x92,0x1A,
0x55,0x81,0x7F,0x26,0x50,0x3F,0x82,0x1A,0x0,0x24,0x26,0x0,0x81,0x5,0x92,0x1A,
0x55,0x81,0x70,0x26,0x51,0x3B,0x82,0x1A,0x0,0x39,0x26,0x0,0x81,0x4,0x92,0x1A,
0x55,0x81,0x75,0x26,0x51,0x26,0x82,0x1A,0x0,0x4F,0x26,0x0,0x81,0x2,0x92,0x1A,
0x54,0x81,0x63,0x82,0x1A,0x0,0x1,0x92,0x26,0x54,0x81,0x30,0x82,0x26,0x0,0x31,
0x92,0x24,0x56,0x81,0x7D,0x30,0x49,0x0F,0x82,0x24,0x0,0x4D,0x30,0x0,0x81,0x20,
0x92,0x24,0x57,0x81,0x6F,0x30,0x53,0x28,0x82,0x24,0x0,0x2E,0x30,0x0,0x81,0x19,
0x92,0x24,0x56,0x81,0x77,0x30,0x52,0x28,0x82,0x24,0x0,0x35,0x30,0x0,0x81,0x9,
0x92,0x24,0x55,0x81,0x72,0x30,0x55,0x38,0x82,0x24,0x0,0x23,0x30,0x0,0x81,0x0B,
0x92,0x23,0x54,0x82,0x5,0x2F,0x53,0x32,0x82,0x23,0x0,0x2B,0x2F,0x0,0x81,0x15,
0x92,0x23,0x53,0x81,0x6F,0x2F,0x54,0x23,0x82,0x23,0x0,0x38,0x2F,0x0,0x81,0x13,
0x92,0x23,0x54,0x81,0x70,0x2F,0x50,0x16,0x82,0x23,0x0,0x56,0x2F,0x0,0x81,0x0F,
0x92,0x23,0x52,0x81,0x5D,0x2F,0x54,0x3C,0x82,0x23,0x0,0x29,0x2F,0x0,0x81,0x2,
0x92,0x21,0x53,0x81,0x66,0x2D,0x55,0x21,0x82,0x21,0x0,0x46,0x2D,0x0,0x81,0x15,
0x92,0x21,0x51,0x81,0x77,0x2D,0x50,0x7,0x82,0x21,0x0,0x81,0x9,0x2D,0x0,0x53,
0x92,0x26,0x54,0x81,0x76,0x32,0x51,0x2C,0x82,0x26,0x0,0x3F,0x32,0x0,0x81,0x17,
0x92,0x26,0x55,0x81,0x70,0x32,0x58,0x33,0x82,0x26,0x0,0x22,0x32,0x0,0x81,0x1A,
0x92,0x1F,0x55,0x81,0x5A,0x2B,0x56,0x27,0x82,0x1F,0x0,0x2D,0x2B,0x0,0x81,0x22,
0x92,0x1F,0x53,0x81,0x75,0x2B,0x55,0x2D,0x82,0x1F,0x0,0x3C,0x2B,0x0,0x81,0x11,
0x92,0x1F,0x55,0x81,0x76,0x2B,0x51,0x1F,0x82,0x1F,0x0,0x49,0x2B,0x0,0x81,0x0B,
0x92,0x1F,0x54,0x81,0x64,0x2B,0x50,0x29,0x82,0x1F,0x0,0x40,0x2B,0x0,0x81,0x7,
0x92,0x1F,0x55,0x81,0x61,0x2B,0x52,0x2A,0x82,0x1F,0x0,0x40,0x2B,0x0,0x81,0x10,
0x92,0x1F,0x55,0x81,0x75,0x2B,0x51,0x2B,0x82,0x1F,0x0,0x3C,0x2B,0x0,0x81,0x0E,
0x92,0x1F,0x54,0x81,0x66,0x2B,0x52,0x33,0x82,0x1F,0x0,0x43,0x2B,0x0,0x81,0x0,
0x92,0x1F,0x53,0x81,0x6F,0x2B,0x56,0x18,0x82,0x1F,0x0,0x49,0x2B,0x0,0x7E,0x92,
0x1E,0x5C,0x81,0x68,0x2A,0x55,0x29,0x82,0x1E,0x0,0x4E,0x2A,0x0,0x81,0x0B,0x92,
0x1E,0x58,0x81,0x54,0x2A,0x56,0x20,0x82,0x1E,0x0,0x54,0x2A,0x0,0x81,0x14,0x92,
0x1E,0x5C,0x81,0x69,0x2A,0x57,0x27,0x82,0x1E,0x0,0x4F,0x2A,0x0,0x81,0x12,0x92,
0x1E,0x57,0x81,0x5D,0x2A,0x55,0x3E,0x82,0x1E,0x0,0x2A,0x2A,0x0,0x81,0x18,0x92,
0x1C,0x53,0x81,0x5E,0x28,0x49,0x0F,0x82,0x1C,0x0,0x57,0x28,0x0,0x81,0x5,0x92,
0x1C,0x55,0x81,0x6E,0x28,0x4E,0x15,0x82,0x1C,0x0,0x61,0x28,0x0,0x81,0x6,0x92,
0x1C,0x55,0x81,0x69,0x28,0x51,0x23,0x82,0x1C,0x0,0x43,0x28,0x0,0x81,0x28,0x92,
0x1C,0x55,0x81,0x59,0x28,0x55,0x33,0x82,0x1C,0x0,0x3C,0x28,0x0,0x75,0x92,0x1A,
0x52,0x81,0x7C,0x26,0x4F,0x24,0x82,0x1A,0x0,0x4F,0x26,0x0,0x81,0x9,0x92,0x1A,
0x55,0x81,0x69,0x26,0x52,0x32,0x82,0x1A,0x0,0x4E,0x26,0x0,0x7F,0x92,0x1A,0x55,
0x81,0x69,0x26,0x51,0x1B,0x82,0x1A,0x0,0x58,0x26,0x0,0x81,0x0D,0x92,0x1A,0x56,
0x81,0x49,0x82,0x1A,0x0,0x8,0x92,0x26,0x55,0x81,0x2A,0x82,0x26,0x0,0x38,0x92,
0x24,0x55,0x82,0x7,0x30,0x46,0x0E,0x82,0x24,0x0,0x48,0x30,0x0,0x81,0x7,0x92,
0x24,0x56,0x81,0x69,0x30,0x53,0x2D,0x82,0x24,0x0,0x41,0x30,0x0,0x81,0x1F,0x92,
0x24,0x56,0x81,0x65,0x30,0x56,0x27,0x82,0x24,0x0,0x3C,0x30,0x0,0x81,0x21,0x92,
0x24,0x55,0x81,0x60,0x30,0x56,0x30,0x82,0x24,0x0,0x2E,0x30,0x0,0x7B,0x92,0x23,
0x55,0x81,0x71,0x2F,0x53,0x18,0x82,0x23,0x0,0x44,0x2F,0x0,0x81,0x1D,0x92,0x23,
0x55,0x81,0x64,0x2F,0x54,0x11,0x82,0x23,0x0,0x56,0x2F,0x0,0x81,0x0A,0x92,0x23,
0x55,0x81,0x71,0x2F,0x53,0x21,0x82,0x23,0x0,0x3F,0x2F,0x0,0x81,0x11,0x92,0x23,
0x54,0x81,0x78,0x2F,0x55,0x31,0x82,0x23,0x0,0x2A,0x2F,0x0,0x81,0x8,0x92,0x21,
0x53,0x81,0x7D,0x2D,0x55,0x1A,0x82,0x21,0x0,0x46,0x2D,0x0,0x81,0x1B,0x92,0x21,
0x53,0x81,0x66,0x2D,0x55,0x0B,0x82,0x21,0x0,0x5C,0x2D,0x0,0x81,0x9,0x92,0x21,
0x53,0x81,0x78,0x2D,0x54,0x1B,0x82,0x21,0x0,0x56,0x2D,0x0,0x81,0x8,0x92,0x21,
0x54,0x81,0x5C,0x82,0x21,0x0,0x8,0x92,0x2D,0x57,0x81,0x7,0x82,0x2D,0x0,0x53,
0x92,0x26,0x54,0x82,0x4,0x32,0x53,0x39,0x82,0x26,0x0,0x39,0x32,0x0,0x81,0x1C,
0x92,0x26,0x57,0x81,0x62,0x32,0x56,0x2A,0x82,0x26,0x0,0x40,0x32,0x0,0x81,0x0D,
0x92,0x26,0x56,0x81,0x6F,0x32,0x58,0x6,0x82,0x26,0x0,0x60,0x32,0x0,0x81,0x1C,
0x92,0x26,0x56,0x81,0x58,0x32,0x56,0x35,0x82,0x26,0x0,0x20,0x32,0x0,0x81,0x1D,
0x92,0x1F,0x54,0x81,0x59,0x2B,0x57,0x14,0x82,0x1F,0x0,0x4A,0x2B,0x0,0x81,0x1D,
0x92,0x1F,0x55,0x81,0x61,0x2B,0x53,0x1F,0x82,0x1F,0x0,0x57,0x2B,0x0,0x81,0x10,
0x92,0x1F,0x54,0x81,0x65,0x2B,0x54,0x2E,0x82,0x1F,0x0,0x34,0x2B,0x0,0x81,0x19,
0x92,0x1F,0x54,0x81,0x6C,0x2B,0x61,0x8,0x82,0x1F,0x0,0x53,0x2B,0x0,0x81,0x3,
0x92,0x1E,0x4F,0x81,0x69,0x2A,0x57,0x2C,0x82,0x1E,0x0,0x38,0x2A,0x0,0x81,0x12,
0x92,0x1E,0x58,0x81,0x6E,0x2A,0x66,0x2A,0x82,0x1E,0x0,0x38,0x2A,0x0,0x81,0x22,
0x92,0x1E,0x5C,0x81,0x67,0x2A,0x61,0x19,0x82,0x1E,0x0,0x40,0x2A,0x0,0x81,0x3B,
0x92,0x1E,0x5C,0x81,0x4D,0x2A,0x58,0x35,0x82,0x1E,0x0,0x20,0x2A,0x0,0x81,0x1A,
0x92,0x1C,0x55,0x81,0x59,0x28,0x4E,0x26,0x82,0x1C,0x0,0x47,0x28,0x0,0x81,0x0A,
0x92,0x1C,0x54,0x81,0x74,0x28,0x53,0x0E,0x82,0x1C,0x0,0x5E,0x28,0x0,0x81,0x2,
0x92,0x1C,0x56,0x81,0x72,0x28,0x50,0x1A,0x82,0x1C,0x0,0x45,0x28,0x0,0x81,0x14,
0x92,0x1C,0x53,0x81,0x7C,0x28,0x53,0x3F,0x82,0x1C,0x0,0x30,0x28,0x0,0x81,0x2,
0x92,0x1A,0x54,0x81,0x74,0x26,0x51,0x2A,0x82,0x1A,0x0,0x40,0x26,0x0,0x81,0x11,
0x92,0x1A,0x56,0x81,0x74,0x26,0x54,0x19,0x82,0x1A,0x0,0x49,0x26,0x0,0x81,0x9,
0x92,0x1A,0x55,0x81,0x68,0x26,0x51,0x16,0x82,0x1A,0x0,0x54,0x26,0x0,0x81,0x12,
0x92,0x1A,0x56,0x81,0x47,0x82,0x1A,0x0,0x0,0x92,0x26,0x51,0x81,0x25,0x82,0x26,
0x0,0x40,0x92,0x24,0x54,0x81,0x7E,0x30,0x47,0x11,0x82,0x24,0x0,0x50,0x30,0x0,
0x81,0x1C,0x92,0x24,0x54,0x81,0x5D,0x82,0x24,0x0,0x8,0x92,0x30,0x55,0x7A,0x82,
0x30,0x0,0x81,0x0C,0x92,0x24,0x56,0x81,0x6E,0x30,0x54,0x2F,0x82,0x24,0x0,0x3B,
0x30,0x0,0x81,0x0E,0x92,0x24,0x54,0x81,0x6A,0x30,0x57,0x36,0x82,0x24,0x0,0x2D,
0x30,0x0,0x81,0x12,0x92,0x23,0x55,0x81,0x6F,0x2F,0x55,0x1E,0x82,0x23,0x0,0x3B,
0x2F,0x0,0x81,0x17,0x92,0x23,0x55,0x81,0x63,0x2F,0x54,0x32,0x82,0x23,0x0,0x3F,
0x2F,0x0,0x7C,0x92,0x23,0x54,0x81,0x77,0x2F,0x54,0x1A,0x82,0x23,0x0,0x47,0x2F,
0x0,0x81,0x1D,0x92,0x23,0x54,0x81,0x60,0x2F,0x53,0x37,0x82,0x23,0x0,0x30,0x2F,
0x0,0x81,0x6,0x92,0x21,0x50,0x81,0x74,0x2D,0x55,0x24,0x82,0x21,0x0,0x43,0x2D,
0x0,0x81,0x15,0x92,0x21,0x54,0x81,0x51,0x2D,0x54,0x2,0x82,0x21,0x0,0x81,0x54,
0x2D,0x0,0x6,0x92,0x26,0x50,0x81,0x74,0x32,0x4A,0x35,0x82,0x26,0x0,0x57,0x32,
0x0,0x81,0x4,0x92,0x26,0x56,0x81,0x69,0x32,0x56,0x2D,0x82,0x26,0x0,0x32,0x32,
0x0,0x81,0x2C,0x92,0x1F,0x51,0x81,0x6B,0x2B,0x56,0x19,0x82,0x1F,0x0,0x49,0x2B,
0x0,0x81,0x11,0x92,0x1F,0x54,0x81,0x71,0x82,0x1F,0x0,0x2,0x92,0x2B,0x5C,0x60,
0x82,0x2B,0x0,0x81,0x13,0x92,0x1F,0x53,0x81,0x5E,0x82,0x1F,0x0,0x2,0x92,0x2B,
0x57,0x65,0x82,0x2B,0x0,0x81,0x2,0x92,0x1F,0x51,0x81,0x76,0x2B,0x58,0x2F,0x82,
0x1F,0x0,0x53,0x2B,0x0,0x81,0x4,0x92,0x1F,0x54,0x81,0x41,0x82,0x1F,0x0,0x85,
0x60,0x92,0x1F,0x58,0x81,0x27,0x82,0x1F,0x0,0x0,0xFF,0x2F,0x0,
};

PROGMEM const prog_char sequence05[] = { // Nya5nya!
0x4D,0x54,0x68,0x64,0x00,0x00,0x00,0x06,
0x00,0x01,0x00,0x02,0x01,0xE0,0x4D,0x54,
0x72,0x6B,0x00,0x00,0x00,0x19,0x00,0xFF,
0x51,0x03,0x06,0x72,0x84,0x00,0xFF,0x58,
0x04,0x04,0x02,0x18,0x08,0x00,0xFF,0x59,
0x02,0x05,0x00,0x00,0xFF,0x2F,0x00,0x4D,
0x54,0x72,0x6B,0x00,0x00,0x06,0xD0,0x00,
0x90,0x4E,0x64,0x81,0x6E,0x80,0x4E,0x00,
0x02,0x90,0x50,0x64,0x81,0x6E,0x80,0x50,
0x00,0x02,0x90,0x49,0x64,0x76,0x80,0x49,
0x00,0x02,0x90,0x4B,0x64,0x81,0x6E,0x80,
0x4B,0x00,0x02,0x90,0x47,0x64,0x76,0x80,
0x47,0x00,0x02,0x90,0x4A,0x64,0x76,0x80,
0x4A,0x00,0x02,0x90,0x49,0x64,0x76,0x80,
0x49,0x00,0x02,0x90,0x47,0x64,0x81,0x6E,
0x80,0x47,0x00,0x02,0x90,0x47,0x64,0x81,
0x6E,0x80,0x47,0x00,0x02,0x90,0x49,0x64,
0x81,0x6E,0x80,0x49,0x00,0x02,0x90,0x4A,
0x64,0x81,0x6E,0x80,0x4A,0x00,0x02,0x90,
0x4A,0x64,0x76,0x80,0x4A,0x00,0x02,0x90,
0x49,0x64,0x76,0x80,0x49,0x00,0x02,0x90,
0x47,0x64,0x76,0x80,0x47,0x00,0x02,0x90,
0x49,0x64,0x76,0x80,0x49,0x00,0x02,0x90,
0x4B,0x64,0x76,0x80,0x4B,0x00,0x02,0x90,
0x4E,0x64,0x76,0x80,0x4E,0x00,0x02,0x90,
0x50,0x64,0x76,0x80,0x50,0x00,0x02,0x90,
0x4B,0x64,0x76,0x80,0x4B,0x00,0x02,0x90,
0x4E,0x64,0x76,0x80,0x4E,0x00,0x02,0x90,
0x49,0x64,0x76,0x80,0x49,0x00,0x02,0x90,
0x4B,0x64,0x76,0x80,0x4B,0x00,0x02,0x90,
0x47,0x64,0x76,0x80,0x47,0x00,0x02,0x90,
0x49,0x64,0x76,0x80,0x49,0x00,0x02,0x90,
0x47,0x64,0x76,0x80,0x47,0x00,0x02,0x90,
0x4B,0x64,0x81,0x6E,0x80,0x4B,0x00,0x02,
0x90,0x4E,0x64,0x81,0x6E,0x80,0x4E,0x00,
0x02,0x90,0x50,0x64,0x76,0x80,0x50,0x00,
0x02,0x90,0x4B,0x64,0x76,0x80,0x4B,0x00,
0x02,0x90,0x4E,0x64,0x76,0x80,0x4E,0x00,
0x02,0x90,0x49,0x64,0x76,0x80,0x49,0x00,
0x02,0x90,0x4B,0x64,0x76,0x80,0x4B,0x00,
0x02,0x90,0x47,0x64,0x76,0x80,0x47,0x00,
0x02,0x90,0x4A,0x64,0x76,0x80,0x4A,0x00,
0x02,0x90,0x4B,0x64,0x76,0x80,0x4B,0x00,
0x02,0x90,0x4A,0x64,0x76,0x80,0x4A,0x00,
0x02,0x90,0x49,0x64,0x76,0x80,0x49,0x00,
0x02,0x90,0x47,0x64,0x76,0x80,0x47,0x00,
0x02,0x90,0x49,0x64,0x76,0x80,0x49,0x00,
0x02,0x90,0x4A,0x64,0x81,0x6E,0x80,0x4A,
0x00,0x02,0x90,0x47,0x64,0x76,0x80,0x47,
0x00,0x02,0x90,0x49,0x64,0x76,0x80,0x49,
0x00,0x02,0x90,0x4B,0x64,0x76,0x80,0x4B,
0x00,0x02,0x90,0x4E,0x64,0x76,0x80,0x4E,
0x00,0x02,0x90,0x49,0x64,0x76,0x80,0x49,
0x00,0x02,0x90,0x4A,0x64,0x76,0x80,0x4A,
0x00,0x02,0x90,0x49,0x64,0x76,0x80,0x49,
0x00,0x02,0x90,0x47,0x64,0x76,0x80,0x47,
0x00,0x02,0x90,0x49,0x64,0x81,0x6E,0x80,
0x49,0x00,0x02,0x90,0x47,0x64,0x81,0x6E,
0x80,0x47,0x00,0x02,0x90,0x49,0x64,0x81,
0x6E,0x80,0x49,0x00,0x02,0x90,0x4E,0x64,
0x81,0x6E,0x80,0x4E,0x00,0x02,0x90,0x50,
0x64,0x81,0x6E,0x80,0x50,0x00,0x02,0x90,
0x49,0x64,0x76,0x80,0x49,0x00,0x02,0x90,
0x4B,0x64,0x81,0x6E,0x80,0x4B,0x00,0x02,
0x90,0x47,0x64,0x76,0x80,0x47,0x00,0x02,
0x90,0x4A,0x64,0x76,0x80,0x4A,0x00,0x02,
0x90,0x49,0x64,0x76,0x80,0x49,0x00,0x02,
0x90,0x47,0x64,0x81,0x6E,0x80,0x47,0x00,
0x02,0x90,0x47,0x64,0x81,0x6E,0x80,0x47,
0x00,0x02,0x90,0x49,0x64,0x81,0x6E,0x80,
0x49,0x00,0x02,0x90,0x4A,0x64,0x81,0x6E,
0x80,0x4A,0x00,0x02,0x90,0x4A,0x64,0x76,
0x80,0x4A,0x00,0x02,0x90,0x49,0x64,0x76,
0x80,0x49,0x00,0x02,0x90,0x47,0x64,0x76,
0x80,0x47,0x00,0x02,0x90,0x49,0x64,0x76,
0x80,0x49,0x00,0x02,0x90,0x4B,0x64,0x76,
0x80,0x4B,0x00,0x02,0x90,0x4E,0x64,0x76,
0x80,0x4E,0x00,0x02,0x90,0x50,0x64,0x76,
0x80,0x50,0x00,0x02,0x90,0x4B,0x64,0x76,
0x80,0x4B,0x00,0x02,0x90,0x4E,0x64,0x76,
0x80,0x4E,0x00,0x02,0x90,0x49,0x64,0x76,
0x80,0x49,0x00,0x02,0x90,0x4B,0x64,0x76,
0x80,0x4B,0x00,0x02,0x90,0x47,0x64,0x76,
0x80,0x47,0x00,0x02,0x90,0x49,0x64,0x76,
0x80,0x49,0x00,0x02,0x90,0x47,0x64,0x76,
0x80,0x47,0x00,0x02,0x90,0x4B,0x64,0x81,
0x6E,0x80,0x4B,0x00,0x02,0x90,0x4E,0x64,
0x81,0x6E,0x80,0x4E,0x00,0x02,0x90,0x50,
0x64,0x76,0x80,0x50,0x00,0x02,0x90,0x4B,
0x64,0x76,0x80,0x4B,0x00,0x02,0x90,0x4E,
0x64,0x76,0x80,0x4E,0x00,0x02,0x90,0x49,
0x64,0x76,0x80,0x49,0x00,0x02,0x90,0x4B,
0x64,0x76,0x80,0x4B,0x00,0x02,0x90,0x47,
0x64,0x76,0x80,0x47,0x00,0x02,0x90,0x4A,
0x64,0x76,0x80,0x4A,0x00,0x02,0x90,0x4B,
0x64,0x76,0x80,0x4B,0x00,0x02,0x90,0x4A,
0x64,0x76,0x80,0x4A,0x00,0x02,0x90,0x49,
0x64,0x76,0x80,0x49,0x00,0x02,0x90,0x47,
0x64,0x76,0x80,0x47,0x00,0x02,0x90,0x49,
0x64,0x76,0x80,0x49,0x00,0x02,0x90,0x4A,
0x64,0x81,0x6E,0x80,0x4A,0x00,0x02,0x90,
0x47,0x64,0x76,0x80,0x47,0x00,0x02,0x90,
0x49,0x64,0x76,0x80,0x49,0x00,0x02,0x90,
0x4B,0x64,0x76,0x80,0x4B,0x00,0x02,0x90,
0x4E,0x64,0x76,0x80,0x4E,0x00,0x02,0x90,
0x49,0x64,0x76,0x80,0x49,0x00,0x02,0x90,
0x4A,0x64,0x76,0x80,0x4A,0x00,0x02,0x90,
0x49,0x64,0x76,0x80,0x49,0x00,0x02,0x90,
0x47,0x64,0x76,0x80,0x47,0x00,0x02,0x90,
0x49,0x64,0x81,0x6E,0x80,0x49,0x00,0x02,
0x90,0x47,0x64,0x81,0x6E,0x80,0x47,0x00,
0x02,0x90,0x47,0x64,0x81,0x6E,0x80,0x47,
0x00,0x02,0x90,0x47,0x64,0x81,0x6E,0x80,
0x47,0x00,0x02,0x90,0x42,0x64,0x76,0x80,
0x42,0x00,0x02,0x90,0x44,0x64,0x76,0x80,
0x44,0x00,0x02,0x90,0x47,0x64,0x81,0x6E,
0x80,0x47,0x00,0x02,0x90,0x42,0x64,0x76,
0x80,0x42,0x00,0x02,0x90,0x44,0x64,0x76,
0x80,0x44,0x00,0x02,0x90,0x47,0x64,0x76,
0x80,0x47,0x00,0x02,0x90,0x49,0x64,0x76,
0x80,0x49,0x00,0x02,0x90,0x4B,0x64,0x76,
0x80,0x4B,0x00,0x02,0x90,0x47,0x64,0x76,
0x80,0x47,0x00,0x02,0x90,0x4C,0x64,0x76,
0x80,0x4C,0x00,0x02,0x90,0x4B,0x64,0x76,
0x80,0x4B,0x00,0x02,0x90,0x4C,0x64,0x76,
0x80,0x4C,0x00,0x02,0x90,0x4E,0x64,0x76,
0x80,0x4E,0x00,0x02,0x90,0x47,0x64,0x81,
0x6E,0x80,0x47,0x00,0x02,0x90,0x47,0x64,
0x81,0x6E,0x80,0x47,0x00,0x02,0x90,0x42,
0x64,0x76,0x80,0x42,0x00,0x02,0x90,0x44,
0x64,0x76,0x80,0x44,0x00,0x02,0x90,0x47,
0x64,0x76,0x80,0x47,0x00,0x02,0x90,0x42,
0x64,0x76,0x80,0x42,0x00,0x02,0x90,0x4C,
0x64,0x76,0x80,0x4C,0x00,0x02,0x90,0x4B,
0x64,0x76,0x80,0x4B,0x00,0x02,0x90,0x49,
0x64,0x76,0x80,0x49,0x00,0x02,0x90,0x47,
0x64,0x76,0x80,0x47,0x00,0x02,0x90,0x42,
0x64,0x76,0x80,0x42,0x00,0x02,0x90,0x3F,
0x64,0x76,0x80,0x3F,0x00,0x02,0x90,0x40,
0x64,0x76,0x80,0x40,0x00,0x02,0x90,0x42,
0x64,0x76,0x80,0x42,0x00,0x02,0x90,0x47,
0x64,0x81,0x6E,0x80,0x47,0x00,0x02,0x90,
0x42,0x64,0x76,0x80,0x42,0x00,0x02,0x90,
0x44,0x64,0x76,0x80,0x44,0x00,0x02,0x90,
0x47,0x64,0x81,0x6E,0x80,0x47,0x00,0x02,
0x90,0x42,0x64,0x76,0x80,0x42,0x00,0x02,
0x90,0x44,0x64,0x76,0x80,0x44,0x00,0x02,
0x90,0x47,0x64,0x76,0x80,0x47,0x00,0x02,
0x90,0x47,0x64,0x76,0x80,0x47,0x00,0x02,
0x90,0x49,0x64,0x76,0x80,0x49,0x00,0x02,
0x90,0x4B,0x64,0x76,0x80,0x4B,0x00,0x02,
0x90,0x47,0x64,0x76,0x80,0x47,0x00,0x02,
0x90,0x42,0x64,0x76,0x80,0x42,0x00,0x02,
0x90,0x44,0x64,0x76,0x80,0x44,0x00,0x02,
0x90,0x42,0x64,0x76,0x80,0x42,0x00,0x02,
0x90,0x47,0x64,0x81,0x6E,0x80,0x47,0x00,
0x02,0x90,0x47,0x64,0x76,0x80,0x47,0x00,
0x02,0x90,0x46,0x64,0x76,0x80,0x46,0x00,
0x02,0x90,0x47,0x64,0x76,0x80,0x47,0x00,
0x02,0x90,0x42,0x64,0x76,0x80,0x42,0x00,
0x02,0x90,0x44,0x64,0x76,0x80,0x44,0x00,
0x02,0x90,0x47,0x64,0x76,0x80,0x47,0x00,
0x02,0x90,0x4C,0x64,0x76,0x80,0x4C,0x00,
0x02,0x90,0x4B,0x64,0x76,0x80,0x4B,0x00,
0x02,0x90,0x4C,0x64,0x76,0x80,0x4C,0x00,
0x02,0x90,0x4E,0x64,0x76,0x80,0x4E,0x00,
0x02,0x90,0x47,0x64,0x81,0x6E,0x80,0x47,
0x00,0x02,0x90,0x46,0x64,0x81,0x6E,0x80,
0x46,0x00,0x02,0x90,0x47,0x64,0x81,0x6E,
0x80,0x47,0x00,0x02,0x90,0x42,0x64,0x76,
0x80,0x42,0x00,0x02,0x90,0x44,0x64,0x76,
0x80,0x44,0x00,0x02,0x90,0x47,0x64,0x81,
0x6E,0x80,0x47,0x00,0x02,0x90,0x42,0x64,
0x76,0x80,0x42,0x00,0x02,0x90,0x44,0x64,
0x76,0x80,0x44,0x00,0x02,0x90,0x47,0x64,
0x76,0x80,0x47,0x00,0x02,0x90,0x49,0x64,
0x76,0x80,0x49,0x00,0x02,0x90,0x4B,0x64,
0x76,0x80,0x4B,0x00,0x02,0x90,0x47,0x64,
0x76,0x80,0x47,0x00,0x02,0x90,0x4C,0x64,
0x76,0x80,0x4C,0x00,0x02,0x90,0x4B,0x64,
0x76,0x80,0x4B,0x00,0x02,0x90,0x4C,0x64,
0x76,0x80,0x4C,0x00,0x02,0x90,0x4E,0x64,
0x76,0x80,0x4E,0x00,0x02,0x90,0x47,0x64,
0x81,0x6E,0x80,0x47,0x00,0x02,0x90,0x47,
0x64,0x81,0x6E,0x80,0x47,0x00,0x02,0x90,
0x42,0x64,0x76,0x80,0x42,0x00,0x02,0x90,
0x44,0x64,0x76,0x80,0x44,0x00,0x02,0x90,
0x47,0x64,0x76,0x80,0x47,0x00,0x02,0x90,
0x42,0x64,0x76,0x80,0x42,0x00,0x02,0x90,
0x4C,0x64,0x76,0x80,0x4C,0x00,0x02,0x90,
0x4B,0x64,0x76,0x80,0x4B,0x00,0x02,0x90,
0x49,0x64,0x76,0x80,0x49,0x00,0x02,0x90,
0x47,0x64,0x76,0x80,0x47,0x00,0x02,0x90,
0x42,0x64,0x76,0x80,0x42,0x00,0x02,0x90,
0x3F,0x64,0x76,0x80,0x3F,0x00,0x02,0x90,
0x40,0x64,0x76,0x80,0x40,0x00,0x02,0x90,
0x42,0x64,0x76,0x80,0x42,0x00,0x02,0x90,
0x47,0x64,0x81,0x6E,0x80,0x47,0x00,0x02,
0x90,0x42,0x64,0x76,0x80,0x42,0x00,0x02,
0x90,0x44,0x64,0x76,0x80,0x44,0x00,0x02,
0x90,0x47,0x64,0x81,0x6E,0x80,0x47,0x00,
0x02,0x90,0x42,0x64,0x76,0x80,0x42,0x00,
0x02,0x90,0x44,0x64,0x76,0x80,0x44,0x00,
0x02,0x90,0x47,0x64,0x76,0x80,0x47,0x00,
0x02,0x90,0x47,0x64,0x76,0x80,0x47,0x00,
0x02,0x90,0x49,0x64,0x76,0x80,0x49,0x00,
0x02,0x90,0x4B,0x64,0x76,0x80,0x4B,0x00,
0x02,0x90,0x47,0x64,0x76,0x80,0x47,0x00,
0x02,0x90,0x42,0x64,0x76,0x80,0x42,0x00,
0x02,0x90,0x44,0x64,0x76,0x80,0x44,0x00,
0x02,0x90,0x42,0x64,0x76,0x80,0x42,0x00,
0x02,0x90,0x47,0x64,0x81,0x6E,0x80,0x47,
0x00,0x02,0x90,0x47,0x64,0x76,0x80,0x47,
0x00,0x02,0x90,0x46,0x64,0x76,0x80,0x46,
0x00,0x02,0x90,0x47,0x64,0x76,0x80,0x47,
0x00,0x02,0x90,0x42,0x64,0x76,0x80,0x42,
0x00,0x02,0x90,0x44,0x64,0x76,0x80,0x44,
0x00,0x02,0x90,0x47,0x64,0x76,0x80,0x47,
0x00,0x02,0x90,0x4C,0x64,0x76,0x80,0x4C,
0x00,0x02,0x90,0x4B,0x64,0x76,0x80,0x4B,
0x00,0x02,0x90,0x4C,0x64,0x76,0x80,0x4C,
0x00,0x02,0x90,0x4E,0x64,0x76,0x80,0x4E,
0x00,0x02,0x90,0x47,0x64,0x81,0x6E,0x80,
0x47,0x00,0x02,0x90,0x49,0x64,0x81,0x6E,
0x80,0x49,0x00,0x00,0xFF,0x2F,0x00
};

PROGMEM const prog_char sequence06[] = { // Poteto fryer
  0x4D,0x54,0x68,0x64,0x00,0x00,0x00,0x06,
  0x00,0x01,0x00,0x02,0x00,0x30,0x4D,0x54,
  0x72,0x6B,0x00,0x00,0x00,0x29,0x00,0xFF,
  0x51,0x03,0x07,0xA1,0x20,0x00,0xFF,0x58,
  0x04,0x04,0x02,0x18,0x08,0x00,0xFF,0x59,
  0x02,0xFE,0x00,0x00,0xFF,0x03,0x0C,0x50,
  0x6F,0x74,0x65,0x74,0x6F,0x20,0x66,0x72,
  0x79,0x65,0x72,0x00,0xFF,0x2F,0x00,0x4D,
  0x54,0x72,0x6B,0x00,0x00,0x00,0x74,0x00,
  0xFF,0x03,0x0C,0x4D,0x65,0x6C,0x6F,0x64,
  0x79,0x20,0x74,0x72,0x61,0x63,0x6B,0x00,
  0x90,0x4F,0x40,0x18,0x80,0x4F,0x40,0x00,
  0x90,0x4D,0x40,0x18,0x80,0x4D,0x40,0x00,
  0x90,0x4F,0x40,0x18,0x80,0x4F,0x40,0x18,
  0x90,0x4F,0x40,0x18,0x80,0x4F,0x40,0x00,
  0x90,0x4D,0x40,0x18,0x80,0x4D,0x40,0x00,
  0x90,0x4F,0x40,0x18,0x80,0x4F,0x40,0x18,
  0x90,0x4F,0x40,0x18,0x80,0x4F,0x40,0x00,
  0x90,0x4D,0x40,0x18,0x80,0x4D,0x40,0x00,
  0x90,0x4F,0x40,0x18,0x80,0x4F,0x40,0x18,
  0x90,0x4F,0x40,0x18,0x80,0x4F,0x40,0x00,
  0x90,0x4D,0x40,0x18,0x80,0x4D,0x40,0x00,
  0x90,0x4F,0x40,0x18,0x80,0x4F,0x40,0x18,
  0xFF,0x2F,0x00
};

PROGMEM const prog_char sequence07[] = { // Shaba-dooby Touch Henshin
  0x4D,0x54,0x68,0x64,0x00,0x00,0x00,0x06,
  0x00,0x01,0x00,0x02,0x00,0x30,0x4D,0x54,
  0x72,0x6B,0x00,0x00,0x00,0x1A,0x00,0xFF,
  0x51,0x03,0x07,0xA1,0x20,0x00,0xFF,0x58,
  0x04,0x04,0x02,0x18,0x08,0x00,0xFF,0x59,
  0x02,0x00,0x01,0x81,0x40,0xFF,0x2F,0x00,
  0x4D,0x54,0x72,0x6B,0x00,0x00,0x00,0x44,
  0x00,0x90,0x45,0x40,0x0C,0x80,0x45,0x40,
  0x00,0x90,0x45,0x40,0x0C,0x80,0x45,0x40,
  0x00,0x90,0x45,0x40,0x0C,0x80,0x45,0x40,
  0x00,0x90,0x45,0x40,0x0C,0x80,0x45,0x40,
  0x00,0x90,0x51,0x40,0x0C,0x80,0x51,0x40,
  0x0C,0x90,0x45,0x40,0x0C,0x80,0x45,0x40,
  0x00,0x90,0x43,0x40,0x24,0x80,0x43,0x40,
  0x00,0x90,0x45,0x40,0x3C,0x80,0x45,0x40,
  0x0C,0xFF,0x2F,0x00,
};