18069996051/arduino-libs
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

初始化提交

Browse Source
This commit is contained in:
王立帮
2024-07-20 22:09:06 +08:00
commit c247dd07a6
6876 changed files with 2743096 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

451
arduino-cli/libraries/Adafruit_Circuit_Playground/Adafruit_CircuitPlayground.cpp Normal file
View File

@@ -0,0 +1,451 @@
/*!
* @file Adafruit_CircuitPlayground.cpp
*
* @mainpage Adafruit CircuitPlayground Library
*
* @section intro_sec Introduction
*
* This is the documentation for Adafruit's CircuitPlayground driver for the
* Arduino platform. It is designed specifically to work with the
* Adafruit CircuitPlayground boards:
* - https://www.adafruit.com/products/3000
* - https://www.adafruit.com/products/3333
*
*
* Adafruit invests time and resources providing this open source code,
* please support Adafruit and open-source hardware by purchasing
* products from Adafruit!
*
*
* @section author Author
*
* Written by Ladyada and others for Adafruit Industries.
*
* @section license License
*
* BSD license, all text here must be included in any redistribution.
*
*/
#include <Adafruit_Circuit_Playground.h>
/**************************************************************************/
/*!
@brief Set up the CircuitPlayground hardware
@param brightness Optional brightness to set the neopixels to
@returns True if device is set up, false on any failure
*/
/**************************************************************************/
bool Adafruit_CircuitPlayground::begin(uint8_t brightness) {
pinMode(CPLAY_REDLED, OUTPUT);
pinMode(CPLAY_BUZZER, OUTPUT);
#if defined(__AVR__)
pinMode(CPLAY_CAPSENSE_SHARED, OUTPUT);
pinMode(CPLAY_LEFTBUTTON, INPUT);
pinMode(CPLAY_RIGHTBUTTON, INPUT);
pinMode(CPLAY_SLIDESWITCHPIN, INPUT);
#elif defined(ARDUINO_NRF52840_CIRCUITPLAY) // bluefruit
pinMode(CPLAY_LEFTBUTTON, INPUT_PULLDOWN);
pinMode(CPLAY_RIGHTBUTTON, INPUT_PULLDOWN);
pinMode(CPLAY_SLIDESWITCHPIN, INPUT_PULLUP);
pinMode(CPLAY_SPEAKER_SHUTDOWN, OUTPUT);
digitalWrite(CPLAY_SPEAKER_SHUTDOWN, HIGH);
#elif defined(__SAMD21G18A__) // Circuit Playground Express
pinMode(CPLAY_LEFTBUTTON, INPUT_PULLDOWN);
pinMode(CPLAY_RIGHTBUTTON, INPUT_PULLDOWN);
pinMode(CPLAY_SLIDESWITCHPIN, INPUT_PULLUP);
irReceiver = IRrecvPCI(CPLAY_IR_RECEIVER);
irDecoder = IRdecode();
// since we aren't calling speaker.begin() anymore, do this here
pinMode(CPLAY_SPEAKER_SHUTDOWN, OUTPUT);
digitalWrite(CPLAY_SPEAKER_SHUTDOWN, HIGH);
#endif
strip = Adafruit_CPlay_NeoPixel();
strip.updateType(NEO_GRB + NEO_KHZ800);
strip.updateLength(10);
strip.setPin(CPLAY_NEOPIXELPIN);
#ifdef __AVR__ // Circuit Playground 'classic'
lis = Adafruit_CPlay_LIS3DH(CPLAY_LIS3DH_CS, &SPI); // SPI
#elif defined(ARDUINO_NRF52840_CIRCUITPLAY)
lis = Adafruit_CPlay_LIS3DH(&Wire1); // i2c on wire1
#else // samd21
lis = Adafruit_CPlay_LIS3DH(&Wire1); // i2c on wire1
#endif
mic = Adafruit_CPlay_Mic();
strip.begin();
strip.show(); // Initialize all pixels to 'off'
strip.setBrightness(brightness);
#if defined(__AVR__) || defined(ARDUINO_NRF52840_CIRCUITPLAY) // bluefruit
cap[0] = CPlay_CapacitiveSensor(CPLAY_CAPSENSE_SHARED, 0);
cap[1] = CPlay_CapacitiveSensor(CPLAY_CAPSENSE_SHARED, 1);
cap[2] = CPlay_CapacitiveSensor(CPLAY_CAPSENSE_SHARED, 2);
cap[3] = CPlay_CapacitiveSensor(CPLAY_CAPSENSE_SHARED, 3);
cap[4] = CPlay_CapacitiveSensor(CPLAY_CAPSENSE_SHARED, 6);
cap[5] = CPlay_CapacitiveSensor(CPLAY_CAPSENSE_SHARED, 9);
cap[6] = CPlay_CapacitiveSensor(CPLAY_CAPSENSE_SHARED, 10);
cap[7] = CPlay_CapacitiveSensor(CPLAY_CAPSENSE_SHARED, 12);
#elif defined(__SAMD21G18A__) // Circuit Playground Express
for (int i = 0; i < 7; i++) {
cap[i] = Adafruit_CPlay_FreeTouch(A1 + i, OVERSAMPLE_4, RESISTOR_50K,
FREQ_MODE_NONE);
if (!cap[i].begin())
return false;
}
#endif
return lis.begin(CPLAY_LIS3DH_ADDRESS);
}
/**************************************************************************/
/*!
@brief read capacitive touch sensor
@param p the pin to read. Must be a captouch enabled pin.
@param samples Optional number of samples to take. Defaults to 10.
@returns measured captouch value
*/
/**************************************************************************/
uint16_t Adafruit_CircuitPlayground::readCap(uint8_t p, uint8_t samples) {
#if defined(__AVR__) || \
defined(ARDUINO_NRF52840_CIRCUITPLAY) // Circuit Playground Classic or
// bluefruit
switch (p) {
case 0:
return cap[0].capacitiveSensor(samples);
case 1:
return cap[1].capacitiveSensor(samples);
case 2:
return cap[2].capacitiveSensor(samples);
case 3:
return cap[3].capacitiveSensor(samples);
case 6:
return cap[4].capacitiveSensor(samples);
case 9:
return cap[5].capacitiveSensor(samples);
case 10:
return cap[6].capacitiveSensor(samples);
case 12:
return cap[7].capacitiveSensor(samples);
default:
return 0;
}
#elif defined(__SAMD21G18A__) // Circuit Playground Express
// analog pins r ez!
if ((p >= A1) && (p <= A7)) {
return cap[p - A1].measure();
}
// oof digital pins
switch (p) {
case 0:
return cap[A6 - A1].measure();
case 1:
return cap[A7 - A1].measure();
case 2:
return cap[A5 - A1].measure();
case 3:
return cap[A4 - A1].measure();
case 6:
return cap[A1 - A1].measure();
case 9:
return cap[A2 - A1].measure();
case 10:
return cap[A3 - A1].measure();
default:
return 0;
}
#endif
}
/**************************************************************************/
/*!
@brief turn on or off the red LED on pin #13
@param v pass true to turn LED on, false to turn LED off
*/
/**************************************************************************/
void Adafruit_CircuitPlayground::redLED(bool v) {
digitalWrite(CPLAY_REDLED, v);
}
/**************************************************************************/
/*!
@brief read the slide switch
@returns true if slide switch in set, false if not
*/
/**************************************************************************/
bool Adafruit_CircuitPlayground::slideSwitch(void) {
return digitalRead(CPLAY_SLIDESWITCHPIN);
}
/**************************************************************************/
/*!
@brief read the left button
@returns true if button is pressed, false if not
*/
/**************************************************************************/
bool Adafruit_CircuitPlayground::leftButton(void) {
return digitalRead(CPLAY_LEFTBUTTON);
}
/**************************************************************************/
/*!
@brief read the right button
@returns true if button is pressed, false if not
*/
/**************************************************************************/
bool Adafruit_CircuitPlayground::rightButton(void) {
return digitalRead(CPLAY_RIGHTBUTTON);
}
/**************************************************************************/
/*!
@brief play a tone on the onboard buzzer
@param freq the frequency to play
@param time the duration of the tone in milliseconds
@param wait Optional flag to wait for time milliseconds after playing the
tone. Defaults to true.
@note The driver circuitry is an on/off transistor driver, so you will only
be able to play square waves. It is also not the same loudness over all
frequencies but is designed to be the loudest at around 4 KHz
*/
/**************************************************************************/
void Adafruit_CircuitPlayground::playTone(uint16_t freq, uint16_t time,
bool wait) {
#ifdef __AVR__
#define F_PLL 48000000
if (!freq)
return;
uint32_t ocr;
uint16_t prescale = 1;
uint8_t scalebits = 0;
uint8_t hi1, lo1, hi2, lo2;
// Determine best prescaler setting for 10-bit timer
do {
scalebits++;
ocr = F_PLL / freq / prescale - 1;
prescale *= 2;
if (prescale >= 16384) {
ocr = 1023;
scalebits = 0b1111;
}
} while (ocr > 1023);
// Set up Timer4 for fast PWM on !OC4A
PLLFRQ = (PLLFRQ & 0xCF) | 0x30; // Route PLL to async clk
TCCR4A = _BV(COM4A0) | _BV(PWM4A); // Clear on match, PWMA on
TCCR4B = _BV(PWM4X) | scalebits; // PWM invert
TCCR4D = 0; // Fast PWM mode
TCCR4E = 0; // Not enhanced mode
DT4 = 0; // No dead time
hi1 = ocr >> 8;
lo1 = ocr & 0xFF;
hi2 = ocr >> 9;
lo2 = (ocr >> 1) & 0xFF;
noInterrupts(); // TC4H accesses MUST be atomic
TC4H = hi1;
OCR4C = lo1; // TOP
TC4H = hi2;
OCR4A = lo2; // 50% duty
interrupts();
pinMode(5, OUTPUT); // Enable output
delay(time);
pinMode(5, INPUT); // Disable output
TCCR4A = 0; // PWMA off
#else
tone(CPLAY_BUZZER, freq, time);
delay(time); // time argument to tone() isn't working, so...
#endif
if (wait)
delay(time);
}
/**************************************************************************/
/*!
@brief read the onboard lightsensor
@returns value between 0 and 1023 read from the light sensor
@note 1000 Lux will roughly read as 2 Volts (or about 680 as a raw analog
reading). A reading of about 300 is common for most indoor light levels. Note
that outdoor daylight is 10,000 Lux or even higher, so this sensor is best
suited for indoor light levels!
*/
/**************************************************************************/
uint16_t Adafruit_CircuitPlayground::lightSensor(void) {
return analogRead(CPLAY_LIGHTSENSOR);
}
/**************************************************************************/
/*!
@brief read the onboard sound sensor. A reading of ~0 is silent, and
loud audio will result in a reading between -500 and 500 or so.
@returns value of the sound sensor
*/
/**************************************************************************/
int16_t Adafruit_CircuitPlayground::soundSensor(void) {
int16_t x;
mic.capture(&x, 1);
return x;
}
/**************************************************************************/
/*!
@brief read the X parameter of the onboard accelerometer. Value returned is
defined by setAccelRange().
@returns X value of the accelerometer
*/
/**************************************************************************/
float Adafruit_CircuitPlayground::motionX(void) {
sensors_event_t event;
CircuitPlayground.lis.getEvent(&event);
return event.acceleration.x;
}
/**************************************************************************/
/*!
@brief read the Y parameter of the onboard accelerometer. Value returned is
defined by setAccelRange().
@returns Y value of the accelerometer
*/
/**************************************************************************/
float Adafruit_CircuitPlayground::motionY(void) {
sensors_event_t event;
CircuitPlayground.lis.getEvent(&event);
return event.acceleration.y;
}
/**************************************************************************/
/*!
@brief read the Z parameter of the onboard accelerometer. Value returned is
defined by setAccelRange().
@returns the Z value of the onboard accelerometer
*/
/**************************************************************************/
float Adafruit_CircuitPlayground::motionZ(void) {
sensors_event_t event;
CircuitPlayground.lis.getEvent(&event);
return event.acceleration.z;
}
/**************************************************************************/
/*!
@brief read the onboard thermistor.
@returns temperature reading in Centigrade.
*/
/**************************************************************************/
float Adafruit_CircuitPlayground::temperature(void) {
// Thermistor test
double reading;
reading = analogRead(CPLAY_THERMISTORPIN);
// Serial.print("Thermistor reading: "); Serial.println(reading);
// convert the value to resistance
reading = ((1023.0 * SERIESRESISTOR) / reading);
reading -= SERIESRESISTOR;
// Serial.print("Thermistor resistance: "); Serial.println(reading);
double steinhart;
steinhart = reading / THERMISTORNOMINAL; // (R/Ro)
steinhart = log(steinhart); // ln(R/Ro)
steinhart /= BCOEFFICIENT; // 1/B * ln(R/Ro)
steinhart += 1.0 / (TEMPERATURENOMINAL + 273.15); // + (1/To)
steinhart = 1.0 / steinhart; // Invert
steinhart -= 273.15; // convert to C
return steinhart;
}
/**************************************************************************/
/*!
@brief read the onboard thermistor.
@returns temperature reading in Farenheight.
*/
/**************************************************************************/
float Adafruit_CircuitPlayground::temperatureF(void) {
float tempF = CircuitPlayground.temperature() * 1.8 + 32;
return tempF;
}
/**************************************************************************/
/*!
@brief get a color value from the color wheel.
@param WheelPos a value 0 to 255
@returns a color value. The colours are a transition r - g - b - back to r.
*/
/**************************************************************************/
uint32_t Adafruit_CircuitPlayground::colorWheel(uint8_t WheelPos) {
WheelPos = 255 - WheelPos;
if (WheelPos < 85) {
return strip.Color(255 - WheelPos * 3, 0, WheelPos * 3);
}
if (WheelPos < 170) {
WheelPos -= 85;
return strip.Color(0, WheelPos * 3, 255 - WheelPos * 3);
}
WheelPos -= 170;
return strip.Color(WheelPos * 3, 255 - WheelPos * 3, 0);
}
/**************************************************************************/
/*!
@brief detect a color value from the light sensor
@param red the pointer to where the red component should be stored.
@param green the pointer to where the green component should be stored.
@param blue the pointer to where the blue component should be stored.
*/
/**************************************************************************/
void Adafruit_CircuitPlayground::senseColor(uint8_t &red, uint8_t &green,
uint8_t &blue) {
// Save the current pixel brightness so it can later be restored. Then bump
// the brightness to max to make sure the LED is as bright as possible for
// the color readings.
uint8_t old_brightness = strip.getBrightness();
strip.setBrightness(255);
// Set pixel 1 (next to the light sensor) to full red, green, blue
// color and grab a light sensor reading. Make sure to wait a bit
// after changing pixel colors to let the light sensor change
// resistance!
setPixelColor(1, 255, 0, 0); // Red
delay(LIGHT_SETTLE_MS);
uint16_t raw_red = lightSensor();
setPixelColor(1, 0, 255, 0); // Green
delay(LIGHT_SETTLE_MS);
uint16_t raw_green = lightSensor();
setPixelColor(1, 0, 0, 255); // Blue
delay(LIGHT_SETTLE_MS);
uint16_t raw_blue = lightSensor();
// Turn off the pixel and restore brightness, we're done with readings.
setPixelColor(1, 0);
strip.setBrightness(old_brightness);
// Now scale down each of the raw readings to be within
// 0 to 255. Remember each sensor reading is from the ADC
// which has 10 bits of resolution (0 to 1023), so dividing
// by 4 will change the range from 0-1023 to 0-255. Also
// use the min function to clamp the value to 255 at most (just
// to prevent overflow from 255.xx to 0).
red = min(255, raw_red / 4);
green = min(255, raw_green / 4);
blue = min(255, raw_blue / 4);
}
/**************************************************************************/
/*!
@brief check whether or not this device is a CircuitPlayground Express.
@returns True if the device is a CircuitPlayground Express, false if it is a
'classic'.
*/
/**************************************************************************/
bool Adafruit_CircuitPlayground::isExpress(void) {
#ifdef __AVR__
return false;
#else
return true;
#endif
}
// instantiate static
Adafruit_CircuitPlayground CircuitPlayground;

3
arduino-cli/libraries/Adafruit_Circuit_Playground/Adafruit_CircuitPlayground.h Normal file
View File

@@ -0,0 +1,3 @@
// this is a placeholder file. dont undo or delete this 'clever hack' :)
#include <Adafruit_Circuit_Playground.h>

266
arduino-cli/libraries/Adafruit_Circuit_Playground/Adafruit_Circuit_Playground.h Normal file
View File

@@ -0,0 +1,266 @@
/*!
* @file Adafruit_Circuit_Playground.h
*
* This is part of Adafruit's CircuitPlayground driver for the Arduino platform.
* It is designed specifically to work with the Adafruit CircuitPlayground
* boards.
*
* Adafruit invests time and resources providing this open source code,
* please support Adafruit and open-source hardware by purchasing
* products from Adafruit!
*
* Written by Ladyada and others for Adafruit Industries.
*
* BSD license, all text here must be included in any redistribution.
*
*/
#ifndef _ADAFRUIT_CIRCUITPLAYGROUND_H_
#define _ADAFRUIT_CIRCUITPLAYGROUND_H_
#include "utility/Adafruit_CPlay_LIS3DH.h"
#include "utility/Adafruit_CPlay_Mic.h"
#include "utility/Adafruit_CPlay_NeoPixel.h"
#include "utility/Adafruit_CPlay_Speaker.h"
#include "utility/CP_Firmata.h"
#include <Arduino.h>
#if defined(__AVR__) || \
defined(ARDUINO_NRF52840_CIRCUITPLAY) // Circuit Playground 'classic'
#include "utility/CPlay_CapacitiveSensor.h"
#else
#include "utility/Adafruit_CPlay_FreeTouch.h"
#include "utility/IRLibCPE.h"
#endif
#ifndef NOT_AN_INTERRUPT // Not defined in Arduino 1.0.5
#define NOT_AN_INTERRUPT -1 ///< Pin is not on an interrupt
#endif
#ifdef __AVR__ // Circuit Playground 'classic'
#define CPLAY_CAPSENSE_SHARED 30 ///< capacitive sense pin
#define CPLAY_REDLED 13 ///< red LED pin
#define CPLAY_NEOPIXELPIN 17 ///< neopixel pin
#define CPLAY_SLIDESWITCHPIN 21 ///< slide switch pin
#define CPLAY_LEFTBUTTON 4 ///< left button pin
#define CPLAY_RIGHTBUTTON 19 ///< right button pin
#define CPLAY_LIGHTSENSOR A5 ///< light sensor pin
#define CPLAY_THERMISTORPIN A0 ///< thermistor pin
#define CPLAY_SOUNDSENSOR A4 ///< sound sensor pin
#define CPLAY_BUZZER 5 ///< buzzer pin
#define CPLAY_LIS3DH_CS 8 ///< LIS3DH chip select pin
#define CPLAY_LIS3DH_INTERRUPT 7 ///< LIS3DH interrupt pin
#define CPLAY_LIS3DH_ADDRESS 0x18 ///< LIS3DH I2C address
#elif defined(ARDUINO_NRF52840_CIRCUITPLAY)
#include <math.h>
#define CPLAY_CAPSENSE_SHARED \
255 ///< we use ground instead of capacitive sense pin
#define CPLAY_LEFTBUTTON 4 ///< left button pin
#define CPLAY_RIGHTBUTTON 5 ///< right button pin
#define CPLAY_SLIDESWITCHPIN 7 ///< slide switch pin
#define CPLAY_NEOPIXELPIN 8 ///< neopixel pin
#define CPLAY_REDLED 13 ///< red led pin
#define CPLAY_BUZZER A0 ///< buzzer pin
#define CPLAY_LIGHTSENSOR A8 ///< light sensor pin
#define CPLAY_THERMISTORPIN A9 ///< thermistor pin
#define CPLAY_LIS3DH_CS -1 ///< LIS3DH chip select pin
#define CPLAY_LIS3DH_INTERRUPT 27 ///< LIS3DH interrupt pin
#define CPLAY_LIS3DH_ADDRESS 0x19 ///< LIS3DH I2C address
#else // Circuit Playground Express
#define CPLAY_LEFTBUTTON 4 ///< left button pin
#define CPLAY_RIGHTBUTTON 5 ///< right button pin
#define CPLAY_SLIDESWITCHPIN 7 ///< slide switch pin
#define CPLAY_NEOPIXELPIN 8 ///< neopixel pin
#define CPLAY_REDLED 13 ///< red led pin
#define CPLAY_IR_EMITTER 25 ///< IR emmitter pin
#define CPLAY_IR_RECEIVER 26 ///< IR receiver pin
#define CPLAY_BUZZER A0 ///< buzzer pin
#define CPLAY_LIGHTSENSOR A8 ///< light sensor pin
#define CPLAY_THERMISTORPIN A9 ///< thermistor pin
#define CPLAY_SOUNDSENSOR A4 ///< TBD I2S
#define CPLAY_LIS3DH_CS -1 ///< LIS3DH chip select pin
#define CPLAY_LIS3DH_INTERRUPT 27 ///< LIS3DH interrupt pin
#define CPLAY_LIS3DH_ADDRESS 0x19 ///< LIS3DH I2C address
#endif
#define SERIESRESISTOR 10000 ///< series resistor for thermistor
#define THERMISTORNOMINAL 10000 ///< resistance of thermistor at 25 degrees C
#define TEMPERATURENOMINAL \
25 ///< temp. for nominal resistance (almost always 25 C)
#define BCOEFFICIENT \
3380 ///< The beta coefficient of the thermistor (usually 3000-4000)
/*!
@brief Configuration to tune the color sensing logic:
Amount of time (in milliseconds) to wait between
changing the pixel color and reading the light
sensor.
*/
#define LIGHT_SETTLE_MS 100
/**************************************************************************/
/*!
@brief Class that stores state and functions for interacting with
CircuitPlayground hardware
*/
/**************************************************************************/
class Adafruit_CircuitPlayground {
public:
bool begin(uint8_t brightness = 20);
Adafruit_CPlay_NeoPixel strip; ///< the neopixel strip object
Adafruit_CPlay_LIS3DH lis; ///< the accelerometer object
Adafruit_CPlay_Mic mic; ///< the microphone object
Adafruit_CPlay_Speaker speaker; ///< the speaker object
#if defined(__AVR__) || \
defined(ARDUINO_NRF52840_CIRCUITPLAY) // Circuit Playground 'classic' or
// bluefruit
CPlay_CapacitiveSensor cap[8]; ///< the array of capacitive touch sensors
#else
Adafruit_CPlay_FreeTouch cap[7]; ///< the array of capacitive touch sensors
IRrecvPCI irReceiver; ///< the IR receiver object
IRdecode irDecoder; ///< the IR decoder object
IRsend irSend; ///< the IR send object
#endif
bool slideSwitch(void);
void redLED(bool v);
void playTone(uint16_t freq, uint16_t time, bool wait = true);
bool leftButton(void);
bool rightButton(void);
uint16_t lightSensor(void);
int16_t soundSensor(void);
float temperature(void);
float temperatureF(void);
uint16_t readCap(uint8_t p, uint8_t samples = 10);
// Accelerometer
float motionX(void);
float motionY(void);
float motionZ(void);
/**************************************************************************/
/*!
@brief set the range of the MEMS accelerometer.
@param range the range to set the accelerometer to. LIS3DH_RANGE_2_G
is the smallest (+-2G) but will give the greatest precision, while
LIS3DH_RANGE_8_G is the largest (+-8G) but with the lease precision.
LIS3DH_RANGE_4_G is in the middle.
*/
/**************************************************************************/
void setAccelRange(lis3dh_range_t range) { lis.setRange(range); }
/**************************************************************************/
/*!
@brief turn on tap detection. Tap detection can detect single taps or
'double taps' (like a double-click).
@param c If c is 1 you will only detect single taps, one at a time.
If c is 2, you will be able to detect both single taps and double
taps.
@param clickthresh the threshold over which to register a tap
*/
/**************************************************************************/
void setAccelTap(uint8_t c, uint8_t clickthresh) {
lis.setClick(c, clickthresh, 10, 20, 255);
}
/**************************************************************************/
/*!
@brief test whether or not a tap has been detected
@return 0 if no tap is detected, 1 if a single tap is detected, and 2 or 3
if double tap is detected.
*/
/**************************************************************************/
uint8_t getAccelTap(void) { return (lis.getClick() >> 8) & 0x3; }
/**************************************************************************/
/*!
@brief turn off all neopixels on the board
*/
/**************************************************************************/
void clearPixels(void) {
strip.clear();
strip.show();
}
/**************************************************************************/
/*!
@brief set the color of a neopixel on the board
@param p the pixel to set. Pixel 0 is above the pad labeled 'GND' right next
to the USB connector, while pixel 9 is above the pad labeled '3.3V' on the
other side of the USB connector.
@param c a 24bit color value to set the pixel to
*/
/**************************************************************************/
void setPixelColor(uint8_t p, uint32_t c) {
strip.setPixelColor(p, c);
strip.show();
}
/**************************************************************************/
/*!
@brief set the color of a neopixel on the board
@param p the pixel to set. Pixel 0 is above the pad labeled 'GND' right next
to the USB connector, while pixel 9 is above the pad labeled '3.3V' on the
other side of the USB connector.
@param r a 0 to 255 value corresponding to the red component of the desired
color.
@param g a 0 to 255 value corresponding to the green component of the
desired color.
@param b a 0 to 255 value corresponding to the blue component of the desired
color.
*/
/**************************************************************************/
void setPixelColor(uint8_t p, uint8_t r, uint8_t g, uint8_t b) {
strip.setPixelColor(p, r, g, b);
strip.show();
}
/*! @brief set the global brightness of all neopixels.
@param b a 0 to 255 value corresponding to the desired brightness. The
default brightness of all neopixels is 30. */
void setBrightness(uint16_t b) { strip.setBrightness(b); }
/*! @brief Get a sinusoidal value from a sine table
@param x a 0 to 255 value corresponding to an index to the sine table
@returns An 8-bit sinusoidal value back */
uint8_t sine8(uint8_t x) { return strip.sine8(x); }
/*! @brief Get a gamma-corrected value from a gamma table
@param x a 0 to 255 value corresponding to an index to the gamma table
@returns An 8-bit gamma-corrected value back */
uint8_t gamma8(uint8_t x) { return strip.gamma8(x); }
uint32_t colorWheel(uint8_t x);
// Basic RGB color sensing with the light sensor and nearby neopixel.
// Both functions do the same thing and just differ in how they return the
// result, either as explicit RGB bytes or a 24-bit RGB color value.
void senseColor(uint8_t &red, uint8_t &green, uint8_t &blue);
/**************************************************************************/
/*!
@brief detect a color using the onboard light sensor
@return a 24 bit color. The most significant byte is red, followed by green,
and the least significant byte is blue.
*/
/**************************************************************************/
uint32_t senseColor() {
// Use the individual color component color sense function and then
// recombine tbe components into a 24-bit color value.
uint8_t red, green, blue;
senseColor(red, green, blue);
return ((uint32_t)red << 16) | ((uint32_t)green << 8) | blue;
}
bool isExpress(void);
private:
};
extern Adafruit_CircuitPlayground
CircuitPlayground; ///< instantiated by default
#endif

13
arduino-cli/libraries/Adafruit_Circuit_Playground/CONTRIBUTING.md Normal file
View File

@@ -0,0 +1,13 @@
# Contribution Guidelines
This library is the culmination of the expertise of many members of the open source community who have dedicated their time and hard work. The best way to ask for help or propose a new idea is to [create a new issue](https://github.com/adafruit/Adafruit_CircuitPlayground/issues/new) while creating a Pull Request with your code changes allows you to share your own innovations with the rest of the community.
The following are some guidelines to observe when creating issues or PRs:
- Be friendly; it is important that we can all enjoy a safe space as we are all working on the same project and it is okay for people to have different ideas
- [Use code blocks](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet#code); it helps us help you when we can read your code! On that note also refrain from pasting more than 30 lines of code in a post, instead [create a gist](https://gist.github.com/) if you need to share large snippets
- Use reasonable titles; refrain from using overly long or capitalized titles as they are usually annoying and do little to encourage others to help :smile:
- Be detailed; refrain from mentioning code problems without sharing your source code and always give information regarding your board and version of the library

2492
arduino-cli/libraries/Adafruit_Circuit_Playground/Doxyfile Normal file
View File

File diff suppressed because it is too large Load Diff

131
arduino-cli/libraries/Adafruit_Circuit_Playground/README.md Normal file
View File

@@ -0,0 +1,131 @@
# Adafruit CircuitPlayground Library [![Build Status](https://github.com/adafruit/Adafruit_CircuitPlayground/workflows/Arduino%20Library%20CI/badge.svg)](https://github.com/adafruit/Adafruit_CircuitPlayground/actions)[![Documentation](https://github.com/adafruit/ci-arduino/blob/master/assets/doxygen_badge.svg)](http://adafruit.github.io/Adafruit_CircuitPlayground/html/index.html)
<img src="https://cdn-shop.adafruit.com/970x728/3333-01.jpg" height="300"/>
## Description
All in one library to control Adafruit's Circuit Playground board. Requires no other dependencies and exposes all Circuit Playground components in a simple to use class. Adafruit Circuit Playground Express is a high-level library that provides objects that represent CircuitPlayground hardware.
## Installation
### First Method
![image](https://user-images.githubusercontent.com/36513474/68966019-f1521f00-07fe-11ea-97b6-78b621e5e2e4.png)
1. In the Arduino IDE, navigate to Sketch > Include Library > Manage Libraries
1. Then the Library Manager will open and you will find a list of libraries that are already installed or ready for installation.
1. Then search for Circuit playground using the search bar.
1. Click on the text area and then select the specific version and install it.
### Second Method
1. Navigate to the [Releases page](https://github.com/adafruit/Adafruit_CircuitPlayground/releases).
1. Download the latest release.
1. Extract the zip file
1. In the Arduino IDE, navigate to Sketch > Include Library > Add .ZIP Library
## Features
- ### Complete Package
Everything that is needed to run Arduino code on Circuit Playground is wrapped up into a tidy library that integrates all the sensing and lighting.
- ### Self-contained
Requires no other dependencies and exposes all Circuit Playground components in a simple to use class.
- ### High-Level Library
This high-level library provides objects that represent CircuitPlayground hardware.
- ### Give back
The library is free; you don’t have to pay for anything. However, if you want to support the development, or just thank the author of the library by purchasing products from Adafruit!
Not only you’ll encourage the development of the library, but you’ll also learn how to best use the library and probably some C++ too
- ### MIT License
Adafruit playground library is open-source and uses one of the most permissive licenses so you can use it on any project.
- Commercial use
- Modification
- Distribution
- Private use
## Functions
- begin()
- readCap()
- redLED()
- slideSwitch()
- leftButton()
- rightButton()
- playTone()
- lightSensor()
- soundSensor()
- motionX()
- motionY()
- motionZ()
- temperature()
- temperatureF()
- colorWheel()
- sensorColor()
- isExpress()
## Examples
There are many examples implemented in this library. One of the examples is below. You can find other examples [here](https://github.com/adafruit/Adafruit_CircuitPlayground/tree/master/examples)
soundPressureLevel.ino
```C++
#include <Adafruit_CircuitPlayground.h>
void setup() {
CircuitPlayground.begin();
Serial.begin(115200);
}
void loop() {
Serial.println(CircuitPlayground.mic.soundPressureLevel(50));
}
```
## Contributing
If you want to contribute to this project:
- Report bugs and errors
- Ask for enhancements
- Create issues and pull requests
- Tell others about this library
- Contribute new protocols
Please read [CONTRIBUTING.md](https://github.com/adafruit/Adafruit_CircuitPlayground/blob/master/CONTRIBUTING.md) for details on our code of conduct, and the process for submitting pull requests to us.
## Credits
The author and maintainer of this library are Limor Fried/Ladyada and others for Adafruit Industries <info@adafruit.com>.
Based on previous work by:
- T. DiCola
- P. Y. Dragon
- deanm1278
- C. Nelson
- E. Saadia
- per1234
- driveblock
- C. Young
- D. Cogliano
This is a library for the Adafruit CircuitPlayground boards:
- [Circuit Playground Express](https://www.adafruit.com/products/3333)
- [Circuit Playground Classic](https://www.adafruit.com/product/3000)
Check out the links above for our tutorials and wiring diagrams.
Adafruit invests time and resources providing this open source code, please support Adafruit and open-source hardware by purchasing products from Adafruit!
## License
This library is licensed under [MIT license](https://opensource.org/licenses/MIT). All text above must be included in any redistribution.

1245
arduino-cli/libraries/Adafruit_Circuit_Playground/examples/CircuitPlaygroundFirmata/CircuitPlaygroundFirmata.ino Normal file
View File

File diff suppressed because it is too large Load Diff

1549
arduino-cli/libraries/Adafruit_Circuit_Playground/examples/CircuitPlaygroundFirmata_Express_CodeOrg/CircuitPlaygroundFirmata_Express_CodeOrg.ino Normal file
View File

File diff suppressed because it is too large Load Diff

56
arduino-cli/libraries/Adafruit_Circuit_Playground/examples/FidgetSpinner/FidgetSpinner.h Normal file
View File

@@ -0,0 +1,56 @@
// Fidget spinner logic.
// This class represents a fidget spinner that can be spun to a specified
// velocity and then over time will slow down and stop. The spinner keeps track
// of its continuous (floating point) position value within the range 0...<10
// so it can map to CircuitPlayground pixel positions easily.// Author: Tony DiCola
// License: MIT License (https://opensource.org/licenses/MIT)
// Usage:
// - Create an instance of the class (specifying a custom decay value between 0 and 1,
// the lower the decay the faster the spinner slows down).
// - Call spin to start the spinner moving at the specified velocity (in pixels/second).
// - Call getPosition periodically to get the current spinner position given an elapsed
// amount of seconds since the last getPosition call.
#ifndef FIDGETANIMATION_H
#define FIDGETANIMATION_H
class FidgetSpinner {
public:
FidgetSpinner(float decay=0.5):
_position(0.0), _velocity(0.0), _elapsedS(0.0), _decay(decay)
{}
void spin(float velocity) {
// Start the fidget spinner moving at the specified velocity (in pixels/second).
// Over time the spinner will slow down based on its decay value.
_velocity = velocity;
_elapsedS = 0.0; // Reset elapsed time to start the decay from the beginning.
}
float getPosition(float deltaS) {
// Get the fidget spinner's current position after moving for the specified number
// of milliseconds. Returns a continuous value in the range 0...<10.
_elapsedS += deltaS;
// Compute current velocity based on exponential decay of initial
// velocity over the elapsed time (this causes the spinner to
// gradually slow down and mimics the effects of friction).
float currentVelocity = _velocity*pow(_decay, _elapsedS);
// Now move the position based on the current velocity.
_position += currentVelocity*deltaS;
// Finally make sure position is constrained within 0...<10 range.
_position = fmod(_position, 10.0);
if (_position < 0.0) {
// Ensure position is never negative by wrapping back to the
// same pixel position in a positive location.
_position += 10.0;
}
return _position;
}
private:
float _position;
float _velocity;
float _elapsedS;
float _decay;
};
#endif

269
arduino-cli/libraries/Adafruit_Circuit_Playground/examples/FidgetSpinner/FidgetSpinner.ino Normal file
View File

@@ -0,0 +1,269 @@
// Circuit Playground Digital Fidget Spinner
// -----------------------------------------
// Uses the Circuit Playground accelerometer to detect when the board
// is flicked from one side or the other and animates the pixels spinning
// around accordingly (with decay in speed to simulate friction).
// Press one button to cycle through different color combinations,
// and another button to cycle through 4 different types of animations
// (single dot, dual dot, single sine wave, dual sine wave).
// See the FidgetSpinner.h and PeakDetector.h files as tabs at the top
// for more of the sketch code!
// Author: Tony DiCola
// License: MIT License (https://opensource.org/licenses/MIT)
#include <Adafruit_CircuitPlayground.h>
#include "FidgetSpinner.h"
#include "PeakDetector.h"
// Configure which accelerometer axis to check:
// This should be one of the following values (uncomment only ONE):
//#define AXIS CircuitPlayground.motionX() // X axis, good for Circuit Playground express (SAMD21).
#define AXIS CircuitPlayground.motionY() // Y axis, good for Circuit Playground classic (32u4).
//#define AXIS CircuitPlayground.motionZ() // Z axis, wacky--try it!
// Configure how the axis direction compares to pixel movement direction:
#define INVERT_AXIS true // Set to true or 1 to invert the axis direction vs.
// pixel movement direction, or false/0 to disable.
// If the pixels spin in the opposite direction of your
// flick all the time then try changing this value.
// Configure pixel brightness.
// Set this to a value from 0 to 255 (minimum to maximum brightness).
#define BRIGHTNESS 255
// Configure peak detector behavior:
#define LAG 30 // Lag, how large is the buffer of filtered samples.
// Must be an integer value!
#define THRESHOLD 20.0 // Number of standard deviations above average a
// value needs to be to be considered a peak.
#define INFLUENCE 0.1 // Scale down peak values to this percent influence
// when storing them back in the filtered values.
// Should be a value from 0 to 1.0 where smaller
// values mean peaks have less influence.
// Configure spinner decay, i.e. how much it slows down. This should
// be a value from 0 to 1 where smaller values cause the spinner to
// slow down faster.
#define DECAY 0.66
// Debounce times for peak detection and button presses.
// You probably don't need to change these.
#define PEAK_DEBOUNCE_MS 500
#define BUTTON_DEBOUNCE_MS 20
// Define combinations of colors. Each combo has a primary and secondary color
// that are defined as 24-bit RGB values (like HTML colors, set them using hex
// values). First define a struct to specify the types colors. Then define
// the list of color combos. If you want to change color combos (like add or
// remove them, skip down to the colors[] array below and change it.
typedef struct {
uint32_t primary;
uint32_t secondary;
} colorCombo;
// Add or remove color combos here:
colorCombo colors[] = {
// Each color combo has the following form:
// { .primary = 24-bit RGB color (use hex), .secondary = 24-bit RGB color },
// Make sure each combo ends in a comma EXCEPT for the last one!
{ .primary = 0xFF0000, .secondary = 0x000000 }, // Red to black
{ .primary = 0x00FF00, .secondary = 0x000000 }, // Green to black
{ .primary = 0x0000FF, .secondary = 0x000000 }, // Blue to black
{ .primary = 0xFF0000, .secondary = 0x00FF00 }, // Red to green
{ .primary = 0xFF0000, .secondary = 0x0000FF }, // Red to blue
{ .primary = 0x00FF00, .secondary = 0x0000FF } // Green to blue
};
// Uncomment this to output a stream of debug information
// from the accelerometer and peak detector. Use the serial
// plotter to view the graph of these 4 values:
// - Accelerometer y axis value (in m/s^2)
// - Peak detector filtered y axis average
// - Peak detector filtered y axis standard deviation
// - Peak detector result, 0=no peak 1=positive peak, -1=negative peak
#define DEBUG
// Global state used by the sketch (you don't need to change this):
PeakDetector peakDetector(LAG, THRESHOLD, INFLUENCE);
FidgetSpinner fidgetSpinner(DECAY);
uint32_t lastMS = millis();
uint32_t peakDebounce = 0;
uint32_t buttonDebounce = 0;
bool lastButton1;
bool lastButton2;
int currentAnimation = 0;
int currentColor = 0;
void setup() {
// Initialize serial output for debugging and plotting.
Serial.begin(115200);
// Initialize Circuit Playground library and set accelerometer
// to its widest +/-16G range.
CircuitPlayground.begin(BRIGHTNESS);
CircuitPlayground.setAccelRange(LIS3DH_RANGE_16_G);
// Initialize starting button state.
lastButton1 = CircuitPlayground.leftButton();
lastButton2 = CircuitPlayground.rightButton();
}
void loop() {
// Update time since last loop call.
uint32_t currentMS = millis();
uint32_t deltaMS = currentMS - lastMS; // Time in milliseconds.
float deltaS = deltaMS / 1000.0; // Time in seconds.
lastMS = currentMS;
// Grab the current accelerometer axis value and look for a sudden peak.
float accel = AXIS;
int result = peakDetector.detect(accel);
// If in debug mode, print out the current acceleration and peak detector
// state (average, standard deviation, and peak result). Use the serial
// plotter to view this over time.
#ifdef DEBUG
Serial.print(accel);
Serial.print(",");
Serial.print(peakDetector.getAvg());
Serial.print(",");
Serial.print(peakDetector.getStd());
Serial.print(",");
Serial.println(result);
#endif
// If there was a peak and enough time has elapsed since the last peak
// (i.e. to 'debounce' the noisey peak signal a bit) then start the spinner
// moving at a velocity proportional to the accelerometer value.
if ((result != 0) && (currentMS >= peakDebounce)) {
peakDebounce = currentMS + PEAK_DEBOUNCE_MS;
// Invert accel because accelerometer axis positive/negative is flipped
// with respect to pixel positive/negative movement.
if (INVERT_AXIS) {
fidgetSpinner.spin(-accel);
}
else {
fidgetSpinner.spin(accel);
}
}
// Check if enough time has passed to test for button releases.
if (currentMS >= buttonDebounce) {
buttonDebounce = currentMS + BUTTON_DEBOUNCE_MS;
// Check if any button was released. I.e. the last known button
// state was pressed (true) and the current state is released (false).
bool button1 = CircuitPlayground.leftButton();
bool button2 = CircuitPlayground.rightButton();
if (!button1 && lastButton1) {
// Button 1 released!
// Change to the next animation (looping back to start after 3 since
// there are 4 total animations).
currentAnimation = (currentAnimation + 1) % 4;
}
if (!button2 && lastButton2) {
// Button 2 released!
// Change to the next color index.
currentColor = (currentColor + 1) % (sizeof(colors)/sizeof(colorCombo));
}
lastButton1 = button1;
lastButton2 = button2;
}
// Update the spinner position and draw the current animation frame.
float pos = fidgetSpinner.getPosition(deltaS);
switch (currentAnimation) {
case 0:
// Single dot.
animateDots(pos, 1);
break;
case 1:
// Two opposite dots.
animateDots(pos, 2);
break;
case 2:
// Sine wave with one peak.
animateSine(pos, 1.0);
break;
case 3:
// Sine wave with two peaks.
animateSine(pos, 2.0);
break;
}
}
// Helper functions:
void fillPixels(const uint32_t color) {
// Set all the pixels on CircuitPlayground to the specified color.
for (int i=0; i<CircuitPlayground.strip.numPixels();++i) {
CircuitPlayground.strip.setPixelColor(i, color);
}
}
float constrainPosition(const float pos) {
// Take a continuous positive or negative value and map it to its relative positon
// within the range 0...<10 (so it's valid as an index to CircuitPlayground pixel
// position).
float result = fmod(pos, CircuitPlayground.strip.numPixels());
if (result < 0.0) {
result += CircuitPlayground.strip.numPixels();
}
return result;
}
float lerp(const float x, const float x0, const float x1, const float y0, const float y1) {
// Linear interpolation of value y within y0...y1 given x and range x0...x1.
return y0 + (x-x0)*((y1-y0)/(x1-x0));
}
uint32_t primaryColor() {
return colors[currentColor].primary;
}
uint32_t secondaryColor() {
return colors[currentColor].secondary;
}
uint32_t colorLerp(const float x, const float x0, const float x1, const uint32_t c0, const uint32_t c1) {
// Perform linear interpolation of 24-bit RGB color values.
// Will return a color within the range of c0...c1 proportional to the value x within x0...x1.
uint8_t r0 = (c0 >> 16) & 0xFF;
uint8_t g0 = (c0 >> 8) & 0xFF;
uint8_t b0 = c0 & 0xFF;
uint8_t r1 = (c1 >> 16) & 0xFF;
uint8_t g1 = (c1 >> 8) & 0xFF;
uint8_t b1 = c1 & 0xFF;
uint32_t r = int(lerp(x, x0, x1, r0, r1));
uint32_t g = int(lerp(x, x0, x1, g0, g1));
uint32_t b = int(lerp(x, x0, x1, b0, b1));
return (r << 16) | (g << 8) | b;
}
// Animation functions:
void animateDots(float pos, int count) {
// Simple discrete dot animation. Spins dots around the board based on the specified
// spinner position. Count specifies how many dots to display, each one equally spaced
// around the pixels (in practice any count that 10 isn't evenly divisible by will look odd).
// Count should be from 1 to 10 (inclusive)!
fillPixels(secondaryColor());
// Compute each dot's position and turn on the appropriate pixel.
for (int i=0; i<count; ++i) {
float dotPos = constrainPosition(pos + i*(float(CircuitPlayground.strip.numPixels())/float(count)));
CircuitPlayground.strip.setPixelColor(int(dotPos), primaryColor());
}
CircuitPlayground.strip.show();
}
void animateSine(float pos, float frequency) {
// Smooth sine wave animation. Sweeps a sine wave of primary to secondary color around
// the board pixels based on the specified spinner position.
// Compute phase based on spinner position. As the spinner position changes the phase will
// move the sine wave around the pixels.
float phase = 2.0*PI*(constrainPosition(pos)/10.0);
for (int i=0; i<CircuitPlayground.strip.numPixels();++i) {
// Use a sine wave to compute the value of each pixel based on its position for time
// (and offset by the global phase that depends on fidget spinner position).
float x = sin(2.0*PI*frequency*(i/10.0)+phase);
CircuitPlayground.strip.setPixelColor(i, colorLerp(x, -1.0, 1.0, primaryColor(), secondaryColor()));
}
CircuitPlayground.strip.show();
}

122
arduino-cli/libraries/Adafruit_Circuit_Playground/examples/FidgetSpinner/PeakDetector.h Normal file
View File

@@ -0,0 +1,122 @@
// Signal peak detector using smoothed z-score algorithm.
// Detects when a continuous signal has a significant peak in values. Based on
// algorithm from the answer here:
// https://stackoverflow.com/questions/22583391/peak-signal-detection-in-realtime-timeseries-data/22640362#22640362
// Author: Tony DiCola
// License: MIT License (https://opensource.org/licenses/MIT)
// Usage:
// - Create an instance of the PeakDetector class and configure its lag, threshold,
// and influence. These likely need to be adjust to fit your dataset. See the
// Stack Overflow question above for more details on their meaning.
// - Continually call detect and feed it a new sample value. Detect will return 0
// if no peak was detected, 1 if a positive peak was detected and -1 if a negative
// peak was detected.
#ifndef PEAKDETECTOR_H
#define PEAKDETECTOR_H
class PeakDetector {
public:
PeakDetector(const int lag=5, const float threshold=3.5, const float influence=0.5):
_lag(lag), _threshold(threshold), _influence(influence), _avg(0.0), _std(0.0), _primed(false), _index(0)
{
// Allocate memory for last samples (used during averaging) and set them all to zero.
_filtered = new float[lag];
for (int i=0; i<lag; ++i) {
_filtered[i] = 0.0;
}
}
~PeakDetector() {
// Deallocate memory for samples.
if (_filtered != NULL) {
delete[] _filtered;
}
}
int detect(float sample) {
// Detect if the provided sample is a positive or negative peak.
// Will return 0 if no peak detected, 1 if a positive peak and -1
// if a negative peak.
int result = 0;
// Fill up filtered samples if not yet primed with enough available samples.
if (_primed && (abs(sample-_avg) > (_threshold*_std))) {
// Detected a peak!
// Determine type of peak, positive or negative.
if (sample > _avg) {
result = 1;
}
else {
result = -1;
}
// Save this sample but scaled down based on influence.
_filtered[_index] = (_influence*sample) + ((1.0-_influence)*_filtered[_previousIndex()]);
}
else {
// Did not detect a peak, or not yet primed with enough samples.
// Just record this sample and move on.
_filtered[_index] = sample;
}
// Increment index of next filtered sample.
_incrementIndex();
// When primed update the average and standard deviation of the most recent
// filtered values.
if (_primed) {
// Compute mean of filtered values.
_avg = 0.0;
for (int i=0; i<_lag; ++i) {
_avg += _filtered[i];
}
_avg = _avg/float(_lag);
// Compute standard deviation of filtered values.
_std = 0.0;
for (int i=0; i<_lag; ++i) {
_std += pow(_filtered[i]-_avg, 2.0);
}
_std = sqrt(_std/float(_lag));
}
return result;
}
float getAvg() {
// Return the current signal average, useful for debugging.
return _avg;
}
float getStd() {
// Return the current signal standard deviation, useful for debugging.
return _std;
}
private:
float _lag;
float _threshold;
float _influence;
float* _filtered;
float _avg;
float _std;
bool _primed;
int _index;
void _incrementIndex() {
// Increment the index of the current sample.
_index += 1;
if (_index >= _lag) {
// Loop back to start of sample buffer when full, but be sure to note
// when this happens to indicate we are primed with enough samples.
_index = 0;
_primed = true;
}
}
int _previousIndex() {
// Find the index of the last sample.
int result = _index-1;
if (result < 0) {
result = _lag-1;
}
return result;
}
};
#endif

23
arduino-cli/libraries/Adafruit_Circuit_Playground/examples/Hello_CircuitPlayground/Hello_Accelerometer/Hello_Accelerometer.ino Normal file
View File

@@ -0,0 +1,23 @@
#include <Adafruit_CircuitPlayground.h>
float X, Y, Z;
void setup() {
Serial.begin(9600);
CircuitPlayground.begin();
}
void loop() {
X = CircuitPlayground.motionX();
Y = CircuitPlayground.motionY();
Z = CircuitPlayground.motionZ();
Serial.print("X: ");
Serial.print(X);
Serial.print(" Y: ");
Serial.print(Y);
Serial.print(" Z: ");
Serial.println(Z);
delay(1000);
}

12
arduino-cli/libraries/Adafruit_Circuit_Playground/examples/Hello_CircuitPlayground/Hello_Blink/Hello_Blink.ino Normal file
View File

@@ -0,0 +1,12 @@
#include <Adafruit_CircuitPlayground.h>
void setup() {
CircuitPlayground.begin();
}
void loop() {
CircuitPlayground.redLED(HIGH);
delay(500);
CircuitPlayground.redLED(LOW);
delay(500);
}

30
arduino-cli/libraries/Adafruit_Circuit_Playground/examples/Hello_CircuitPlayground/Hello_Buttons/Hello_Buttons.ino Normal file
View File

@@ -0,0 +1,30 @@
#include <Adafruit_CircuitPlayground.h>
bool leftButtonPressed;
bool rightButtonPressed;
void setup() {
Serial.begin(9600);
CircuitPlayground.begin();
}
void loop() {
leftButtonPressed = CircuitPlayground.leftButton();
rightButtonPressed = CircuitPlayground.rightButton();
Serial.print("Left Button: ");
if (leftButtonPressed) {
Serial.print("DOWN");
} else {
Serial.print(" UP");
}
Serial.print(" Right Button: ");
if (rightButtonPressed) {
Serial.print("DOWN");
} else {
Serial.print(" UP");
}
Serial.println();
delay(1000);
}

17
arduino-cli/libraries/Adafruit_Circuit_Playground/examples/Hello_CircuitPlayground/Hello_LightSensor/Hello_LightSensor.ino Normal file
View File

@@ -0,0 +1,17 @@
#include <Adafruit_CircuitPlayground.h>
int value;
void setup() {
Serial.begin(9600);
CircuitPlayground.begin();
}
void loop() {
value = CircuitPlayground.lightSensor();
Serial.print("Light Sensor: ");
Serial.println(value);
delay(1000);
}

25
arduino-cli/libraries/Adafruit_Circuit_Playground/examples/Hello_CircuitPlayground/Hello_NeoPixels/Hello_NeoPixels.ino Normal file
View File

@@ -0,0 +1,25 @@
#include <Adafruit_CircuitPlayground.h>
void setup() {
CircuitPlayground.begin();
}
void loop() {
CircuitPlayground.clearPixels();
delay(500);
CircuitPlayground.setPixelColor(0, 255, 0, 0);
CircuitPlayground.setPixelColor(1, 128, 128, 0);
CircuitPlayground.setPixelColor(2, 0, 255, 0);
CircuitPlayground.setPixelColor(3, 0, 128, 128);
CircuitPlayground.setPixelColor(4, 0, 0, 255);
CircuitPlayground.setPixelColor(5, 0xFF0000);
CircuitPlayground.setPixelColor(6, 0x808000);
CircuitPlayground.setPixelColor(7, 0x00FF00);
CircuitPlayground.setPixelColor(8, 0x008080);
CircuitPlayground.setPixelColor(9, 0x0000FF);
delay(5000);
}

22
arduino-cli/libraries/Adafruit_Circuit_Playground/examples/Hello_CircuitPlayground/Hello_SlideSwitch/Hello_SlideSwitch.ino Normal file
View File

@@ -0,0 +1,22 @@
#include <Adafruit_CircuitPlayground.h>
bool slideSwitch;
void setup() {
Serial.begin(9600);
CircuitPlayground.begin();
}
void loop() {
slideSwitch = CircuitPlayground.slideSwitch();
Serial.print("Slide Switch: ");
if (slideSwitch) {
Serial.print("+");
} else {
Serial.print("-");
}
Serial.println();
delay(1000);
}

18
arduino-cli/libraries/Adafruit_Circuit_Playground/examples/Hello_CircuitPlayground/Hello_SoundSensor/Hello_SoundSensor.ino Normal file
View File

@@ -0,0 +1,18 @@
#include <Adafruit_CircuitPlayground.h>
float value;
void setup() {
Serial.begin(9600);
CircuitPlayground.begin();
}
void loop() {
// Take 10 milliseconds of sound data to calculate
value = CircuitPlayground.mic.soundPressureLevel(10);
Serial.print("Sound Sensor SPL: ");
Serial.println(value);
delay(90);
}

10
arduino-cli/libraries/Adafruit_Circuit_Playground/examples/Hello_CircuitPlayground/Hello_Speaker/Hello_Speaker.ino Normal file
View File

@@ -0,0 +1,10 @@
#include <Adafruit_CircuitPlayground.h>
void setup() {
CircuitPlayground.begin();
}
void loop() {
CircuitPlayground.playTone(500, 100);
delay(1000);
}

20
arduino-cli/libraries/Adafruit_Circuit_Playground/examples/Hello_CircuitPlayground/Hello_Temperature/Hello_Temperature.ino Normal file
View File

@@ -0,0 +1,20 @@
#include <Adafruit_CircuitPlayground.h>
float tempC, tempF;
void setup() {
Serial.begin(9600);
CircuitPlayground.begin();
}
void loop() {
tempC = CircuitPlayground.temperature();
tempF = CircuitPlayground.temperatureF();
Serial.print("tempC: ");
Serial.print(tempC);
Serial.print(" tempF: ");
Serial.println(tempF);
delay(1000);
}

84
arduino-cli/libraries/Adafruit_Circuit_Playground/examples/Hello_CircuitPlayground/README.md Normal file
View File

@@ -0,0 +1,84 @@
# Hello Circuit Playground
A set of very basic example sketches to demonstrate the various components
of the [Circuit Playground](https://www.adafruit.com/products/3000).
These sketches were tested and verified with:
* Circuit Playground Developer Edition
* Ubuntu 16.04 LTS
* Arduino IDE 1.6.11
* Adafruit AVR Boards 1.4.9
* Adafruit Circuit Playground Library 1.6.1
## Hello_Blink
Blinks the little red LED next to the micro USB connector once per second.
## Hello_SlideSwitch
The position (+ or -) of the slide switch is sent to the serial monitor once
per second.
```
Slide Switch: -
Slide Switch: +
Slide Switch: +
```
## Hello_Buttons
The position (UP or DOWN) of the two push buttons are sent to the serial
monitor once per second.
```
Left Button: UP Right Button: UP
Left Button: DOWN Right Button: UP
Left Button: UP Right Button: UP
Left Button: UP Right Button: DOWN
```
## Hello_LightSensor
The reading (0-1023) from the light sensor is sent to the serial monitor once
per second.
```
Light Sensor: 962
Light Sensor: 954
Light Sensor: 275
Light Sensor: 192
Light Sensor: 688
```
## Hello_Temperature
The temperature is sent to the serial monitor once per second.
```
tempC: 28.25 tempF: 83.02
tempC: 29.71 tempF: 85.64
tempC: 30.72 tempF: 87.30
tempC: 31.85 tempF: 89.32
```
## Hello_Accelerometer
The readings (in m/s<sup>2</sup>) from the 3 axes of the accelerometer are sent
to the serial monitor once per second. (1G ~= 9.8 m/s<sup>2</sup>)
```
X: -0.33 Y: 2.41 Z: 9.40
X: -1.25 Y: 4.20 Z: 1.86
X: -7.95 Y: -3.50 Z: -2.47
X: 0.11 Y: -8.38 Z: 2.25
X: -2.28 Y: 2.73 Z: 9.10
```
## Hello_SoundSensor
The reading (0-1023) from the sound sensor (microphone) is sent to the serial
monitor once per second.
```
Sound Sensor: 339
Sound Sensor: 339
Sound Sensor: 1023
Sound Sensor: 10
Sound Sensor: 15
Sound Sensor: 1023
Sound Sensor: 336
```
## Hello_Speaker
Plays a 500Hz tone for 0.1 seconds on the speaker, followed by 1 second of
silence.
## Hello_NeoPixels
Clears all pixels for 0.5 seconds then displays colors on the fist 5 pixels
using individual 8-bit values and the same colors on the next 5 pixels using
24-bit values. After 5 seconds, this repeats.

163
arduino-cli/libraries/Adafruit_Circuit_Playground/examples/Infrared_Demos/Infrared_NeoPixel/Infrared_NeoPixel.ino Normal file
View File

@@ -0,0 +1,163 @@
/* Infrared_NeoPixel.ino Example sketch for IRLib2 and Circuit Playground Express
Illustrates how to change NeoPixel patterns and colors using
an IR remote. Programmed to use IR codes for Adafruit mini remote
https://www.adafruit.com/product/389
Press the following keys on the remote:
vol- decrease brightness
vol+ increase brightness
right arrow rotate clockwise
left arrow rotate counterclockwise
up arrow rotate faster
down arrow rotate slower
0 rainbow pattern
1 candy cane pattern
2 one red pixel
3 decreased solid colors
4 increase solid colors
*/
#include <Adafruit_CircuitPlayground.h>
#include "adafruit_mini_codes.h"
#if !defined(ARDUINO_SAMD_CIRCUITPLAYGROUND_EXPRESS)
#error "Infrared support is only for the Circuit Playground Express, it doesn't work with the Classic version"
#endif
//Pattern numbers
#define RAINBOW 0
#define CANDY_CANE 1
#define JUST_ONE 2
#define MONOCHROME 3
uint8_t i,j,Phase, Pattern;
int8_t Direction, Mono;
int16_t Bright, Speed;
void Show_Pattern(void) {
CircuitPlayground.setBrightness(Bright);
for(i=0;i<11;i++) {
j= (20+i+Phase*Direction) % 10;
switch (Pattern) {
case RAINBOW:
CircuitPlayground.setPixelColor(j, CircuitPlayground.colorWheel(25*i));
break;
case CANDY_CANE:
if((i % 5)<2) {
CircuitPlayground.setPixelColor(j, 255,0,0);
} else {
CircuitPlayground.setPixelColor(j, 255,255,255);
}
break;
case JUST_ONE:
if(i<2) {
CircuitPlayground.setPixelColor(j, 255,0,0);
} else {
CircuitPlayground.setPixelColor(j, 0,0,0);
}
break;
case MONOCHROME:
CircuitPlayground.setPixelColor(i, CircuitPlayground.colorWheel(25*Mono));
break;
}
}
}
void setup() {
CircuitPlayground.begin();
Serial.begin(9600);
CircuitPlayground.irReceiver.enableIRIn(); // Start the receiver
Bright=8; Phase=0; Pattern=2; Direction=1; Speed=300;
Mono=0;
}
void loop() {
// First up, display whatever neopixel patterm we're doing
Show_Pattern();
// a small pause
delay(Speed);
// go to next phase next time
Phase++;
if (Phase >= 10) {
Phase = 0;
}
// Did we get any infrared signals?
if (! CircuitPlayground.irReceiver.getResults()) {
return;
}
// Did we get any decodable messages?
if (! CircuitPlayground.irDecoder.decode()) {
CircuitPlayground.irReceiver.enableIRIn(); // Restart receiver
return;
}
// We can print out the message if we want...
CircuitPlayground.irDecoder.dumpResults(false);
// Did we get any NEC remote messages?
if (! CircuitPlayground.irDecoder.protocolNum == NEC) {
CircuitPlayground.irReceiver.enableIRIn(); // Restart receiver
return;
}
// What message did we get?
switch(CircuitPlayground.irDecoder.value) {
case ADAF_MINI_0_10_PLUS:
Serial.println("Rainbow mode!");
Pattern = RAINBOW;
break;
case ADAF_MINI_1:
Serial.println("Candy Cane mode!");
Pattern = CANDY_CANE;
break;
case ADAF_MINI_2:
Serial.println("Just One mode!");
Pattern = JUST_ONE;
break;
case ADAF_MINI_3:
Serial.println("Monochrome mode, less");
Pattern = MONOCHROME;
Mono--;
if (Mono < 0) {
Mono = 9;
}
break;
case ADAF_MINI_4:
Serial.println("Monochrome mode, more");
Pattern = MONOCHROME;
Mono++;
if (Mono > 9) {
Mono = 0;
}
break;
case ADAF_MINI_LEFT_ARROW:
Serial.println("Counter-Clockwise");
Direction = 1;
break;
case ADAF_MINI_RIGHT_ARROW:
Serial.println("Clockwise");
Direction = -1;
break;
case ADAF_MINI_VOLUME_UP:
Serial.println("Brighter");
Bright = min(255, Bright+2);
break;
case ADAF_MINI_VOLUME_DOWN:
Serial.println("Dimmer");
Bright = max(0, Bright-2);
break;
case ADAF_MINI_UP_ARROW:
Serial.println("Faster");
Speed = max(50, Speed-50);
break;
case ADAF_MINI_DOWN_ARROW:
Serial.println("Slower");
Speed = min(2000, Speed+50);
break;
}
//Restart receiver
CircuitPlayground.irReceiver.enableIRIn();
}

28
arduino-cli/libraries/Adafruit_Circuit_Playground/examples/Infrared_Demos/Infrared_NeoPixel/adafruit_mini_codes.h Normal file
View File

@@ -0,0 +1,28 @@
/*
IR codes for Adafruit mini remote
https://www.adafruit.com/product/389
Uses NEC protocol
*/
#define ADAF_MINI_VOLUME_DOWN 0xfd00ff
#define ADAF_MINI_PLAY_PAUSE 0xfd807f
#define ADAF_MINI_VOLUME_UP 0xfd40bf
#define ADAF_MINI_SETUP 0xfd20df
#define ADAF_MINI_UP_ARROW 0xfda05f
#define ADAF_MINI_STOP_MODE 0xfd609f
#define ADAF_MINI_LEFT_ARROW 0xfd10ef
#define ADAF_MINI_ENTER_SAVE 0xfd906f
#define ADAF_MINI_RIGHT_ARROW 0xfd50af
#define ADAF_MINI_0_10_PLUS 0xfd30cf
#define ADAF_MINI_DOWN_ARROW 0xfdb04f
#define ADAF_MINI_REPEAT 0xfd708f
#define ADAF_MINI_1 0xfd08f7
#define ADAF_MINI_2 0xfd8877
#define ADAF_MINI_3 0xfd48b7
#define ADAF_MINI_4 0xfd28d7
#define ADAF_MINI_5 0xfda857
#define ADAF_MINI_6 0xfd6897
#define ADAF_MINI_7 0xfd18e7
#define ADAF_MINI_8 0xfd9867
#define ADAF_MINI_9 0xfd58a7

29
arduino-cli/libraries/Adafruit_Circuit_Playground/examples/Infrared_Demos/Infrared_Read/Infrared_Read.ino Normal file
View File

@@ -0,0 +1,29 @@
/* Infrared_Read.ino Example sketch for IRLib2 and Circuit Playground Express
Illustrates how to receive an IR signal, decode it and print
information about it to the serial monitor.
*/
#include <Adafruit_CircuitPlayground.h>
#if !defined(ARDUINO_SAMD_CIRCUITPLAYGROUND_EXPRESS)
#error "Infrared support is only for the Circuit Playground Express, it doesn't work with the Classic version"
#endif
void setup() {
CircuitPlayground.begin();
Serial.begin(9600);
while (!Serial); // Wait until serial console is opened
CircuitPlayground.irReceiver.enableIRIn(); // Start the receiver
Serial.println("Ready to receive IR signals");
}
void loop() {
//Continue looping until you get a complete signal received
if (CircuitPlayground.irReceiver.getResults()) {
CircuitPlayground.irDecoder.decode(); //Decode it
CircuitPlayground.irDecoder.dumpResults(false); //Now print results. Use false for less detail
CircuitPlayground.irReceiver.enableIRIn(); //Restart receiver
}
}

66
arduino-cli/libraries/Adafruit_Circuit_Playground/examples/Infrared_Demos/Infrared_Record/Infrared_Record.ino Normal file
View File

@@ -0,0 +1,66 @@
/* Infrared_Record.ino Example sketch for IRLib2 and Circuit Playground Express
Illustrates how to receive an IR signal, decode and save it.
Then retransmit it whenever you push the left pushbutton.
*/
#include <Adafruit_CircuitPlayground.h>
#if !defined(ARDUINO_SAMD_CIRCUITPLAYGROUND_EXPRESS)
#error "Infrared support is only for the Circuit Playground Express, it doesn't work with the Classic version"
#endif
/* IR signals consist of a protocol number, a value, and a number of bits.
* Store all of these values for future use.
*/
uint8_t IR_protocol;
uint32_t IR_value;
uint16_t IR_bits;
void setup() {
Serial.begin(9600);
while (!Serial);
Serial.println("Send an IR signal and I will record it.");
Serial.println("Press the left button and we will retransmit it.");
CircuitPlayground.begin();
CircuitPlayground.irReceiver.enableIRIn(); // Start the receiver
IR_protocol=0; // Indicates we've not received a code yet
}
void loop() {
/* Receiver will look for a signal and when wa complete frame of data
* has been received, getResults() returns true. Once that happens,
* the receiver stops reccording so you will need to restart it
* after you have processed the data.
*/
if(CircuitPlayground.irReceiver.getResults()) {
//attempt to decode it
if(CircuitPlayground.irDecoder.decode()) {
Serial.println("IR decoded");
//Print the results. Change parameter to "true" for verbose output.
CircuitPlayground.irDecoder.dumpResults(false);
Serial.println("Saving results. Press left button to retransmit.");
IR_protocol=CircuitPlayground.irDecoder.protocolNum;
IR_value= CircuitPlayground.irDecoder.value;
IR_bits= CircuitPlayground.irDecoder.bits;
}
CircuitPlayground.irReceiver.enableIRIn(); //Restart receiver
}
/* If the left button is pressed and we have received a code
* retransmit it using the sender.
*/
if (CircuitPlayground.leftButton()) {
Serial.println("Left button pressed!");
if(IR_protocol) {
CircuitPlayground.irSend.send(IR_protocol, IR_value, IR_bits);
Serial.println("Sending recorded IR signal");
Serial.print("Protocol:"); Serial.print(IR_protocol,DEC);
Serial.print(" Value:0x"); Serial.print(IR_value,HEX);
Serial.print(" Bits:"); Serial.println(IR_bits,DEC);
} else {
Serial.println("No signal saved yet.");
}
}
}

33
arduino-cli/libraries/Adafruit_Circuit_Playground/examples/Infrared_Demos/Infrared_Send/Infrared_Send.ino Normal file
View File

@@ -0,0 +1,33 @@
/* Infrared_Send.ino Example sketch for IRLib2 and Circuit Playground Express
Illustrates how to transmit an IR signal whenever you do push one of the
built-in pushbuttons.
*/
#include <Adafruit_CircuitPlayground.h>
#if !defined(ARDUINO_SAMD_CIRCUITPLAYGROUND_EXPRESS)
#error "Infrared support is only for the Circuit Playground Express, it doesn't work with the Classic version"
#endif
void setup() {
CircuitPlayground.begin();
}
//Defines for a Samsung TV using NECx protocol
#define MY_PROTOCOL NECX
#define MY_BITS 32
#define MY_MUTE 0xE0E0F00F
#define MY_POWER 0xE0E040BF
void loop() {
// If the left button is pressed send a mute code.
if (CircuitPlayground.leftButton()) {
CircuitPlayground.irSend.send(MY_PROTOCOL,MY_MUTE,MY_BITS);
while (CircuitPlayground.leftButton()) {}//wait until button released
}
// If the right button is pressed send a power code.
if (CircuitPlayground.rightButton()) {
CircuitPlayground.irSend.send(MY_PROTOCOL,MY_POWER,MY_BITS);
while (CircuitPlayground.rightButton()) {}//wait until button released
}
}

107
arduino-cli/libraries/Adafruit_Circuit_Playground/examples/Infrared_Demos/Infrared_Testpattern/Infrared_Testpattern.ino Normal file
View File

@@ -0,0 +1,107 @@
/* Infrared_Testpattern.ino Example sketch for IRLib2 and Circuit Playground Express
* Send an easily recognized pattern of bits from one Arduino
* to another to verify that your protocol is working. Load
* this sketch to send a signal. Use the "dump" sketch on the other
* Arduino to receive codes. Open the serial monitor and type the
* number Of the protocol want to test.
*/
#include <Adafruit_CircuitPlayground.h>
#if !defined(ARDUINO_SAMD_CIRCUITPLAYGROUND_EXPRESS)
#error "Infrared support is only for the Circuit Playground Express, it doesn't work with the Classic version"
#endif
void setup() {
CircuitPlayground.begin();
Serial.begin(9600);
while (!Serial); // Wait for serial console
Serial.println("Type the protocol number: 1-12 Or '-1' for all");
}
void sendOne(uint8_t protocol, uint32_t data, uint16_t data2 = 0, uint8_t khz = 0) {
Serial.print("Protocol #"); Serial.print(protocol, DEC);
Serial.print("\t"); Serial.print(Pnames(protocol));
Serial.print("\t data = 0x"); Serial.print(data, HEX);
if (data2) {
Serial.print("\t data2 = 0x"); Serial.print(data2, HEX);
Serial.print(" "); Serial.print(data2, DEC);
Serial.print(" dec");
}
if (khz) {
CircuitPlayground.irSend.send(protocol, data, data2, khz);
Serial.print(" khz="); Serial.println(khz,DEC);
} else {
CircuitPlayground.irSend.send(protocol, data, data2);
Serial.println();
}
delay(2000);
}
#define PATTERN1 0x12345678
#define ALL1S 0xFFFFFFFF
void doTest (uint8_t P) {
switch (P) {
case 1: sendOne(1,PATTERN1); //NEC Regular data
sendOne(1,REPEAT_CODE); //NEC Special ditto repeat code
sendOne(1,PATTERN1,40); //Pioneer is NEC with 40 kHz modulation
break;
case 2: sendOne(2,PATTERN1,12); //Sony 12 bits
sendOne(2,PATTERN1,15); //Sony 15 bits
sendOne(2,PATTERN1,20); //Sony 20 bits
break; //Note: Sony always sends three copies of signal
case 3: sendOne(3,ALL1S,13); //RC5
sendOne(3,ALL1S,14); //RC5-F7
sendOne(3,ALL1S,14,57); //RC5-F7-57
break;
case 4: sendOne(4,0x0ffff,20); //RC6-0-16 Original Phillips RC6
sendOne(4,0xcfffff,24); //RC6-6-20 Used by some Sky and Sky+ remotes
sendOne(4,0xcfffff,28); //RC6-6-24 a.k.a. "Replay" protocol
sendOne(4,ALL1S,32); //RC6-6-32 a.k.a. "MCE" protocol
break;
case 5: sendOne(5,ALL1S); //Panasonic_Old 22 bits used by some SA and Cisco cable boxes
break;
case 6: //JVC use "true" for first frame, "false" for repeats
//When "true" it automatically sends one repeat. Use "false"
//for additional repeats. The 2 lines below will actually send
//a total of 3 frames... A first and 2 repeats.
sendOne(6,PATTERN1,true);
sendOne(6,PATTERN1,false);
break;
case 7: sendOne(7,PATTERN1); //NECx used by many Samsung TVs
sendOne(7,REPEAT_CODE); //Some varieties use ditto
break;
case 8: sendOne(8,0x12345,0x1234);//Samsung36 16 bit address +20 data
break;
case 9: sendOne(9,PATTERN1); //G.I.Cable 16 bits with ditto repeat
sendOne(9,REPEAT_CODE); //This will report NEC if both protocols used
break;
case 10: sendOne(10,PATTERN1); //DirecTV default no repeat, 38 khz
sendOne(10,PATTERN1,true);//3rd parameter is repeat flag
sendOne(10,PATTERN1,false,40);//4th is khz, 38, 40, 57 are legal
break;
case 11: sendOne(11,ALL1S,12); //RCMM Phillips protocol used by U-Verse
sendOne(11,ALL1S,24); //also 24 or 32 bit possible
sendOne(11,ALL1S,32);
break;
case 12: sendOne(12,CYKM_MOUSE_MOVE+CYKM_DIR_RIGHT);//Move mouse right
sendOne(12,CYKM_MOUSE_MOVE+CYKM_DIR_UP); //Move mouse up
sendOne(12,CYKM_MOUSE_MOVE+CYKM_DIR_LEFT); //Move mouse left
sendOne(12,CYKM_MOUSE_MOVE+CYKM_DIR_DOWN); //Move mouse down
break;
};
}
void loop() {
if (Serial.available () > 0) {
int16_t i = Serial.parseInt();
if(i==-1) {
for(i=1;i<=12;i++) {
doTest(i);
};
} else {
doTest(i);
}
}
}

464
arduino-cli/libraries/Adafruit_Circuit_Playground/examples/Microphone_Demos/Birthday_Candles/Birthday_Candles.ino Normal file
View File

@@ -0,0 +1,464 @@
// Circuit Playground Birthday Candles
//
// All the NeoPixels will flicker like candles and the speaker will
// play the tune to Happy Birthday continuously. Blow on the board
// to slowly blow out all the candles and hear a victory song!
// Controls:
// - Slide switch: Move this to +/on to hear music or -/off to disable sound.
// - Left button: Hold this down and press reset to use a rainbow flicker color.
// - Right button: Hold this down and press reset to use a simple solid color (no flicker).
// - If neither left or right button are pressed at startup then a flame-like
// flickering animation will be used.
// After all the candles are blown out press reset to reset and start over!
//
// Author: Tony DiCola
// License: MIT (https://opensource.org/licenses/MIT)
#include <Adafruit_CircuitPlayground.h>
// General configuration defines:
#define BREATH_THRESHOLD 92 // Peak to peak sound pressure level that
// determines if someone is blowing on the board.
// You can open the serial console to see the sound
// levels and adjust as necessary!
#define FLAME_LIFE_MS 200 // Amount of time (in milliseconds) that each
// candle flame takes to blow out. Increase this
// to make it harder/slower to blow them all out
// and decrease it to make it easier/faster.
#define FLAME_HUE 35 // Primary hue of the flame. This is a value in
// degrees from 0.0 to 360.0, see HSV color space
// for different hue values:
// https://en.wikipedia.org/wiki/HSL_and_HSV#/media/File:Hsl-hsv_models.svg
// The value 35 degrees is a nice orange in the
// middle of red and yellow hues that will look like
// a flame flickering as the hues animate.
// For the flicker effect the pixels will cycle
// around hues that are +/-10 degrees of this value.
// For the solid effect the pixels will be set
// to this hue (at full saturation and value).
// Rainbow effect ignores this hue config and
// cycles through all of them.
#define LIT_CANDLES 10 // The number of candles to start with lit. By
// default all 10 candles/pixels will be lit but
// adjust down to light less for a young kid's
// birthday.
// A few music note frequencies as defined in this tone example:
// https://www.arduino.cc/en/Tutorial/toneMelody
#define NOTE_C4 262
#define NOTE_CS4 277
#define NOTE_D4 294
#define NOTE_DS4 311
#define NOTE_E4 330
#define NOTE_F4 349
#define NOTE_FS4 370
#define NOTE_G4 392
#define NOTE_GS4 415
#define NOTE_A4 440
#define NOTE_AS4 466
#define NOTE_B4 494
#define NOTE_C5 523
#define NOTE_CS5 554
#define NOTE_D5 587
#define NOTE_DS5 622
#define NOTE_E5 659
#define NOTE_F5 698
#define NOTE_FS5 740
#define NOTE_G5 784
#define NOTE_GS5 831
#define NOTE_A5 880
#define NOTE_AS5 932
#define NOTE_B5 988
// Define note durations. You only need to adjust the whole note
// time and other notes will be subdivided from it directly.
#define WHOLE 2200 // Length of time in milliseconds of a whole note (i.e. a full bar).
#define HALF WHOLE/2
#define QUARTER HALF/2
#define EIGHTH QUARTER/2
#define EIGHTH_TRIPLE QUARTER/3
#define SIXTEENTH EIGHTH/2
// Color gamma correction table, this makes the hues of the NeoPixels
// a little more accurate by accounting for our eye's non-linear color
// sensitivity. See this great guide for more details:
// https://learn.adafruit.com/led-tricks-gamma-correction/the-issue
const uint8_t PROGMEM gamma8[] = {
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, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2,
2, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 5, 5, 5,
5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8, 9, 9, 9, 10,
10, 10, 11, 11, 11, 12, 12, 13, 13, 13, 14, 14, 15, 15, 16, 16,
17, 17, 18, 18, 19, 19, 20, 20, 21, 21, 22, 22, 23, 24, 24, 25,
25, 26, 27, 27, 28, 29, 29, 30, 31, 32, 32, 33, 34, 35, 35, 36,
37, 38, 39, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 50,
51, 52, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 66, 67, 68,
69, 70, 72, 73, 74, 75, 77, 78, 79, 81, 82, 83, 85, 86, 87, 89,
90, 92, 93, 95, 96, 98, 99,101,102,104,105,107,109,110,112,114,
115,117,119,120,122,124,126,127,129,131,133,135,137,138,140,142,
144,146,148,150,152,154,156,158,160,162,164,167,169,171,173,175,
177,180,182,184,186,189,191,193,196,198,200,203,205,208,210,213,
215,218,220,223,225,228,231,233,236,239,241,244,247,249,252,255 };
// Global program state.
int lit = LIT_CANDLES; // How many candles are still lit. Once all are extinguished this falls to -1.
float frequencies[10] = {0}; // Random frequencies and phases will be generated for each pixel to
float phases[10] = {0}; // define an organic but random looking flicker effect.
enum AnimationType { SOLID, FLICKER, RAINBOW }; // Which type of animation is currently running.
AnimationType animation = FLICKER;
// Play a note of the specified frequency and for the specified duration.
// Hold is an optional bool that specifies if this note should be held a
// little longer, i.e. for eigth notes that are tied together.
// While waiting for a note to play the waitBreath delay function is used
// so breath detection and pixel animation continues to run. No tones
// will play if the slide switch is in the -/off position or all the
// candles have been blown out.
void playNote(int frequency, int duration, bool hold=false, bool measure=true) {
// Check if the slide switch is off or the candles have been blown out
// and stop immediately without playing anything.
if (!CircuitPlayground.slideSwitch() || lit < 0) {
return;
}
if (hold) {
// For a note that's held play it a little longer than the specified duration
// so it blends into the next tone (but there's still a small delay to
// hear the next note).
CircuitPlayground.playTone(frequency, duration + duration/32, false);
}
else {
// For a note that isn't held just play it for the specified duration.
CircuitPlayground.playTone(frequency, duration, false);
}
// Use waitBreath instead of Arduino's delay because breath detection and
// pixel animation needs to occur while music plays. However skip this logic
// if not asked for (measure = false, only needed when playing celebration
// song so as to not continue waiting for breaths).
if (measure) {
waitBreath(duration + duration/16);
}
else {
delay(duration + duration/16);
}
}
// Delay for the specified number of milliseconds while at the same time
// listening for a continuous loud sound on from the microphone, i.e. someone
// blowing directly on it, and animating the NeoPixels. When a breath is detected
// the number of lit candles will gradually decrease. Once the number of lit
// candles hits zero then a celebration tune is played and everything stops.
void waitBreath(uint32_t milliseconds) {
float peakToPeak = measurePeak(milliseconds);
// Serial.println(peakToPeak);
while (peakToPeak >= BREATH_THRESHOLD) {
// Decrement the number of lit candles and keep it from going below
// the value -1 (a sentinel that indicates all the candles are blown out
// and no music playback, etc. should occur anymore).
lit = max(lit-1, -1);
// For the simple solid color animation (i.e. no flickering) only update
// the pixels when the lit pixel count changes. This allows the tone
// playback to sound better because the pixels don't need to be updated
// during delays and music note playback (the pixel writing messes with
// interrupts that drive tone playback and cause scratchier sounding tones).
if (animation == SOLID) {
showLitSolid();
}
// Check if we just hit 0 candles lit up, i.e. they're all blown out.
// Turn off the pixels and play a little celebration tune when it
// happens, then indicate the candles are blown out with the -1 sentinel value.
if (lit == 0) {
CircuitPlayground.clearPixels();
celebrateSong();
lit = -1;
}
// Keep measuring the peak to peak sound value for a period of time
// that it takes to blow out another candle.
peakToPeak = measurePeak(FLAME_LIFE_MS);
}
}
// Song to play when the candles are blown out.
void celebrateSong() {
// Play a little charge melody, from:
// https://en.wikipedia.org/wiki/Charge_(fanfare)
// Note the explicit boolean parameters in particular the measure=false
// at the end. This means the notes will play without any breath measurement
// logic. Without this false value playNote will try to keep waiting for candles
// to blow out during the celebration song!
playNote(NOTE_G4, EIGHTH_TRIPLE, true, false);
playNote(NOTE_C5, EIGHTH_TRIPLE, true, false);
playNote(NOTE_E5, EIGHTH_TRIPLE, false, false);
playNote(NOTE_G5, EIGHTH, true, false);
playNote(NOTE_E5, SIXTEENTH, false);
playNote(NOTE_G5, HALF, false);
}
// Measure the peak to peak sound pressure level from the microphone
// for a specified number of milliseconds.
// While measuring the current NeoPixel animation will be updated too.
float measurePeak(uint32_t milliseconds) {
float soundMax = 0;
// Loop until the specified number of milliseconds have ellapsed.
uint32_t start = millis();
uint32_t current = start;
while ((current - start) < milliseconds) {
// Inside the loop check the sound pressure level 10ms at a time
float sample = CircuitPlayground.mic.soundPressureLevel(10);
Serial.println(sample);
soundMax = max(sample, soundMax);
// Be sure to drive the NeoPixel animation too.
animatePixels(current);
current = millis();
}
return soundMax;
}
// Perform a frame of animation on the NeoPixels.
// Current is the current monotonically increasing time in milliseconds.
void animatePixels(uint32_t current) {
switch (animation) {
case FLICKER:
showLitFlicker(current);
break;
case RAINBOW:
showLitRainbow(current);
break;
// Ignore the SOLID case as it has no animation.
// This makes the audio smoother since it doesn't get interrupted by
// NeoPixel writing like the other animations. The pixels are instead
// changed only once when the number of lit candles changes (see the
// waitBreath function's loop).
}
}
// Helper to change the color of a NeoPixel on the Circuit Playground board.
// Will automatically convert from HSV color space to RGB and apply gamma
// correction.
float setPixelHSV(int i, float h, float s, float v) {
// Convert HSV to RGB
float r, g, b = 0.0;
HSVtoRGB(&r, &g, &b, h, s, v);
// Lookup gamma correct RGB colors (also convert from 0...1.0 RGB range to 0...255 byte range).
uint8_t r1 = pgm_read_byte(&gamma8[int(r*255.0)]);
uint8_t g1 = pgm_read_byte(&gamma8[int(g*255.0)]);
uint8_t b1 = pgm_read_byte(&gamma8[int(b*255.0)]);
// Set the color of the pixel.
CircuitPlayground.strip.setPixelColor(i, r1, g1, b1);
}
// Rainbow candle flicker animation.
// Uses a sine wave with random frequency and phase (computed ahead of time in setup)
// to smoothly modulate the hue of each NeoPixel candle flame over time.
void showLitRainbow(uint32_t current) {
// Convert time from milliseconds to seconds.
float t = current/1000.0;
// Loop through each pixel and compute its color.
for (int i=0; i<10; ++i) {
if (i < lit) {
// This pixel should be lit, so compute its hue from the sine wave
// equation and set the color accordingly. Notice the frequency
// is scaled down by 10 to 'slow down' the rainbow flicker animation.
// This lets the same random frequencies be shared between fast candle
// flame effects and this slower rainbow flicker effect.
float x = sin(2.0*PI*frequencies[i]/10.0*t + phases[i]);
// Interpolate the sine wave between all 360 degree hue values.
float h = lerp(x, -1.0, 1.0, 0.0, 360.0);
setPixelHSV(i, h, 1.0, 1.0);
}
else {
// This pixel has been blown out, just turn it off.
setPixelHSV(i, 0, 0, 0);
}
}
CircuitPlayground.strip.show();
}
// Flickering candle animation effect.
// Uses a noisey sine wave to modulate the hue of each pixel within a range
// of flame colors. The sine wave has some low and high frequency components
// which give it an organice and seemingly random appearance.
void showLitFlicker(uint32_t current) {
// First determine the low and high bounds of the flicker hues.
// These are +/- 10 degrees of the specified target hue and will
// wrap around to the start/end as appropriate.
float lowHue = fmod(FLAME_HUE - 10.0, 360.0);
float highHue = fmod(FLAME_HUE + 10.0, 360.0);
// Convert time from milliseconds to seconds.
float t = current/1000.0;
// Loop through each pixel and compute its color.
for (int i=0; i<10; ++i) {
if (i < lit) {
// This pixel should be lit, so compute its hue by composing
// a low frequency / slowly changing sine wave with a high
// frequency / fast changing cosine wave. This means the candle will
// pulse and jump around in an organice but random looking way.
// The frequencies and phases of the waves are randomly generated at
// startup in the setup function.
// Low frequency wave is a sine wave with random freuqency between 1 and 4,
// and offset by a random phase to keep pixels from all starting at the same
// color:
float lowFreq = sin(2.0*PI*frequencies[i]*t + phases[i]);
// High frequency is a faster changing cosine wave that uses a different
// pixel's random frequency.
float highFreq = cos(3.0*PI*frequencies[(i+5)%10]*t);
// Add the low and high frequency waves together, then interpolate their value
// to a hue that's +/-20% of the configured target hue.
float h = lerp(lowFreq+highFreq, -2.0, 2.0, lowHue, highHue);
setPixelHSV(i, h, 1.0, 1.0);
}
else {
// This pixel has been blown out, just turn it off.
setPixelHSV(i, 0, 0, 0);
}
}
CircuitPlayground.strip.show();
}
// Simple solid lit candle effect.
// No animation, each pixel is lit with the specified flame hue until they're all blown out.
void showLitSolid() {
for (int i=0; i<10; ++i) {
if (i < lit) {
// This pixel should be lit.
setPixelHSV(i, FLAME_HUE, 1.0, 1.0);
}
else {
// This pixel has been blown out, just turn it off.
setPixelHSV(i, 0, 0, 0);
}
}
CircuitPlayground.strip.show();
}
// HSV to RGB color space conversion function taken directly from:
// https://www.cs.rit.edu/~ncs/color/t_convert.html
void HSVtoRGB( float *r, float *g, float *b, float h, float s, float v )
{
int i;
float f, p, q, t;
if( s == 0 ) {
// achromatic (grey)
*r = *g = *b = v;
return;
}
h /= 60; // sector 0 to 5
i = floor( h );
f = h - i; // factorial part of h
p = v * ( 1 - s );
q = v * ( 1 - s * f );
t = v * ( 1 - s * ( 1 - f ) );
switch( i ) {
case 0:
*r = v;
*g = t;
*b = p;
break;
case 1:
*r = q;
*g = v;
*b = p;
break;
case 2:
*r = p;
*g = v;
*b = t;
break;
case 3:
*r = p;
*g = q;
*b = v;
break;
case 4:
*r = t;
*g = p;
*b = v;
break;
default: // case 5:
*r = v;
*g = p;
*b = q;
break;
}
}
// Linear interpolation of value y within y0...y1 given x and x0...x1.
float lerp(float x, float x0, float x1, float y0, float y1) {
return y0 + (x-x0)*((y1-y0)/(x1-x0));
}
void setup() {
// Initialize serial output and Circuit Playground library.
Serial.begin(115200);
CircuitPlayground.begin();
// Check if a button is being pressed at startup and change the
// animation mode accordingly.
if (CircuitPlayground.leftButton()) {
// Rainbow animation on left button press at startup.
animation = RAINBOW;
}
else if (CircuitPlayground.rightButton()) {
// Solid color animation on right button press at startup.
animation = SOLID;
// Since the solid animation doesn't update every frame, bootstrap it by
// turning all the pixels on at the start. As candles are blown out the
// pixels will be updated (see the waitBreath function's loop).
showLitSolid();
}
else {
// Otherwise default to flicker animation.
animation = FLICKER;
}
// Read the sound sensor and use it to initialize the random number generator.
randomSeed(CircuitPlayground.soundSensor());
// Precompute random frequency and phase values for each pixel.
// This gives the flicker an organic but random looking appearance.
for (int i=0; i<10; ++i) {
// Generate random floating point frequency values between 1.0 and 4.0.
frequencies[i] = random(1000, 4000)/1000.0;
// Generate random floating point phase values between 0 and 2*PI.
phases[i] = random(1000)/1000.0 * 2.0 * PI;
}
}
void loop() {
// Play happy birthday tune, from:
// http://www.irish-folk-songs.com/happy-birthday-tin-whistle-sheet-music.html#.WXFJMtPytBw
// Inside each playNote call it will play a note and drive the NeoPixel animation
// and check for a breath against the sound sensor. Once all the candles are blown out
// the playNote calls will stop playing music.
playNote(NOTE_D4, EIGHTH, true);
playNote(NOTE_D4, EIGHTH);
playNote(NOTE_E4, QUARTER); // Bar 1
playNote(NOTE_D4, QUARTER);
playNote(NOTE_G4, QUARTER);
playNote(NOTE_FS4, HALF); // Bar 2
playNote(NOTE_D4, EIGHTH, true);
playNote(NOTE_D4, EIGHTH);
playNote(NOTE_E4, QUARTER); // Bar 3
playNote(NOTE_D4, QUARTER);
playNote(NOTE_A4, QUARTER);
playNote(NOTE_G4, HALF); // Bar 4
playNote(NOTE_D4, EIGHTH, true);
playNote(NOTE_D4, EIGHTH);
playNote(NOTE_D5, QUARTER); // Bar 5
playNote(NOTE_B4, QUARTER);
playNote(NOTE_G4, QUARTER);
playNote(NOTE_FS4, QUARTER); // Bar 6
playNote(NOTE_E4, QUARTER);
playNote(NOTE_C5, EIGHTH, true);
playNote(NOTE_C5, EIGHTH);
playNote(NOTE_B4, QUARTER); // Bar 7
playNote(NOTE_G4, QUARTER);
playNote(NOTE_A4, QUARTER);
playNote(NOTE_G4, HALF); // Bar 8
// One second pause before repeating the loop and playing
// the tune again. Use waitBreath instead of delay so the
// pixel animation and breath check continues to happen.
waitBreath(1000);
}

205
arduino-cli/libraries/Adafruit_Circuit_Playground/examples/Microphone_Demos/mic_FFT_classic/mic_FFT_classic.ino Normal file
View File

@@ -0,0 +1,205 @@
// FFT-based audio visualizer for Adafruit Circuit Playground: uses the
// built-in mic on A4, 10x NeoPixels for display. Built on the ELM-Chan
// FFT library for AVR microcontrollers.
// The fast Fourier transform (FFT) algorithm converts a signal from the
// time domain to the frequency domain -- e.g. turning a sampled audio
// signal into a visualization of frequencies and magnitudes -- an EQ meter.
// The FFT algorithm itself is handled in the Circuit Playground library;
// the code here is mostly for converting that function's output into
// animation. In most AV gear it's usually done with bargraph displays;
// with a 1D output (the 10 NeoPixels) we need to get creative with color
// and brightness...it won't look great in every situation (seems to work
// best with LOUD music), but it's colorful and fun to look at. So this
// code is mostly a bunch of tables and weird fixed-point (integer) math
// that probably doesn't make much sense even with all these comments.
#include <Adafruit_CircuitPlayground.h>
#include <Wire.h>
#include <SPI.h>
// GLOBAL STUFF ------------------------------------------------------------
// Displaying EQ meter output straight from the FFT may be 'correct,' but
// isn't always visually interesting (most bins spend most time near zero).
// Dynamic level adjustment narrows in on a range of values so there's
// always something going on. The upper and lower range are based on recent
// audio history, and on a per-bin basis (some may be more active than
// others, so this keeps one or two "loud" bins from spoiling the rest.
#define BINS 10 // FFT output is filtered down to this many bins
#define FRAMES 4 // This many FFT cycles are averaged for leveling
uint8_t lvl[FRAMES][BINS], // Bin levels for the prior #FRAMES frames
avgLo[BINS], // Pseudo rolling averages for bins -- lower and
avgHi[BINS], // upper limits -- for dynamic level adjustment.
frameIdx = 0; // Counter for lvl storage
// CALIBRATION CONSTANTS ---------------------------------------------------
const uint8_t PROGMEM
// Low-level noise initially subtracted from each of 32 FFT bins
noise[] = { 0x04,0x03,0x03,0x03, 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 },
// FFT bins (32) are then filtered down to 10 output bins (to match the
// number of NeoPixels on Circuit Playground). 10 arrays here, one per
// output bin. First element of each is the number of input bins to
// merge, second element is index of first merged bin, remaining values
// are scaling weights as each input bin is merged into output. The
// merging also "de-linearizes" the FFT output, so it's closer to a
// logarithmic scale with octaves evenly-ish spaced, music looks better.
bin0data[] = { 1, 2, 147 },
bin1data[] = { 2, 2, 89, 14 },
bin2data[] = { 2, 3, 89, 14 },
bin3data[] = { 4, 3, 15, 181, 58, 3 },
bin4data[] = { 4, 4, 15, 181, 58, 3 },
bin5data[] = { 6, 5, 6, 89, 185, 85, 14, 2 },
bin6data[] = { 7, 7, 5, 60, 173, 147, 49, 9, 1 },
bin7data[] = { 10, 8, 3, 23, 89, 170, 176, 109, 45, 14, 4, 1 },
bin8data[] = { 13, 11, 2, 12, 45, 106, 167, 184, 147, 89, 43, 18, 6, 2, 1 },
bin9data[] = { 18, 14, 2, 6, 19, 46, 89, 138, 175, 185, 165, 127, 85, 51, 27, 14, 7, 3, 2, 1 },
// Pointers to 10 bin arrays, because PROGMEM arrays-of-arrays are weird:
* const binData[] = { bin0data, bin1data, bin2data, bin3data, bin4data,
bin5data, bin6data, bin7data, bin8data, bin9data },
// R,G,B values for color wheel covering 10 NeoPixels:
reds[] = { 0xAD, 0x9A, 0x84, 0x65, 0x00, 0x00, 0x00, 0x00, 0x65, 0x84 },
greens[] = { 0x00, 0x66, 0x87, 0x9E, 0xB1, 0x87, 0x66, 0x00, 0x00, 0x00 },
blues[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0xC3, 0xE4, 0xFF, 0xE4, 0xC3 },
gamma8[] = { // Gamma correction improves the appearance of midrange colors
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,
0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x03,
0x03, 0x03, 0x04, 0x04, 0x04, 0x04, 0x05, 0x05, 0x05, 0x05, 0x05, 0x06,
0x06, 0x06, 0x06, 0x07, 0x07, 0x07, 0x08, 0x08, 0x08, 0x09, 0x09, 0x09,
0x0A, 0x0A, 0x0A, 0x0B, 0x0B, 0x0B, 0x0C, 0x0C, 0x0D, 0x0D, 0x0D, 0x0E,
0x0E, 0x0F, 0x0F, 0x10, 0x10, 0x11, 0x11, 0x12, 0x12, 0x13, 0x13, 0x14,
0x14, 0x15, 0x15, 0x16, 0x16, 0x17, 0x18, 0x18, 0x19, 0x19, 0x1A, 0x1B,
0x1B, 0x1C, 0x1D, 0x1D, 0x1E, 0x1F, 0x1F, 0x20, 0x21, 0x22, 0x22, 0x23,
0x24, 0x25, 0x26, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2A, 0x2B, 0x2C, 0x2D,
0x2E, 0x2F, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x3F, 0x40, 0x41, 0x42, 0x44, 0x45, 0x46,
0x47, 0x48, 0x49, 0x4B, 0x4C, 0x4D, 0x4E, 0x50, 0x51, 0x52, 0x54, 0x55,
0x56, 0x58, 0x59, 0x5A, 0x5C, 0x5D, 0x5E, 0x60, 0x61, 0x63, 0x64, 0x66,
0x67, 0x69, 0x6A, 0x6C, 0x6D, 0x6F, 0x70, 0x72, 0x73, 0x75, 0x77, 0x78,
0x7A, 0x7C, 0x7D, 0x7F, 0x81, 0x82, 0x84, 0x86, 0x88, 0x89, 0x8B, 0x8D,
0x8F, 0x91, 0x92, 0x94, 0x96, 0x98, 0x9A, 0x9C, 0x9E, 0xA0, 0xA2, 0xA4,
0xA6, 0xA8, 0xAA, 0xAC, 0xAE, 0xB0, 0xB2, 0xB4, 0xB6, 0xB8, 0xBA, 0xBC,
0xBF, 0xC1, 0xC3, 0xC5, 0xC7, 0xCA, 0xCC, 0xCE, 0xD1, 0xD3, 0xD5, 0xD7,
0xDA, 0xDC, 0xDF, 0xE1, 0xE3, 0xE6, 0xE8, 0xEB, 0xED, 0xF0, 0xF2, 0xF5,
0xF7, 0xFA, 0xFC, 0xFF };
const uint16_t PROGMEM
// Scaling values applied to each FFT bin (32) after noise subtraction
// but prior to merging/filtering. When multiplied by these values,
// then divided by 256, these tend to produce outputs in the 0-255
// range (VERY VERY "ISH") at normal listening levels. These were
// determined empirically by throwing lots of sample audio at it.
binMul[] = { 405, 508, 486, 544, 533, 487, 519, 410,
481, 413, 419, 410, 397, 424, 412, 411,
511, 591, 588, 577, 554, 529, 524, 570,
546, 559, 511, 552, 439, 488, 483, 547, },
// Sums of bin weights for bin-merging tables above.
binDiv[] = { 147, 103, 103, 257, 257, 381, 444, 634, 822, 1142 };
// SETUP FUNCTION - runs once ----------------------------------------------
void setup() {
CircuitPlayground.begin();
CircuitPlayground.setBrightness(255);
CircuitPlayground.clearPixels();
// Initialize rolling average ranges
uint8_t i;
for(i=0; i<BINS; i++) {
avgLo[i] = 0;
avgHi[i] = 255;
}
for(i=0; i<FRAMES; i++) {
memset(&lvl[i], 127, sizeof(lvl[i]));
}
}
// LOOP FUNCTION - runs over and over - does animation ---------------------
void loop() {
uint16_t spectrum[32]; // FFT spectrum output buffer
CircuitPlayground.mic.fft(spectrum);
// spectrum[] is now raw FFT output, 32 bins.
// Remove noise and apply EQ levels
uint8_t i, N;
uint16_t S;
for(i=0; i<32; i++) {
N = pgm_read_byte(&noise[i]);
if(spectrum[i] > N) { // Above noise threshold: scale & clip
S = ((spectrum[i] - N) *
(uint32_t)pgm_read_word(&binMul[i])) >> 8;
spectrum[i] = (S < 255) ? S : 255;
} else { // Below noise threshold: clip
spectrum[i] = 0;
}
}
// spectrum[] is now noise-filtered, scaled & clipped
// FFT output, in range 0-255, still 32 bins.
// Filter spectrum[] from 32 elements down to 10,
// make pretty colors out of it:
uint16_t sum, level;
uint8_t j, minLvl, maxLvl, nBins, binNum, *data;
for(i=0; i<BINS; i++) { // For each output bin (and each pixel)...
data = (uint8_t *)pgm_read_word(&binData[i]);
nBins = pgm_read_byte(&data[0]); // Number of input bins to merge
binNum = pgm_read_byte(&data[1]); // Index of first input bin
data += 2;
for(sum=0, j=0; j<nBins; j++) {
sum += spectrum[binNum++] * pgm_read_byte(&data[j]); // Total
}
sum /= pgm_read_word(&binDiv[i]); // Average
lvl[frameIdx][i] = sum; // Save for rolling averages
minLvl = maxLvl = lvl[0][i]; // Get min and max range for bin
for(j=1; j<FRAMES; j++) { // from prior stored frames
if(lvl[j][i] < minLvl) minLvl = lvl[j][i];
else if(lvl[j][i] > maxLvl) maxLvl = lvl[j][i];
}
// minLvl and maxLvl indicate the extents of the FFT output for this
// bin over the past few frames, used for vertically scaling the output
// graph (so it looks interesting regardless of volume level). If too
// close together though (e.g. at very low volume levels) the graph
// becomes super coarse and 'jumpy'...so keep some minimum distance
// between them (also lets the graph go to zero when no sound playing):
if((maxLvl - minLvl) < 23) {
maxLvl = (minLvl < (255-23)) ? minLvl + 23 : 255;
}
avgLo[i] = (avgLo[i] * 7 + minLvl) / 8; // Dampen min/max levels
avgHi[i] = (maxLvl >= avgHi[i]) ? // (fake rolling averages)
(avgHi[i] * 3 + maxLvl) / 4 : // Fast rise
(avgHi[i] * 31 + maxLvl) / 32; // Slow decay
// Second fixed-point scale then 'stretches' each bin based on
// dynamic min/max levels to 0-256 range:
level = 1 + ((sum <= avgLo[i]) ? 0 :
256L * (sum - avgLo[i]) / (long)(avgHi[i] - avgLo[i]));
// Clip output and convert to color:
if(level <= 255) {
uint8_t r = (pgm_read_byte(&reds[i]) * level) >> 8,
g = (pgm_read_byte(&greens[i]) * level) >> 8,
b = (pgm_read_byte(&blues[i]) * level) >> 8;
CircuitPlayground.strip.setPixelColor(i,
pgm_read_byte(&gamma8[r]),
pgm_read_byte(&gamma8[g]),
pgm_read_byte(&gamma8[b]));
} else { // level = 256, show white pixel OONTZ OONTZ
CircuitPlayground.strip.setPixelColor(i, 0x56587F);
}
}
CircuitPlayground.strip.show();
if(++frameIdx >= FRAMES) frameIdx = 0;
}

137
arduino-cli/libraries/Adafruit_Circuit_Playground/examples/Microphone_Demos/mic_FFT_express/mic_FFT_express.ino Normal file
View File

@@ -0,0 +1,137 @@
/* This example shows how to use the FFT library with a Circuit Playground
* Express. Requires installing the "Adafruit Zero FFT library" (use the
* Arduino Library Manager to install it!
*
* The LEDs will map around the circle when frequencies between FREQ_MIN
* and FREQ_MAX are detected
*/
#include <Adafruit_CircuitPlayground.h>
#include "Adafruit_ZeroFFT.h"
//this must be a power of 2
#define DATA_SIZE 256
#define NUM_PIXELS 10
//the sample rate
#define FS 22000
//the lowest frequency that will register on the meter
#define FREQ_MIN 600
//the highest frequency that will register on the meter
#define FREQ_MAX 3000
#define MIN_INDEX FFT_INDEX(FREQ_MIN, FS, DATA_SIZE)
#define MAX_INDEX FFT_INDEX(FREQ_MAX, FS, DATA_SIZE)
#define SCALE_FACTOR 32
int16_t pixelData[NUM_PIXELS + 1];
int16_t inputData[DATA_SIZE];
const uint8_t
// R,G,B values for color wheel covering 10 NeoPixels:
reds[] = { 0xAD, 0x9A, 0x84, 0x65, 0x00, 0x00, 0x00, 0x00, 0x65, 0x84 },
greens[] = { 0x00, 0x66, 0x87, 0x9E, 0xB1, 0x87, 0x66, 0x00, 0x00, 0x00 },
blues[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0xC3, 0xE4, 0xFF, 0xE4, 0xC3 },
gamma8[] = { // Gamma correction improves the appearance of midrange colors
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,
0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x03,
0x03, 0x03, 0x04, 0x04, 0x04, 0x04, 0x05, 0x05, 0x05, 0x05, 0x05, 0x06,
0x06, 0x06, 0x06, 0x07, 0x07, 0x07, 0x08, 0x08, 0x08, 0x09, 0x09, 0x09,
0x0A, 0x0A, 0x0A, 0x0B, 0x0B, 0x0B, 0x0C, 0x0C, 0x0D, 0x0D, 0x0D, 0x0E,
0x0E, 0x0F, 0x0F, 0x10, 0x10, 0x11, 0x11, 0x12, 0x12, 0x13, 0x13, 0x14,
0x14, 0x15, 0x15, 0x16, 0x16, 0x17, 0x18, 0x18, 0x19, 0x19, 0x1A, 0x1B,
0x1B, 0x1C, 0x1D, 0x1D, 0x1E, 0x1F, 0x1F, 0x20, 0x21, 0x22, 0x22, 0x23,
0x24, 0x25, 0x26, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2A, 0x2B, 0x2C, 0x2D,
0x2E, 0x2F, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x3F, 0x40, 0x41, 0x42, 0x44, 0x45, 0x46,
0x47, 0x48, 0x49, 0x4B, 0x4C, 0x4D, 0x4E, 0x50, 0x51, 0x52, 0x54, 0x55,
0x56, 0x58, 0x59, 0x5A, 0x5C, 0x5D, 0x5E, 0x60, 0x61, 0x63, 0x64, 0x66,
0x67, 0x69, 0x6A, 0x6C, 0x6D, 0x6F, 0x70, 0x72, 0x73, 0x75, 0x77, 0x78,
0x7A, 0x7C, 0x7D, 0x7F, 0x81, 0x82, 0x84, 0x86, 0x88, 0x89, 0x8B, 0x8D,
0x8F, 0x91, 0x92, 0x94, 0x96, 0x98, 0x9A, 0x9C, 0x9E, 0xA0, 0xA2, 0xA4,
0xA6, 0xA8, 0xAA, 0xAC, 0xAE, 0xB0, 0xB2, 0xB4, 0xB6, 0xB8, 0xBA, 0xBC,
0xBF, 0xC1, 0xC3, 0xC5, 0xC7, 0xCA, 0xCC, 0xCE, 0xD1, 0xD3, 0xD5, 0xD7,
0xDA, 0xDC, 0xDF, 0xE1, 0xE3, 0xE6, 0xE8, 0xEB, 0xED, 0xF0, 0xF2, 0xF5,
0xF7, 0xFA, 0xFC, 0xFF };
// the setup routine runs once when you press reset:
void setup() {
CircuitPlayground.begin();
}
// Track low and high levels for dynamic adjustment
int minLvl = 0, maxLvl = 1000;
void loop() {
int i;
CircuitPlayground.mic.capture(inputData, DATA_SIZE);
// Center data on average amplitude
int32_t avg = 0;
for(i=0; i<DATA_SIZE; i++) avg += inputData[i];
avg /= DATA_SIZE;
// Scale for FFT
for(i=0; i<DATA_SIZE; i++)
inputData[i] = (inputData[i] - avg) * SCALE_FACTOR;
//run the FFT
ZeroFFT(inputData, DATA_SIZE);
// Sum inputData[] (FFT output) into pixelData[] bins.
// Note that pixelData[] has one element more than the number of
// pixels actually displayed -- this is on purpose, as the last
// element tends to be zero and not visually interesting.
memset(pixelData, 0, sizeof pixelData); // Clear pixelData[] buffer
for(i=MIN_INDEX; i<=MAX_INDEX; i++){
int ix = map(i, MIN_INDEX, MAX_INDEX, 0, NUM_PIXELS);
pixelData[ix] += inputData[i];
}
// Figure the max and min levels for the current frame
int most = pixelData[0], least = pixelData[0];
for(i=1; i<NUM_PIXELS; i++) {
if(pixelData[i] > most) most = pixelData[i];
if(pixelData[i] < least) least = pixelData[i];
}
// Always have some minimum space between, else it's too "jumpy"
if((most - least) < 15) most = least + 15;
// Dynamic max/min is sort of a fake rolling average...
maxLvl = (most > maxLvl) ?
(maxLvl * 3 + most + 1) / 4 : // Climb fast
(maxLvl * 31 + most + 15) / 32; // Fall slow
minLvl = (least < minLvl) ?
(minLvl * 3 + least + 3) / 4 : // Fall fast
(minLvl * 31 + least + 31) / 32; // Climb slow
//display the data
int n;
for(i=0; i<NUM_PIXELS; i++) {
// Scale pixel data to 0-511ish range based on dynamic levels
n = map(pixelData[i], minLvl, maxLvl, 0, 511);
if(n < 0) n = 0;
else if(n > 511) n = 511;
int r, g, b;
if(n < 256) {
// Lower half of range: interp from black to RGB pixel color
r = map(n, 0, 255, 0, reds[i]);
g = map(n, 0, 255, 0, greens[i]);
b = map(n, 0, 255, 0, blues[i]);
} else {
// Upper half of range: interp from RGB color to white
r = map(n, 256, 511, reds[i] , 255);
g = map(n, 256, 511, greens[i], 255);
b = map(n, 256, 511, blues[i] , 255);
}
CircuitPlayground.strip.setPixelColor(i, gamma8[r], gamma8[g], gamma8[b]);
}
CircuitPlayground.strip.show();
}

156
arduino-cli/libraries/Adafruit_Circuit_Playground/examples/Microphone_Demos/pretty_meter/pretty_meter.ino Normal file
View File

@@ -0,0 +1,156 @@
// Audio level visualizer for Adafruit Circuit Playground: uses the
// built-in microphone, 10x NeoPixels for display. Like the FFT example,
// the real work is done in the Circuit Playground library via the 'mic'
// object; this code is almost entirely just dressing up the output with
// a lot of averaging and scaling math and colors.
#include <Adafruit_CircuitPlayground.h>
#include <Wire.h>
#include <SPI.h>
// GLOBAL STUFF ------------------------------------------------------------
// To keep the display 'lively,' an upper and lower range of volume
// levels are dynamically adjusted based on recent audio history, and
// the graph is fit into this range.
#define FRAMES 8
uint16_t lvl[FRAMES], // Audio level for the prior #FRAMES frames
avgLo = 6, // Audio volume lower end of range
avgHi = 512, // Audio volume upper end of range
sum = 256 * FRAMES; // Sum of lvl[] array
uint8_t lvlIdx = 0; // Counter into lvl[] array
int16_t peak = 0; // Falling dot shows recent max
int8_t peakV = 0; // Velocity of peak dot
// SETUP FUNCTION - runs once ----------------------------------------------
void setup() {
CircuitPlayground.begin();
CircuitPlayground.setBrightness(128);
CircuitPlayground.clearPixels();
for(uint8_t i=0; i<FRAMES; i++) lvl[i] = 256;
}
// COLOR TABLES for animation ----------------------------------------------
const uint8_t PROGMEM
reds[] = { 0x9A, 0x75, 0x00, 0x00, 0x00, 0x65, 0x84, 0x9A, 0xAD, 0xAD },
greens[] = { 0x00, 0x00, 0x00, 0x87, 0xB1, 0x9E, 0x87, 0x66, 0x00, 0x00 },
blues[] = { 0x95, 0xD5, 0xFF, 0xC3, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
gamma8[] = { // Gamma correction improves the appearance of midrange colors
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,
0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x03,
0x03, 0x03, 0x04, 0x04, 0x04, 0x04, 0x05, 0x05, 0x05, 0x05, 0x05, 0x06,
0x06, 0x06, 0x06, 0x07, 0x07, 0x07, 0x08, 0x08, 0x08, 0x09, 0x09, 0x09,
0x0A, 0x0A, 0x0A, 0x0B, 0x0B, 0x0B, 0x0C, 0x0C, 0x0D, 0x0D, 0x0D, 0x0E,
0x0E, 0x0F, 0x0F, 0x10, 0x10, 0x11, 0x11, 0x12, 0x12, 0x13, 0x13, 0x14,
0x14, 0x15, 0x15, 0x16, 0x16, 0x17, 0x18, 0x18, 0x19, 0x19, 0x1A, 0x1B,
0x1B, 0x1C, 0x1D, 0x1D, 0x1E, 0x1F, 0x1F, 0x20, 0x21, 0x22, 0x22, 0x23,
0x24, 0x25, 0x26, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2A, 0x2B, 0x2C, 0x2D,
0x2E, 0x2F, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x3F, 0x40, 0x41, 0x42, 0x44, 0x45, 0x46,
0x47, 0x48, 0x49, 0x4B, 0x4C, 0x4D, 0x4E, 0x50, 0x51, 0x52, 0x54, 0x55,
0x56, 0x58, 0x59, 0x5A, 0x5C, 0x5D, 0x5E, 0x60, 0x61, 0x63, 0x64, 0x66,
0x67, 0x69, 0x6A, 0x6C, 0x6D, 0x6F, 0x70, 0x72, 0x73, 0x75, 0x77, 0x78,
0x7A, 0x7C, 0x7D, 0x7F, 0x81, 0x82, 0x84, 0x86, 0x88, 0x89, 0x8B, 0x8D,
0x8F, 0x91, 0x92, 0x94, 0x96, 0x98, 0x9A, 0x9C, 0x9E, 0xA0, 0xA2, 0xA4,
0xA6, 0xA8, 0xAA, 0xAC, 0xAE, 0xB0, 0xB2, 0xB4, 0xB6, 0xB8, 0xBA, 0xBC,
0xBF, 0xC1, 0xC3, 0xC5, 0xC7, 0xCA, 0xCC, 0xCE, 0xD1, 0xD3, 0xD5, 0xD7,
0xDA, 0xDC, 0xDF, 0xE1, 0xE3, 0xE6, 0xE8, 0xEB, 0xED, 0xF0, 0xF2, 0xF5,
0xF7, 0xFA, 0xFC, 0xFF };
// LOOP FUNCTION - runs over and over - does animation ---------------------
void loop() {
uint8_t i, r, g, b;
uint16_t minLvl, maxLvl, a, scaled;
int16_t p;
p = CircuitPlayground.mic.soundPressureLevel(10); // 10 ms
p = map(p, 56, 140, 0, 350); // Scale to 0-350 (may overflow)
a = constrain(p, 0, 350); // Clip to 0-350 range
sum -= lvl[lvlIdx];
lvl[lvlIdx] = a;
sum += a; // Sum of lvl[] array
minLvl = maxLvl = lvl[0]; // Calc min, max of lvl[]...
for(i=1; i<FRAMES; i++) {
if(lvl[i] < minLvl) minLvl = lvl[i];
else if(lvl[i] > maxLvl) maxLvl = lvl[i];
}
// Keep some minimum distance between min & max levels,
// else the display gets "jumpy."
if((maxLvl - minLvl) < 40) {
maxLvl = (minLvl < (512-40)) ? minLvl + 40 : 512;
}
avgLo = (avgLo * 7 + minLvl + 2) / 8; // Dampen min/max levels
avgHi = (maxLvl >= avgHi) ? // (fake rolling averages)
(avgHi * 3 + maxLvl + 1) / 4 : // Fast rise
(avgHi * 31 + maxLvl + 8) / 32; // Slow decay
a = sum / FRAMES; // Average of lvl[] array
if(a <= avgLo) { // Below min?
scaled = 0; // Bargraph = zero
} else { // Else scale to fixed-point coordspace 0-2560
scaled = 2560L * (a - avgLo) / (avgHi - avgLo);
if(scaled > 2560) scaled = 2560;
}
if(scaled >= peak) { // New peak
peakV = (scaled - peak) / 4; // Give it an upward nudge
peak = scaled;
}
uint8_t whole = scaled / 256, // Full-brightness pixels (0-10)
frac = scaled & 255; // Brightness of fractional pixel
int whole2 = peak / 256, // Index of peak pixel
frac2 = peak & 255; // Between-pixels position of peak
uint16_t a1, a2; // Scaling factors for color blending
for(i=0; i<10; i++) { // For each NeoPixel...
if(i <= whole) { // In currently-lit area?
r = pgm_read_byte(&reds[i]), // Look up pixel color
g = pgm_read_byte(&greens[i]),
b = pgm_read_byte(&blues[i]);
if(i == whole) { // Fraction pixel at top of range?
a1 = (uint16_t)frac + 1; // Fade toward black
r = (r * a1) >> 8;
g = (g * a1) >> 8;
b = (b * a1) >> 8;
}
} else {
r = g = b = 0; // In unlit area
}
// Composite the peak pixel atop whatever else is happening...
if(i == whole2) { // Peak pixel?
a1 = 256 - frac2; // Existing pixel blend factor 1-256
a2 = frac2 + 1; // Peak pixel blend factor 1-256
r = ((r * a1) + (0x84 * a2)) >> 8; // Will
g = ((g * a1) + (0x87 * a2)) >> 8; // it
b = ((b * a1) + (0xC3 * a2)) >> 8; // blend?
} else if(i == (whole2-1)) { // Just below peak pixel
a1 = frac2 + 1; // Opposite blend ratios to above,
a2 = 256 - frac2; // but same idea
r = ((r * a1) + (0x84 * a2)) >> 8;
g = ((g * a1) + (0x87 * a2)) >> 8;
b = ((b * a1) + (0xC3 * a2)) >> 8;
}
CircuitPlayground.strip.setPixelColor(i,
pgm_read_byte(&gamma8[r]),
pgm_read_byte(&gamma8[g]),
pgm_read_byte(&gamma8[b]));
}
CircuitPlayground.strip.show();
peak += peakV;
if(peak <= 0) {
peak = 0;
peakV = 0;
} else if(peakV >= -126) {
peakV -= 2;
}
if(++lvlIdx >= FRAMES) lvlIdx = 0;
}

18
arduino-cli/libraries/Adafruit_Circuit_Playground/examples/Microphone_Demos/soundPressureLevel/soundPressureLevel.ino Normal file
View File

@@ -0,0 +1,18 @@
/* This example samples the microphone for 50 milliseconds repeatedly
* and returns the max sound pressure level in dB SPL
* https://en.wikipedia.org/wiki/Sound_pressure
*
* open the serial plotter window in the arduino IDE for a nice graph
* of sound pressure level over time.
*/
#include <Adafruit_CircuitPlayground.h>
void setup() {
CircuitPlayground.begin();
Serial.begin(115200);
}
void loop() {
Serial.println(CircuitPlayground.mic.soundPressureLevel(50));
}

119
arduino-cli/libraries/Adafruit_Circuit_Playground/examples/Microphone_Demos/vu_meter/vu_meter.ino Normal file
View File

@@ -0,0 +1,119 @@
/*
LED VU meter for Circuit Playground
This is a port of the Adafruit Amplitie project to Circuit Playground.
Based on code for the adjustable sensitivity version of amplitie from:
https://learn.adafruit.com/led-ampli-tie/the-code
Hardware requirements:
- Circuit Playground
Software requirements:
- Adafruit Circuit Playground library
Written by Adafruit Industries. Distributed under the BSD license.
This paragraph must be included in any redistribution.
*/
#include <Adafruit_CircuitPlayground.h>
#include <Wire.h>
#include <SPI.h>
#define SAMPLE_WINDOW 10 // Sample window for average level
#define PEAK_HANG 24 // Time of pause before peak dot falls
#define PEAK_FALL 4 // Rate of falling peak dot
#define INPUT_FLOOR 56 // Lower range of mic sensitivity in dB SPL
#define INPUT_CEILING 110 // Upper range of mic sensitivity in db SPL
byte peak = 16; // Peak level of column; used for falling dots
unsigned int sample;
byte dotCount = 0; //Frame counter for peak dot
byte dotHangCount = 0; //Frame counter for holding peak dot
float mapf(float x, float in_min, float in_max, float out_min, float out_max);
void setup()
{
CircuitPlayground.begin();
}
void loop()
{
int numPixels = CircuitPlayground.strip.numPixels();
float peakToPeak = 0; // peak-to-peak level
unsigned int c, y;
//get peak sound pressure level over the sample window
peakToPeak = CircuitPlayground.mic.soundPressureLevel(SAMPLE_WINDOW);
//limit to the floor value
peakToPeak = max(INPUT_FLOOR, peakToPeak);
// Serial.println(peakToPeak);
//Fill the strip with rainbow gradient
for (int i=0;i<=numPixels-1;i++){
CircuitPlayground.strip.setPixelColor(i,Wheel(map(i,0,numPixels-1,30,150)));
}
c = mapf(peakToPeak, INPUT_FLOOR, INPUT_CEILING, numPixels, 0);
// Turn off pixels that are below volume threshold.
if(c < peak) {
peak = c; // Keep dot on top
dotHangCount = 0; // make the dot hang before falling
}
if (c <= numPixels) { // Fill partial column with off pixels
drawLine(numPixels, numPixels-c, CircuitPlayground.strip.Color(0, 0, 0));
}
// Set the peak dot to match the rainbow gradient
y = numPixels - peak;
CircuitPlayground.strip.setPixelColor(y-1,Wheel(map(y,0,numPixels-1,30,150)));
CircuitPlayground.strip.show();
// Frame based peak dot animation
if(dotHangCount > PEAK_HANG) { //Peak pause length
if(++dotCount >= PEAK_FALL) { //Fall rate
peak++;
dotCount = 0;
}
}
else {
dotHangCount++;
}
}
//Used to draw a line between two points of a given color
void drawLine(uint8_t from, uint8_t to, uint32_t c) {
uint8_t fromTemp;
if (from > to) {
fromTemp = from;
from = to;
to = fromTemp;
}
for(int i=from; i<=to; i++){
CircuitPlayground.strip.setPixelColor(i, c);
}
}
float mapf(float x, float in_min, float in_max, float out_min, float out_max)
{
return (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min;
}
// Input a value 0 to 255 to get a color value.
// The colours are a transition r - g - b - back to r.
uint32_t Wheel(byte WheelPos) {
if(WheelPos < 85) {
return CircuitPlayground.strip.Color(WheelPos * 3, 255 - WheelPos * 3, 0);
}
else if(WheelPos < 170) {
WheelPos -= 85;
return CircuitPlayground.strip.Color(255 - WheelPos * 3, 0, WheelPos * 3);
}
else {
WheelPos -= 170;
return CircuitPlayground.strip.Color(0, WheelPos * 3, 255 - WheelPos * 3);
}
}

64
arduino-cli/libraries/Adafruit_Circuit_Playground/examples/ScratchSensorBoard/ScratchSensorBoard.ino Normal file
View File

@@ -0,0 +1,64 @@
// example sketch to turn your circuit playground into a picoboard
// potentiometer is 'simulated' by tilting the cplay (accelerometer Z is reported)
// pin #13 red LED is lit when data is sent to Scratch!
#include <Adafruit_CircuitPlayground.h>
#define SCRATCH_DATA_REQUEST 0x01
#define SCRATCH_FW_VER 0x04
void setup() {
while (!Serial);
Serial.begin(38400);
//Serial.println("Start!");
CircuitPlayground.begin();
pinMode(13, OUTPUT);
}
void loop() {
if (!Serial.available())
return;
char c = Serial.read();
if (c != SCRATCH_DATA_REQUEST)
return;
digitalWrite(13, HIGH);
// data is a request!
sendPacket(0xF, SCRATCH_FW_VER);
sendPacket(0x0, analogRead(A0));
sendPacket(0x1, analogRead(A1));
sendPacket(0x2, analogRead(A2));
if (CircuitPlayground.leftButton() || CircuitPlayground.rightButton()) {
sendPacket(0x3, 0x0);
} else {
sendPacket(0x3, 0xFFFF);
}
sendPacket(0x4, CircuitPlayground.temperature() * 10);
sendPacket(0x5, 1023 - CircuitPlayground.lightSensor());
float s = CircuitPlayground.mic.soundPressureLevel(10);
sendPacket(0x6, s);
float z = CircuitPlayground.motionZ();
z *= -50; // reverse direction
z += 512;
sendPacket(0x7, z);
digitalWrite(13, LOW);
}
void sendPacket(uint8_t channel, uint16_t data) {
uint8_t packet0, packet1;
channel &= 0xF;
if (data >= 1024) data = 1023;
packet0 = 0x80 | (channel << 3) | ((data >> 7) & 0x7);
packet1 = data & 0x7F;
Serial.write(packet0);
//delay(1);
Serial.write(packet1);
//delay(1);
}

209
arduino-cli/libraries/Adafruit_Circuit_Playground/examples/Speech_Demos/Talk_UK_Acorn/Talk_UK_Acorn.ino Normal file
View File

@@ -0,0 +1,209 @@
// Talkie library
// Copyright 2011 Peter Knight
// This code is released under GPLv2 license.
//
// The following phrases are derived from those built into the
// Acorn Computers Speech Synthesiser add-on from 1983.
//
// A male voice with an RP English accent, voiced by Kenneth Kendall.
//
// Due to the large vocabulary, this file takes up 16Kbytes of flash.
// To save space, just copy and paste the words you need.
#include <Adafruit_CircuitPlayground.h>
#include <Wire.h>
#include <SPI.h>
const uint8_t spPAUSE1[] PROGMEM = {0x08,0x14,0xC1,0xDD,0x45,0x64,0x03,0x00,0xFC,0x4A,0x56,0x26,0x3A,0x06,0x0A};
//const uint8_t spPAUSE2[] PROGMEM = {0x08,0x14,0xC1,0xDD,0x45,0x64,0x03,0x00,0x00,0x00,0xC0,0xFF,0x4A,0x46,0x51,0x39,0x79,0x15,0x0A};
//const uint8_t spTONE1[] PROGMEM = {0x8D,0xF2,0xDE,0xDD,0xDD,0x93,0x74,0xAA,0x53,0x9D,0xEA,0x54,0xA7,0x3A,0xD5,0xA9,0x4E,0x75,0xAA,0x53,0x9D,0xEA,0x54,0xA7,0x3A,0xD5,0xA9,0x4E,0x75,0xAA,0x53,0x9D,0xEA,0x54,0xA7,0x3A,0xD5,0xA9,0x4E,0x75,0xAA,0x53,0x9D,0xEA,0x54,0xA7,0x3A,0xD5,0xA9,0x4E,0x75,0xAA,0x53,0x9D,0xFA,0x4A,0x26,0x51,0x39,0x79,0x15,0x0A};
//const uint8_t spTONE2[] PROGMEM = {0x4D,0xF1,0xDE,0xDD,0xDD,0x93,0x74,0xA5,0x2B,0x5D,0xE9,0x4A,0x57,0xBA,0xD2,0x95,0xAE,0x74,0xA5,0x2B,0x5D,0xE9,0x4A,0x57,0xBA,0xD2,0x95,0xAE,0x74,0xA5,0x2B,0x5D,0xE9,0x4A,0x57,0xBA,0xD2,0x95,0xAE,0x74,0xA5,0x2B,0x5D,0xE9,0x4A,0x57,0xBA,0xD2,0x95,0xAE,0x74,0xA5,0x2B,0x5D,0xF9,0x11,0x5A};
//const uint8_t sp_D[] PROGMEM = {0x64,0x14,0xCA,0xDD,0x45,0x64,0x83,0xEB,0xB7,0x71,0x17,0x53,0x37,0xA9,0x6F,0x5E,0xDC,0xCD,0x6D,0xFF,0x11,0x51,0x5A};
//const uint8_t sp_ED[] PROGMEM = {0x69,0x2C,0x8E,0xCA,0x33,0x16,0xB9,0xA9,0x58,0xAA,0xC8,0x6A,0x28,0x96,0x2C,0x45,0xC3,0xB3,0x31,0x99,0x84,0x72,0x77,0x11,0xD9,0xE0,0xA6,0x6D,0xDC,0xC5,0xD4,0x4D,0x1A,0x9A,0x17,0x77,0x73,0xDB,0xFF,0x71,0x39,0x49,0x5A};
//const uint8_t sp_ING[] PROGMEM = {0x2B,0x99,0xCE,0xD1,0x7D,0x22,0x8F,0x7A,0x78,0x25,0xCF,0xA9,0x3C,0xBA,0x15,0x1A,0xA5,0xAA,0x52,0x1A,0x66,0x12,0xE8,0xAE,0xD0,0x7A,0x52,0x63,0x56,0x5C,0x4E,0x9E,0x45,0x0D,0x51,0x59,0xA9,0x46,0x66,0x3B,0xB8,0xBE,0x38,0x97,0x10,0xB3,0xE3,0x07,0x04,0x38,0xA3,0xFA,0x65,0x5A};
//const uint8_t sp_S[] PROGMEM = {0x04,0xF8,0xD4,0x5D,0x00,0x8F,0xB9,0x0B,0xE0,0x4B,0x33,0x06,0x7C,0xE6,0xC5,0x80,0xCF,0xD5,0x09,0xF0,0x0D,0x0A,0x02,0xBE,0x12,0x43,0xC0,0x55,0x6C,0xFF,0x39,0x51,0x51,0x15,0x5A};
const uint8_t sp_TEEN[] PROGMEM = {0xA0,0x80,0x25,0x5C,0x14,0x70,0x5C,0x71,0x89,0x87,0x21,0xCA,0x19,0xDB,0x2D,0xE9,0x8E,0xA8,0x77,0xA2,0x8C,0x64,0x06,0x01,0xDF,0xAA,0x3C,0xEB,0xD6,0xAE,0xA4,0x20,0x3B,0xB3,0x4B,0x3F,0x12,0x48,0x5E,0xC5,0x29,0xC3,0x4C,0x48,0x76,0x5D,0xBB,0x0C,0x23,0xA2,0xC4,0x75,0xE4,0x32,0x64,0xAE,0x36,0xAE,0x49,0xC3,0x10,0x84,0xC5,0xB9,0x39,0x71,0x43,0x10,0x96,0xAB,0x96,0x44,0x0D,0x59,0x72,0x96,0x59,0x6A,0x31,0x74,0x19,0xE6,0x66,0xB6,0xFF,0x09,0x15,0x5A};
//const uint8_t sp_TH[] PROGMEM = {0x08,0x18,0x22,0x94,0x02,0x02,0xE8,0xDC,0x85,0x00,0x5D,0xB8,0x31,0x20,0x87,0x30,0x04,0x04,0x99,0xFE,0x4D,0x15,0x5A};
//const uint8_t sp_T[] PROGMEM = {0x04,0x68,0x24,0xC4,0x01,0x07,0x44,0x1A,0xA0,0x42,0xE3,0xD1,0x0C,0x67,0x68,0x36,0xB5,0x5B,0x3F,0xBC,0x91,0x47,0xCD,0x49,0xD3,0x70,0x4A,0x91,0x35,0x3B,0x2F,0xFF,0x2D,0x5A};
const uint8_t sp_Z[] PROGMEM = {0xA1,0xEB,0x38,0x38,0x3C,0x67,0x9B,0xF6,0x6B,0x12,0x97,0x6C,0x62,0x5B,0x06,0x2C,0x40,0x46,0x80,0x2F,0x58,0x11,0xF0,0x95,0x08,0x02,0xBE,0x31,0x47,0xC0,0x17,0x52,0xFF,0x06};
//const uint8_t spZERO[] PROGMEM = {0xA2,0x2B,0x20,0x2D,0xAA,0x1A,0xAA,0xB6,0x81,0xD4,0x88,0x72,0xAC,0x80,0x8F,0xC4,0x34,0x90,0xAA,0x8F,0x44,0xD5,0x43,0x4D,0xCB,0x16,0x33,0x8C,0xB6,0x44,0x23,0x9A,0xDC,0x21,0xA7,0x6B,0xAD,0x60,0x28,0x83,0x9C,0x9E,0x75,0x82,0x69,0x12,0x74,0xB2,0xD1,0xF1,0x87,0x74,0xAA,0x89,0x46,0x27,0x18,0x36,0x39,0x5C,0x17,0x9D,0x60,0xA8,0x92,0x34,0x5B,0xB4,0xA2,0xA6,0xCA,0xD2,0x7D,0xD1,0x88,0x73,0xB6,0xF2,0xA8,0x96,0x23,0xCD,0x83,0x4D,0x23,0x5D,0xB7,0x2C,0x0F,0x74,0xF3,0xC8,0xDC,0x8A,0x5C,0xA9,0xA4,0x3B,0x55,0xAB,0x73,0xE5,0xE2,0x3A,0xD7,0x6D,0x2C,0x49,0x8B,0x3D,0x6F,0x95,0xB1,0x78,0x4D,0xD7,0x78,0x94,0xA6,0x64,0xC3,0x33,0xE2,0x52,0x9A,0x92,0x8D,0x08,0xF3,0x4B,0x61,0x4A,0x31,0xDC,0xB8,0x26,0xBB,0x25,0x05,0x77,0x95,0x7A,0xF4,0x06,0x06};
//const uint8_t spHUNDRED[] PROGMEM = {0xA2,0x6D,0x76,0xD2,0x5D,0x1B,0xE9,0x62,0xFB,0xD7,0x3F,0x7E,0xB7,0x69,0x05,0x9E,0x7A,0x04,0x95,0xBB,0xAC,0x64,0xE2,0x11,0x35,0x9C,0x7C,0xE2,0x49,0x4A,0x1C,0xA5,0xC5,0x52,0xB9,0x0E,0x89,0xD5,0x56,0xA1,0x63,0x4B,0x16,0xA1,0x2D,0x21,0xCD,0x84,0x23,0x85,0xB6,0xD7,0x11,0x75,0x93,0xDD,0xDA,0x52,0x38,0xC9,0xAA,0x75,0xEB,0xB3,0xA3,0xF2,0xC8,0xC6,0xA5,0x2F,0x8E,0xCA,0x33,0x16,0x85,0xB1,0x58,0xAA,0xC8,0x6A,0x28,0xA6,0x2C,0x45,0xC3,0xB3,0x31,0x99,0x84,0x72,0x77,0x11,0xD9,0x60,0xA6,0x6D,0xDC,0xC5,0xD4,0xCD,0xFF,0x06,0x06,0x06};
//const uint8_t spTHOUSAND[] PROGMEM = {0x08,0x68,0x2A,0x14,0x03,0x04,0xE8,0x32,0x9C,0x00,0xD5,0x46,0x2C,0x3F,0xE5,0x08,0xD1,0xAA,0x7C,0xFC,0xDC,0xAB,0x5C,0xAA,0xC8,0xF1,0x4B,0xAC,0x6E,0xD5,0xC9,0xC7,0xAB,0x7E,0x2A,0x4D,0x67,0x1D,0xBF,0x86,0xCD,0x54,0x9D,0x75,0x82,0xEA,0x2F,0xD2,0x68,0xE5,0x8A,0x4A,0x1C,0x37,0xA1,0x97,0x2D,0x8A,0xCE,0xC3,0x35,0x5E,0xB6,0x24,0x29,0xA9,0xF0,0x5C,0x15,0xDA,0xCB,0x28,0xD5,0xBC,0x5D,0xE8,0x9F,0xA0,0x50,0x55,0xE5,0x71,0x68,0xDD,0xE2,0x15,0x2C,0x92,0xA5,0xB4,0x25,0x84,0x2A,0xD7,0xE5,0xD2,0x17,0x1B,0x6E,0x1C,0x9B,0xD2,0x98,0xA4,0x59,0x53,0xB6,0x0E,0x53,0x36,0xE2,0x41,0x9E,0x39,0x4C,0x59,0x99,0x39,0x5B,0x6E,0x33,0x16,0x21,0x5A,0x16,0x5A,0xCC,0x98,0xB8,0x59,0x9B,0xA7,0x46,0xA0,0x50,0xEE,0x2E,0x22,0x1B,0xDC,0xB4,0x8D,0xBB,0x98,0xBA,0x49,0x43,0xF3,0xE2,0x6E,0x6E,0xFB,0xFF,0x46};
//const uint8_t spONE[] PROGMEM = {0xA6,0x90,0x76,0xCC,0x43,0x6B,0xB9,0x42,0xD8,0x35,0x77,0xA9,0x19,0x72,0xE5,0x46,0xD2,0x62,0x56,0xCB,0xAC,0x9F,0x68,0xE1,0x4E,0x23,0x09,0x71,0x23,0x55,0x3A,0x9E,0xB8,0xC4,0x4B,0x77,0x6D,0x74,0xE3,0x93,0x54,0x7B,0xE5,0x6E,0x2D,0x4F,0xD6,0xEC,0x56,0x84,0xB5,0x3A,0x45,0x0D,0x5D,0xA1,0xD6,0xA8,0xF4,0xC5,0x58,0x84,0x78,0xEC,0x34,0x64,0x6D,0x16,0xEA,0x8D,0xC2,0x90,0x95,0x66,0xB1,0x25,0x0E,0x43,0x92,0x1A,0x43,0x9E,0x26,0x0C,0x49,0x49,0xB4,0x78,0xEA,0x34,0x16,0x1B,0xA6,0xEA,0xB1,0xC9,0x24,0x82,0xBB,0x88,0xC8,0x06,0x00,0xF8,0x26};
//const uint8_t spTWO[] PROGMEM = {0x0E,0x58,0x56,0xCB,0x00,0xD7,0xAB,0x19,0xE0,0x38,0xCB,0xE6,0x0C,0x65,0x8A,0x61,0xAD,0x86,0x9D,0xA5,0x79,0xA4,0x2D,0x1E,0x6E,0x61,0x69,0x9A,0xF6,0x79,0x04,0x85,0xA4,0x6B,0xC8,0xEF,0x16,0x17,0x94,0xA1,0xC1,0xBB,0x5B,0x5E,0x61,0x86,0x05,0x7E,0x0A,0xA5,0x0A,0x25,0xA6,0x75,0x3A,0x34,0x8E,0x5F,0xA8,0xEB,0x4B,0xD7,0x49,0xBB,0xE6,0x12,0x8F,0xDD,0xE0,0xC5,0x78,0xB2,0xBC,0x36,0x83,0x15,0xEB,0x2E,0xF2,0x48,0x0D,0x46,0x9E,0x89,0xE9,0x2B,0x31,0xC8,0x32,0x2C,0x9E,0xAB,0xFF,0x5A,0x26};
//const uint8_t spTWEN_[] PROGMEM = {0x01,0x98,0xC1,0xC2,0x00,0xCD,0x4E,0x28,0xA0,0xCC,0x8A,0xE2,0xC7,0xA2,0x6E,0x16,0x8D,0x8E,0x57,0xBC,0x4B,0xBA,0xAF,0x3E,0x7E,0x0F,0x45,0xE1,0xDA,0xF9,0x04,0xD3,0x35,0x85,0x7A,0xAB,0x13,0x75,0xE5,0xD4,0x16,0x89,0x46,0xDC,0x94,0xD0,0x51,0xD9,0x4D,0x69,0x56,0x1C,0xC5,0xA9,0x8C,0xD4,0x42,0xB9,0xBB,0x88,0x6C,0x80,0xFF,0x66};
const uint8_t spTHREE[] PROGMEM = {0x08,0xA8,0xC2,0x8C,0x02,0x04,0x68,0x2A,0xDC,0xF9,0x51,0x5B,0x96,0x79,0x8D,0x10,0xE5,0xCA,0x2E,0x9A,0x76,0x72,0xD0,0xC2,0x5C,0x25,0x21,0x23,0xCD,0x0C,0x4F,0xD4,0x22,0x7A,0x46,0x34,0x3E,0xF1,0x48,0x86,0xD2,0xB1,0xEA,0x24,0x33,0x16,0x62,0xE7,0xAA,0x55,0xAC,0xD4,0x04,0xD5,0x8D,0x47,0xB3,0x53,0x33,0xE4,0x2C,0x69,0xED,0x4E,0x81,0x30,0x53,0xA7,0xF5,0xBB,0x14,0x43,0xF4,0x92,0x36,0xEC,0x92,0x04,0xD5,0x4B,0xD2,0xB8,0xAB,0x23,0xF4,0x34,0xCE,0x63,0x19,0x57,0x73,0x84,0xAE,0x26,0x69,0x9C,0x8D,0xC0,0xAB,0x6B,0x87,0xB1,0x7B,0x94,0x99,0x8A,0xF2,0x5A,0x66};
//const uint8_t spTHIR_[] PROGMEM = {0x08,0xC8,0x22,0x19,0x01,0x4D,0x05,0x0B,0xA0,0x73,0x17,0x03,0x74,0xE1,0x96,0x9C,0x69,0x92,0x4B,0xCC,0xF1,0x08,0xA3,0x77,0x1E,0xAF,0xB2,0xC7,0x2F,0xD6,0xB4,0x2C,0x2F,0x1F,0xBF,0x9B,0xE0,0x0C,0x79,0x7C,0x82,0x6E,0x92,0x3D,0x64,0xF5,0x09,0x7B,0x70,0x09,0xD3,0x39,0x27,0xAA,0x8E,0x23,0xBD,0xAA,0xA6,0xB4,0x39,0x56,0xD3,0xAC,0x85,0x40,0xA1,0xDC,0x5D,0x44,0x36,0xFC,0x16};
//const uint8_t spFOUR[] PROGMEM = {0x08,0xA8,0xCA,0x94,0x00,0x5D,0x84,0x31,0x20,0xA9,0x0A,0x05,0x54,0x1D,0x16,0xBC,0xAA,0xDC,0xC3,0xC4,0xCE,0x0A,0x92,0xDA,0x94,0xA0,0x4D,0xC7,0x4F,0x7C,0xDA,0x0B,0x73,0x9F,0x20,0xAA,0x2D,0x73,0xCE,0x75,0x92,0x28,0xB7,0x23,0xD9,0xF7,0xCA,0x82,0xB9,0x16,0xD3,0x5C,0xA3,0x88,0x7A,0x2A,0x83,0x72,0x8D,0x2E,0xEA,0xED,0x08,0xCC,0xD3,0x86,0x68,0xB6,0xCD,0x29,0x77,0x19,0xA3,0xDE,0xD6,0xA0,0xDE,0x65,0x0C,0x66,0x5B,0x82,0x73,0x97,0x31,0xD8,0x2D,0x0B,0xEA,0x53,0xC6,0x10,0xB6,0x24,0xB8,0x77,0x99,0x42,0x98,0x4C,0xE5,0xDC,0x6E,0x0A,0xA3,0x4C,0xC3,0x17,0xFE,0x5A,0x16};
//const uint8_t spFOUR_[] PROGMEM = {0x08,0xA8,0xCA,0x94,0x00,0x5D,0x84,0x31,0x20,0xA9,0x0A,0x05,0x54,0x1D,0x16,0xBC,0xAA,0xDC,0xC3,0xC4,0xCE,0x0A,0x92,0xDA,0x94,0xA0,0x4D,0xC7,0x4F,0x7C,0xDA,0x0B,0x73,0x9F,0x20,0xAA,0x2D,0x73,0xCE,0xB5,0x92,0x60,0xAE,0xC5,0x34,0xD7,0xC8,0xA2,0x9E,0xCA,0xA0,0x5C,0x2D,0x8B,0x66,0xDB,0x9C,0x72,0xA7,0x22,0x98,0x6D,0x09,0xCE,0x6D,0x8A,0x30,0xCA,0x34,0x7C,0xE1,0xFF,0x56};
//const uint8_t spFIVE[] PROGMEM = {0x08,0xE8,0xD2,0x15,0x03,0x02,0xA8,0x3A,0x5D,0x01,0x55,0x96,0x0E,0x3F,0xA5,0x70,0xE7,0x98,0xBD,0x82,0xDC,0xDB,0x5D,0xAD,0xD6,0x0A,0x4A,0xF8,0x70,0xF5,0x86,0x27,0x2E,0xFE,0xD3,0xC5,0x6B,0x9D,0xB4,0xE9,0xAB,0x94,0x68,0x78,0xAA,0xEA,0x2F,0xC3,0xA3,0xF1,0xE9,0x6A,0xD8,0x88,0xF0,0xD9,0xA7,0x6F,0x61,0xA2,0xDC,0x66,0xAF,0xBE,0x85,0xB6,0x34,0x9B,0xB5,0xFA,0xEE,0x5D,0xD2,0x73,0xCE,0xEA,0xBB,0x33,0x8A,0xAC,0x3A,0x63,0xE8,0x56,0x29,0xAB,0xAB,0x94,0xBE,0x67,0x45,0xCB,0x9E,0x5D,0xFA,0xE6,0x04,0xB3,0x72,0x76,0xEA,0x8A,0x26,0x6F,0xCF,0x29,0xA9,0x4D,0xCA,0x34,0x3D,0x6A,0xC7,0xC1,0x0F,0xFF,0x5A,0x56};
//const uint8_t spFIF_[] PROGMEM = {0x08,0x28,0xD4,0x14,0x03,0x06,0x68,0x2A,0x74,0x79,0xCD,0x30,0x75,0xFB,0xE4,0x13,0x4C,0x1D,0xC8,0x13,0xAB,0x4E,0xD0,0x9D,0x62,0x94,0x4F,0x29,0x51,0x53,0x4A,0x9E,0x3E,0x59,0x00,0x4D,0x98,0x28,0x60,0x99,0x54,0x0D,0x20,0x50,0x28,0x77,0x17,0x91,0x0D,0xF0,0x36};
//const uint8_t spSIX[] PROGMEM = {0x04,0xF8,0x82,0x8D,0x03,0x0A,0xF8,0xCA,0xDC,0x01,0x5F,0x79,0x28,0xE0,0xEB,0x30,0x05,0x7C,0xED,0xBE,0xBC,0xAD,0x8A,0x34,0x62,0xD5,0x0D,0x4E,0xB4,0xDC,0x12,0x87,0x77,0x1A,0xD5,0x28,0x09,0x1E,0xBE,0x24,0x36,0xA8,0x15,0xCA,0xDD,0x45,0x64,0x03,0x80,0x01,0xF2,0x54,0x31,0xC0,0x57,0x15,0x02,0xF8,0xCA,0x8C,0x01,0xDF,0x58,0x12,0xE0,0x1B,0x0B,0x04,0x7C,0x2F,0x86,0x80,0xEF,0xD4,0xFE,0x5A,0x36};
//const uint8_t spSIX_[] PROGMEM = {0x04,0xF8,0x82,0x8D,0x03,0x0A,0xF8,0xCA,0xDC,0x01,0x5F,0x79,0x28,0xE0,0x6B,0xF7,0xE5,0x6D,0x55,0xA4,0x11,0xAB,0x4E,0xB4,0xDC,0x12,0x87,0x77,0x0A,0xCD,0x28,0x09,0x1E,0xBE,0x04,0xB5,0x42,0xB9,0xBB,0x88,0x6C,0x00,0x06,0xE4,0xA9,0x22,0x80,0xAF,0xCC,0x08,0xF0,0x8D,0x25,0x06,0xFE,0x76};
//const uint8_t spSEVEN[] PROGMEM = {0x08,0xF8,0x5C,0x9D,0x01,0x5F,0x78,0x08,0xE0,0x8B,0x74,0x05,0x7C,0x15,0xAE,0x81,0x61,0x57,0x6B,0x9A,0xDC,0x75,0x8E,0xD7,0x6D,0x48,0x89,0x2F,0x3E,0x41,0x0B,0xED,0x29,0x3A,0xFB,0x44,0xD5,0xA7,0x87,0xDA,0xA2,0x96,0xC4,0x50,0x11,0xCA,0xB5,0x54,0xAD,0x65,0x6A,0x88,0xB8,0x6A,0x6D,0x0E,0x63,0xC6,0xD6,0xB8,0x8D,0xB9,0x46,0x38,0xD9,0xEC,0x34,0xE5,0xAC,0x45,0xBE,0x75,0xC2,0x94,0x84,0x78,0xBB,0x37,0xB6,0x93,0x9E,0xC8,0x24,0x82,0xBB,0x88,0xC8,0x06,0x00,0x80,0xFF,0x5A,0x76};
//const uint8_t spSEVEN_[] PROGMEM = {0x08,0xF8,0x5C,0x9D,0x01,0x5F,0x78,0x08,0xE0,0x8B,0x74,0x05,0x7C,0x15,0xAE,0x81,0x61,0x57,0x6B,0x9A,0xDC,0x75,0x4E,0xD0,0x42,0x7B,0x8A,0xCE,0xBE,0x41,0x4B,0x62,0xA8,0x08,0xE5,0x5A,0xAA,0xD6,0x32,0x35,0x44,0x5C,0xB5,0x36,0x87,0x31,0x63,0x6B,0xDC,0xDB,0x34,0xE6,0x1A,0xE1,0x64,0xB3,0xC3,0x94,0xB3,0x16,0xF9,0xD6,0x71,0x53,0x12,0xE2,0xED,0xDE,0xF8,0xFF,0x0E};
//const uint8_t spEIGHT[] PROGMEM = {0x23,0x1E,0xC5,0x58,0x33,0xA7,0x9E,0xA0,0x6A,0xF1,0xAD,0x9E,0xB2,0xE2,0xEE,0x49,0xAB,0x3A,0xCA,0x2A,0x66,0x72,0x94,0xE9,0xDA,0xBB,0x0A,0xC3,0x30,0x8C,0xB5,0x1D,0x5B,0x4C,0x42,0xB9,0xBB,0x88,0x6C,0x00,0x00,0x01,0x5C,0x91,0x26,0x01,0x04,0x14,0x9F,0xFA,0x5A,0x0E};
const uint8_t spEIGH_[] PROGMEM = {0x23,0x1E,0xC5,0x58,0x33,0xA7,0x9E,0xA0,0x6A,0xF1,0xAD,0x9E,0xB2,0xE2,0xEE,0x49,0xAB,0x3A,0xCA,0x2A,0x66,0x72,0x94,0xE9,0xDA,0xBB,0x0A,0xC3,0x30,0x8C,0xB5,0x1D,0x5B,0x4C,0x42,0xB9,0xBB,0x88,0x6C,0x00,0x80,0xFF,0x4E};
//const uint8_t spNINE[] PROGMEM = {0xA1,0x4A,0x4C,0xF4,0x31,0xDD,0x85,0x32,0x71,0xB6,0xC7,0x74,0x97,0x8A,0xCC,0x54,0x1F,0xCB,0x5D,0xC9,0x33,0x35,0x7D,0xCC,0xE4,0x2D,0x6B,0x20,0xF9,0x58,0xEB,0x9F,0xA4,0xCB,0x56,0x13,0x6F,0x74,0xE2,0xAE,0x37,0x5C,0x3D,0xD1,0x89,0x9B,0xBD,0x74,0xF1,0x44,0x27,0x69,0xE6,0xDA,0xD5,0x13,0x9D,0xB4,0xAB,0x9B,0x10,0x4F,0x74,0xF2,0x29,0x67,0xC2,0x3C,0xE5,0x29,0xA7,0xE9,0xAA,0x90,0x54,0xA7,0x9A,0xBE,0x3D,0x52,0x5A,0x9D,0x66,0xC5,0x51,0x49,0x6B,0x74,0xDA,0x95,0x46,0x30,0xA2,0xD1,0xE8,0x66,0x2E,0xE4,0xCA,0xCA,0x6D,0x58,0x21,0x89,0x3A,0x23,0x87,0x21,0x73,0xB5,0x71,0x4D,0x6A,0x86,0x20,0x2C,0xCE,0xCD,0x89,0x1A,0x82,0xB0,0x5C,0xB5,0x24,0x6A,0x08,0x22,0x2A,0x2D,0x3D,0xAB,0x3E,0x4A,0xAD,0x34,0xF3,0xF5,0x5A,0x4E};
const uint8_t spNINE_[] PROGMEM = {0xA1,0x4A,0x4C,0xF4,0x31,0xDD,0x85,0x32,0x71,0xB6,0xC7,0x74,0x57,0xF2,0x4C,0x4D,0x1F,0x33,0x79,0xCB,0x1A,0x48,0x3E,0xD6,0xFA,0x27,0xE9,0xB2,0xD5,0xC4,0x1B,0x9D,0xB8,0xD9,0x4B,0x17,0x4F,0x74,0xD2,0xAE,0x6E,0x42,0x3C,0xD1,0x29,0xA7,0xE9,0xAA,0x90,0x54,0xA7,0x9A,0xBE,0x3D,0x52,0x5A,0x9D,0x66,0xC5,0x51,0x49,0x6B,0x74,0xDA,0x95,0x46,0x30,0xA2,0xD1,0xE8,0x66,0x2E,0xE4,0xCA,0xCA,0x6D,0x58,0x21,0x89,0x3A,0x23,0x87,0x21,0x73,0xB5,0x71,0x4D,0x6A,0x86,0x20,0x2C,0xCE,0xCD,0xC9,0xFF,0x41};
//const uint8_t spA[] PROGMEM = {0x27,0x5A,0x3E,0x95,0xDB,0xDB,0x9C,0x68,0xDA,0x26,0x6D,0xAF,0x75,0xA2,0xA5,0x8B,0xBD,0xBD,0xF6,0x89,0x86,0x4F,0xCA,0xF2,0xDA,0x27,0xEA,0xC1,0xB8,0x2A,0xEB,0x9C,0xB8,0x07,0xE5,0xAA,0xAA,0x72,0xD2,0x1E,0x45,0xAA,0xBA,0xCA,0x2A,0x47,0x13,0xF1,0xEA,0x29,0xAB,0x9B,0xD9,0x59,0xA6,0x96,0x8C,0x7E,0x14,0x23,0x99,0x9A,0x3D,0xC6,0x1E,0x98,0x73,0xAB,0x52,0x1B,0x47,0x12,0xF2,0xAE,0xD9,0x75,0x2C,0x63,0x4F,0xC4,0x59,0x53,0xE5,0xFF,0x39,0x25,0x79,0x61,0x41};
const uint8_t spACORN[] PROGMEM = {0x23,0x9B,0x35,0x85,0xD3,0x96,0x9C,0x64,0xD6,0x12,0x0A,0x5F,0x7C,0xA2,0x95,0xD6,0x30,0x6C,0xF1,0x89,0x56,0x18,0x86,0xCC,0x45,0x2B,0x5A,0xA1,0x11,0x2B,0x1B,0xB7,0x68,0x34,0x06,0xCF,0x9E,0x94,0xB2,0x91,0x19,0x32,0xAB,0x96,0x2A,0x84,0x72,0x77,0x11,0xD9,0x00,0x0A,0x08,0x51,0xC9,0x02,0x25,0x8F,0x6D,0x54,0x4D,0x66,0xB6,0x22,0x86,0x09,0x33,0xDA,0xD5,0xDA,0xE8,0x2A,0xD3,0xB0,0x4F,0xEB,0x92,0xA9,0xCA,0xA0,0xBC,0x6D,0x48,0xA6,0x2A,0x83,0xF2,0x95,0x29,0xD9,0xEC,0x34,0xEC,0x9B,0xE6,0x90,0xAA,0x5D,0x78,0x73,0x98,0x63,0xC9,0x74,0xD6,0x57,0x6E,0x8E,0xCB,0x42,0x6C,0x66,0xB9,0x29,0x0D,0x4B,0xE6,0x8E,0x1B,0xC6,0x94,0x2C,0x84,0xA2,0x73,0x98,0xB2,0x71,0x0B,0xF0,0xCC,0x6E,0x4E,0x3A,0xD4,0xD8,0xB3,0xAA,0xB9,0x68,0x33,0x23,0xD5,0xF2,0x25,0x51,0x15,0x31,0x41};
//const uint8_t spAFTER[] PROGMEM = {0xA5,0xC9,0x76,0xCB,0x1C,0x13,0xAF,0x3A,0xAB,0x1D,0x0B,0xEE,0xBC,0xEA,0xAC,0x6F,0x2C,0x38,0xF3,0xA9,0xB3,0xB9,0xF6,0x90,0xCC,0xA7,0xCA,0xFA,0x3A,0x82,0x33,0x9F,0x2A,0x9B,0xED,0x08,0xCE,0xBC,0xEA,0xEC,0x3B,0xD3,0xB1,0x57,0x69,0xB2,0xCD,0x6C,0xA3,0xD6,0x04,0x68,0xCE,0x44,0x02,0x14,0x40,0xA0,0x08,0xEE,0x22,0x22,0x1B,0x14,0xB0,0x8D,0x7B,0xAB,0x06,0x33,0xB3,0xD2,0x4C,0xA7,0xAA,0xD6,0x3C,0xCD,0x56,0x9D,0xBA,0x3A,0x8D,0x34,0x5D,0x35,0xDA,0xE2,0xB5,0xD2,0xEC,0x55,0x68,0x73,0xF2,0x74,0xF5,0x55,0xFF,0x39,0x49,0x41,0x71,0x41};
//const uint8_t spAGAIN[] PROGMEM = {0xA9,0x28,0x2E,0x64,0x68,0x26,0xAF,0xB2,0x26,0xF3,0xA4,0xAE,0x73,0x8A,0x1A,0xDC,0x4A,0x62,0xF6,0xC9,0xBA,0x6B,0x2A,0x93,0xC5,0xA9,0x28,0xC2,0x71,0x39,0x26,0xFB,0x2C,0x15,0xDE,0xA8,0x98,0x9B,0x93,0x91,0x4C,0x19,0x90,0x59,0x71,0x56,0x34,0x5C,0x40,0x55,0x55,0x3E,0x61,0x0B,0xC2,0x13,0x1B,0xE5,0x44,0x3D,0x89,0x56,0x74,0xDC,0x13,0x77,0xAF,0x3C,0x31,0x55,0x4E,0x32,0x7C,0x50,0x45,0x2D,0x5E,0xD9,0xF0,0x4E,0x59,0xB5,0x78,0x95,0x23,0x26,0x59,0x65,0xED,0x55,0xF7,0x24,0x94,0x55,0x65,0x47,0x3B,0xA4,0x92,0x5D,0x55,0x99,0x5D,0x1A,0xBA,0x26,0xCD,0xD9,0x4A,0x61,0x2C,0x9C,0x2A,0x33,0x9D,0x84,0x31,0x29,0x4B,0xE7,0xF0,0xEA,0xC6,0x64,0x34,0x9C,0x23,0x4D,0x18,0x8B,0xE4,0xD6,0x50,0x2F,0x61,0x48,0x5A,0xD3,0xC2,0x5D,0xFD,0x15,0x39,0x55,0x79,0x59,0x41};
//const uint8_t spAMOUNT[] PROGMEM = {0xA3,0x6E,0x6E,0xDC,0x95,0x1A,0x9E,0xB2,0xBA,0xC9,0x30,0x5A,0x74,0x8B,0x55,0xA4,0xE2,0x29,0x94,0x93,0x4B,0x91,0x9C,0x14,0x43,0xB7,0x6B,0x79,0x36,0x52,0x0A,0xD5,0xAD,0xE7,0x25,0x4D,0x46,0x5A,0x21,0xD7,0x9D,0x28,0x87,0x75,0x75,0x59,0x78,0x82,0xE2,0xAE,0x42,0xB5,0xE1,0x09,0xAA,0xBB,0x72,0xB3,0x86,0x27,0xAA,0xEE,0x3A,0xCD,0x6A,0x9D,0xBC,0xB4,0x2E,0xB7,0xAC,0x72,0xCA,0x1A,0x3A,0xD2,0x74,0xCA,0x6A,0x4A,0x2E,0x0F,0xD1,0x59,0xAD,0x2D,0x49,0x5B,0x28,0xBC,0xA4,0xB6,0x47,0xA8,0x14,0x57,0xE7,0x5B,0xD6,0x0B,0xE5,0xEE,0x22,0xB2,0x01,0x40,0x01,0x4B,0x67,0x08,0xE0,0x67,0x4F,0x04,0xB4,0x94,0xFA,0x39,0x41};
//const uint8_t spAN[] PROGMEM = {0xAB,0x6E,0xA5,0xD4,0xCC,0x27,0x9F,0x72,0xBA,0x75,0x75,0x69,0x75,0xCA,0xE9,0x36,0xD4,0xB9,0xD5,0xA9,0x86,0x5F,0x37,0xE7,0xC5,0xA7,0x1A,0x7E,0xC3,0x9D,0x1A,0x9F,0x6A,0xB8,0x75,0x0F,0x5E,0x74,0xEA,0x61,0xD7,0x3D,0x64,0xD5,0x69,0x86,0x19,0xB7,0xD0,0x55,0xAB,0xE9,0xA6,0x3D,0xC4,0x5A,0x95,0xBA,0xB1,0xC0,0x51,0x9B,0xDA,0xAA,0xAA,0x94,0x96,0x23,0x6E,0xAB,0xB2,0x54,0x59,0x4E,0x27,0xA9,0xAA,0xC6,0x4C,0xCD,0x1D,0xFD,0x11,0x39,0x41};
//const uint8_t spAND[] PROGMEM = {0x2B,0x98,0x61,0x52,0x43,0x1B,0x9F,0x60,0xF8,0x0D,0x73,0x6B,0x74,0x82,0xE1,0xCF,0xD5,0x3D,0xD6,0x09,0x86,0x3B,0x37,0xF7,0x5A,0x27,0x9C,0x76,0xCC,0xDD,0x6B,0x9D,0x68,0xB8,0xB5,0x70,0x8F,0x75,0xB2,0x1E,0xC6,0xC3,0xBD,0xD6,0xAA,0x6A,0x8B,0x08,0xCF,0x28,0xA3,0x6B,0xA9,0x2D,0x3C,0x6A,0xB5,0xBE,0xF9,0xD6,0xB4,0xA8,0x55,0x86,0x1A,0xC3,0x42,0xB2,0x56,0x1C,0x5D,0x1F,0xA5,0x45,0x87,0xC5,0x32,0x83,0x97,0xDE,0x65,0x9E,0xC8,0x0E,0x6A,0x0C,0xD2,0xAB,0x35,0x62,0xA9,0xD1,0xCB,0xCC,0x36,0x4B,0x4C,0x06,0xA1,0xDC,0x5D,0x44,0x36,0xB8,0x69,0x1B,0x77,0x31,0x75,0x93,0x86,0xE6,0xC5,0xDD,0xDC,0xF6,0xFF,0x25,0x51,0x09,0x15,0x79,0x39,0x41};
//const uint8_t spANOTHER[] PROGMEM = {0xA5,0x2E,0x29,0x3C,0xD4,0x27,0xAD,0xBA,0xA6,0xF4,0x94,0xA8,0x75,0xCB,0x55,0xD4,0xE8,0xE1,0x12,0x75,0x5A,0x59,0x0C,0x66,0x73,0x3B,0x29,0x65,0xB3,0x68,0xC7,0x65,0x77,0x34,0x5D,0x96,0x86,0x4A,0xAB,0x55,0x36,0x3B,0x11,0xAA,0xAD,0x6E,0x79,0xCA,0xA6,0x26,0xC3,0xB5,0xD5,0x2D,0x53,0x9B,0x75,0x59,0xB2,0x4C,0x72,0x5D,0x52,0xAE,0xA1,0x96,0xB8,0xB4,0x55,0xB6,0xA6,0x4A,0x93,0x51,0x67,0x97,0x5E,0x54,0x57,0x57,0x95,0x83,0x87,0xCB,0x54,0x5D,0x55,0x8E,0x5E,0x2A,0x13,0x77,0x55,0x39,0x79,0x9A,0x54,0x9D,0x52,0xD7,0x10,0x59,0xA2,0x73,0xFE,0x25,0x51,0x75,0x65,0x39,0x41};
//const uint8_t spANSWER[] PROGMEM = {0x23,0xC8,0xF6,0xDA,0x43,0x3C,0x1E,0x3F,0x9B,0xCD,0x10,0xC9,0x78,0xFC,0x6C,0xB6,0x5C,0x35,0xE3,0x09,0xB2,0xDB,0x72,0xB1,0x94,0x27,0xC8,0xFE,0xCA,0xD4,0x53,0x9E,0xA8,0xC4,0xF7,0xA4,0x48,0x34,0xA2,0xA2,0x56,0x13,0xB4,0x69,0x8B,0x0B,0x4F,0x69,0xF0,0xB5,0x39,0x51,0x71,0x54,0x1A,0x0D,0x9B,0x04,0x01,0x1D,0xB8,0x11,0xE0,0x4B,0x51,0x09,0x58,0x40,0x03,0xA5,0x6A,0xA2,0x24,0x31,0x66,0xB7,0xBA,0xBA,0x30,0xE7,0xB8,0xBD,0xFA,0x1A,0x3D,0x4C,0x6A,0xF1,0x1A,0x9A,0xCB,0x48,0xE3,0xD5,0x6B,0xAC,0xBE,0x22,0x95,0x57,0xB7,0xB1,0x64,0x4F,0xE3,0x9C,0x93,0xA6,0x92,0x9A,0xCD,0x22,0xD6,0xFF,0x4D,0x39,0x41};
//const uint8_t spANY[] PROGMEM = {0xA3,0xEA,0xC1,0x59,0x33,0x17,0x9F,0x6A,0xF9,0x52,0x0E,0x5B,0x7D,0x8A,0xE5,0xC6,0x28,0x6C,0xF3,0x29,0xA6,0x1B,0xE5,0xF4,0xCD,0xA7,0xDC,0x66,0x94,0x23,0x56,0x8D,0xB2,0x4B,0x85,0x31,0x8B,0x32,0xAB,0x55,0x6D,0xDB,0x44,0xE6,0x0B,0x57,0x75,0xEC,0x30,0x44,0xAE,0x5A,0xD5,0xB6,0x83,0xD0,0xD5,0x70,0x55,0xCB,0x35,0x70,0xE5,0xC2,0x55,0x4D,0x3F,0xC0,0x55,0x33,0x47,0x35,0x7C,0x80,0x55,0x95,0x0A,0x6D,0x4F,0x82,0x15,0x13,0xE4,0xFF,0x51,0x19,0x21,0x41,0x19,0x49,0x41,0x35,0x41};
//const uint8_t spAVAILABLE[] PROGMEM = {0x23,0x6F,0xB6,0x2C,0x8D,0x57,0x9D,0x62,0xE8,0x89,0x08,0xDA,0x7C,0xB2,0xAE,0xC6,0xDD,0xF9,0xD5,0xC8,0x9B,0x2C,0x0D,0xA3,0x57,0xA9,0xAA,0x3C,0xD5,0x95,0x5A,0x85,0xBA,0x53,0x13,0x73,0xF6,0x16,0xEA,0xCE,0xCD,0xC4,0x44,0x5D,0xCB,0xAA,0x36,0x49,0xE5,0x36,0x2B,0xEA,0xC6,0x38,0x53,0x56,0x9D,0x68,0xB8,0x64,0x2F,0x69,0x75,0xA2,0xE1,0x93,0xA2,0x6C,0xF1,0x89,0x46,0x08,0x8A,0xF2,0x59,0x27,0x9A,0xAE,0xC0,0x32,0x5A,0xAD,0x78,0x18,0x25,0x8F,0x5C,0xDC,0xD2,0xC2,0x4B,0x94,0x6B,0x53,0xCF,0x56,0x9E,0x83,0x27,0xEA,0xB4,0x2A,0x45,0x4A,0x4D,0x36,0x39,0x19,0x95,0x81,0xA6,0xB9,0x46,0x63,0x36,0x25,0xEE,0xE6,0xE6,0xB1,0x4B,0x1B,0xC3,0xBA,0xA8,0x2E,0x4E,0x7D,0xC8,0x15,0xAA,0xF1,0x2A,0x0D,0x21,0x75,0xA8,0x59,0x6B,0x3F,0xF9,0xD9,0x4C,0x3E,0x65,0x06,0x65,0xEB,0xFF,0x21};
//const uint8_t spB[] PROGMEM = {0xA9,0xB2,0x56,0x3D,0xBD,0x2B,0x95,0xB8,0x28,0xC1,0x9D,0xAD,0xD5,0xBC,0x69,0x1C,0xA2,0xAF,0x51,0xF3,0x97,0x0D,0xB0,0xBE,0xC6,0x3B,0x5C,0xD1,0xF2,0x06,0x32,0x1B,0x7B,0x67,0x2B,0x5F,0xD1,0x80,0x66,0x62,0x8F,0x6A,0x3B,0x26,0x9E,0x89,0xDD,0x9A,0x1D,0x85,0x70,0xA7,0x4E,0x1A,0x56,0x60,0x94,0xEB,0x3A,0x69,0x9C,0x8E,0xC8,0xBF,0xE2,0xB8,0xB1,0x6B,0xB0,0x9D,0x72,0xEC,0xC6,0x6E,0xC1,0x67,0xD3,0x8E,0x1B,0x47,0x04,0xE9,0xA9,0x28,0xFF,0x11,0x41,0x21};
//const uint8_t spBAD[] PROGMEM = {0x08,0x00,0x71,0xC2,0x98,0xD1,0xA7,0xA9,0x5A,0xAA,0x13,0x14,0x15,0x1C,0x69,0xAD,0x4F,0x30,0xEC,0x88,0xAB,0x2F,0x3A,0xC1,0xB0,0x23,0x6E,0x51,0xEB,0x04,0xC3,0x9E,0x84,0x44,0xA3,0x13,0xF5,0xD0,0x16,0x16,0xB1,0x4E,0xDC,0x63,0x7B,0xA8,0xC7,0x3A,0x59,0x8F,0xED,0xA9,0x51,0xEB,0x54,0xAD,0x66,0x84,0x45,0xE5,0x55,0xB7,0x9C,0x91,0xE6,0xB5,0x57,0xDB,0x62,0x78,0x99,0xD7,0x6E,0x7D,0xCD,0xE6,0xEE,0x59,0xA5,0xF5,0x25,0xBA,0x85,0x57,0x99,0xD2,0x97,0xA0,0x11,0xD6,0x75,0xC2,0x98,0xBC,0x66,0xD6,0x46,0xD6,0x23,0x19,0x85,0x72,0x77,0x11,0xD9,0xE0,0xFA,0x6D,0xDC,0xC5,0xD4,0x4D,0xEA,0x9B,0x17,0x77,0x73,0xDB,0xFF,0x39,0x51,0x51,0x75,0x15,0x51,0x21};
//const uint8_t spBETWEEN[] PROGMEM = {0xAC,0x55,0xAC,0x3C,0x22,0x63,0xB7,0xBA,0x5A,0x67,0x33,0xED,0xB4,0xF2,0x6A,0x99,0x33,0x6A,0x51,0xC8,0x9B,0x65,0xB1,0xC8,0x44,0xA4,0x10,0xCA,0xDD,0x45,0x64,0x03,0x04,0x60,0x7A,0xB3,0x00,0xCC,0xD0,0x6E,0x80,0x52,0x36,0x8A,0x9B,0x47,0xBB,0x32,0xC7,0x5A,0x6E,0x36,0x29,0x6E,0xB6,0xFA,0x38,0x4D,0x1B,0x65,0xF8,0x9A,0xE3,0x8D,0xA4,0x10,0xD5,0x8B,0x57,0x36,0x13,0x61,0xF4,0xC4,0x1E,0x45,0x77,0x60,0x33,0xED,0xA8,0xB5,0x55,0x61,0xEC,0x94,0xEA,0xD1,0x4F,0x47,0x18,0x33,0x71,0xDA,0x30,0x0C,0x51,0xCE,0xC4,0x6E,0x63,0x37,0x24,0x91,0x95,0xB8,0x8C,0x85,0xBB,0x25,0x87,0xDA,0x3A,0xFE,0x09,0x15,0x79,0x21};
//const uint8_t spBOTH[] PROGMEM = {0x85,0xD5,0xA6,0x32,0xC5,0x16,0x8D,0xA2,0x58,0xCD,0xD4,0xB8,0xBB,0x8B,0x53,0x56,0x6B,0x5E,0xA6,0x8F,0x6F,0xB9,0xAA,0x6C,0x2C,0xCA,0xFC,0xCE,0xAA,0x8A,0x51,0x6F,0xD5,0x3B,0xB3,0x6A,0x55,0x50,0xAD,0x2D,0x39,0xA9,0xD5,0x51,0x7A,0x64,0x46,0x2A,0x01,0x34,0x65,0x22,0x01,0x09,0x48,0x80,0x03,0x0C,0x28,0xDC,0x94,0x01,0x41,0x95,0xFE,0x39,0x79,0x15,0x15,0x55,0x21};
//const uint8_t spBUTTON[] PROGMEM = {0xA9,0x69,0xCE,0xC2,0x45,0x14,0x9F,0x28,0xFB,0xB5,0x14,0xDD,0x78,0xA2,0x5C,0x26,0x52,0x6D,0xD1,0x8A,0x4A,0xEE,0x2C,0xB7,0x45,0x23,0x2A,0x39,0x23,0x35,0x1A,0x92,0x58,0x28,0x77,0x17,0x91,0x0D,0x00,0xA8,0x28,0x2E,0xAA,0xD0,0x9D,0xA4,0xAA,0xE8,0x8E,0x26,0x75,0x56,0x9A,0x68,0x34,0x83,0xD3,0x55,0x1A,0xB2,0x95,0x54,0x71,0xCF,0x61,0xCE,0x4A,0x22,0x38,0xBD,0x98,0xA5,0x70,0xD7,0x10,0x4F,0x22,0x96,0xA2,0x4C,0x83,0x3D,0xEB,0xFF,0x61};
//const uint8_t spC[] PROGMEM = {0x0C,0xF8,0x8A,0x45,0x02,0x1A,0x50,0xC0,0xE7,0x11,0x16,0x30,0xC0,0xE3,0x69,0xCD,0x5D,0x8A,0xC9,0xB3,0x6D,0x2F,0x6F,0x39,0x03,0xE9,0xA9,0xBD,0xFC,0xE5,0x14,0x6C,0xB6,0xF1,0x0E,0x57,0xB2,0x9D,0x82,0xCC,0xD6,0x9E,0xD9,0x28,0x77,0x10,0x94,0x9E,0xDA,0xAD,0xD9,0x49,0x91,0x76,0xE2,0x94,0x7E,0x25,0x46,0xDE,0x89,0x53,0x86,0x15,0x08,0xE5,0xBA,0x4E,0x1D,0xD3,0x38,0x1D,0x92,0x7F,0xC5,0x89,0x63,0x1C,0xDD,0x38,0x3C,0x48,0x4F,0x45,0x71,0x43,0x33,0xA8,0xDB,0x63,0xFB,0xFF,0x51,0x15,0x15,0x51,0x65,0x65,0x41,0x61};
//const uint8_t spCASSETTE[] PROGMEM = {0x06,0x68,0x86,0x65,0x84,0x55,0x8B,0x74,0xB9,0xAD,0x13,0xB5,0xEC,0x1A,0x16,0x8D,0x4F,0xD6,0xC3,0x68,0x98,0xB4,0x3A,0x79,0x77,0xA5,0x69,0xB6,0xBA,0x14,0xD5,0xAB,0xB9,0x75,0x29,0x04,0x2C,0xA4,0x86,0x80,0x83,0x23,0x10,0x70,0x99,0x3B,0x03,0x3E,0xCB,0x64,0xC0,0x67,0x91,0x02,0xB8,0x2A,0x42,0x01,0x4B,0x95,0x2D,0xB7,0x59,0x97,0xD2,0x58,0x7C,0xA2,0xEE,0x52,0xC2,0x7D,0xF1,0xC9,0xBA,0x2F,0x09,0xB7,0xD5,0xA7,0xEA,0x3E,0x25,0xDC,0x57,0xA7,0xA6,0x19,0x93,0x8A,0x98,0x89,0x1A,0xA1,0xDC,0x5D,0x44,0x36,0x80,0x00,0xAE,0x48,0x93,0x00,0x02,0xAA,0x6F,0xF8,0x25,0x51,0x15,0x61,0x41,0x25,0x41,0x09,0x61};
//const uint8_t spCHARACTER[] PROGMEM = {0x0A,0x68,0x46,0x44,0x01,0x4D,0x91,0xB6,0x60,0x44,0xC1,0x10,0x8F,0xB3,0xDC,0xEE,0xCD,0xCA,0x42,0xCE,0x71,0x5A,0x2E,0x2B,0xCD,0x58,0xC7,0x6B,0x7E,0xA3,0xD5,0x63,0x9D,0xA0,0x85,0xCE,0xB4,0x48,0x74,0xA2,0x96,0xA2,0xCD,0x2D,0xD5,0xC8,0x6A,0xD1,0xC2,0x8A,0xCC,0x23,0x6B,0x45,0x12,0x23,0x33,0xAD,0xBC,0x57,0x35,0xB5,0xCC,0x35,0x8A,0x9E,0x94,0xA2,0xAA,0x31,0x03,0x82,0x62,0x43,0xA0,0x50,0xEE,0x2E,0x22,0x1B,0x00,0x40,0x00,0xDB,0xA4,0x96,0xA2,0x98,0xE0,0xD2,0xAC,0xD4,0xFA,0xEA,0xC3,0x42,0xA2,0x55,0x5A,0x72,0x33,0x4D,0xEF,0xDA,0x6E,0x2D,0x35,0xC2,0x24,0x2B,0xDB,0xF5,0xFF,0x51,0x15,0x51,0x19,0x05,0x59,0x79,0x61};
//const uint8_t spCOMPLETE[] PROGMEM = {0x06,0x28,0x29,0x68,0x44,0x29,0xAA,0xA6,0xD6,0xEC,0x15,0xE7,0x9C,0xE6,0x64,0xAB,0x5A,0x9E,0xBD,0x96,0x41,0xB6,0x0D,0x79,0xB2,0xDC,0x48,0xDD,0xCD,0x94,0x49,0x53,0x15,0x7B,0x12,0x54,0x09,0xE5,0xEE,0x22,0xB2,0x01,0x14,0x50,0x7C,0x78,0x00,0x9A,0x61,0x4B,0xC1,0xE2,0x93,0xE8,0x21,0xA7,0x07,0xCB,0x1C,0xDC,0xC1,0xAB,0xEA,0x2C,0x77,0x06,0x03,0xDB,0x5E,0x3C,0xA2,0xA5,0x05,0xFC,0xBA,0x76,0x8B,0x57,0x31,0xE0,0xEE,0xDA,0x24,0x16,0xCA,0xDD,0x45,0x64,0x03,0x00,0x28,0xE0,0x8A,0x34,0x0D,0x20,0xA0,0xFA,0x86,0xFF,0x25,0x51,0x15,0x55,0x05,0x59,0x79,0x61};
const uint8_t spCOMPUTER[] PROGMEM = {0x06,0x28,0x29,0x68,0x44,0x29,0xAA,0xA6,0xD6,0xEC,0x15,0xE7,0x9C,0xE6,0x64,0xAB,0x5A,0x9E,0xBD,0x96,0x41,0xB6,0x0D,0x79,0xB2,0xDC,0x48,0xDD,0xCD,0x94,0x49,0x53,0x15,0x7B,0x12,0x54,0x09,0xE5,0xEE,0x22,0xB2,0x81,0x01,0xD5,0x86,0x97,0xA0,0x47,0x22,0xCF,0xAA,0xDC,0xFC,0x26,0x8D,0xB2,0x7D,0xF5,0xF2,0x33,0x6D,0xCD,0xB0,0xD7,0x3B,0xE8,0x11,0x2A,0x84,0x72,0x77,0x11,0xD9,0xA0,0x80,0x6D,0x35,0x1D,0xB0,0x89,0xFB,0x48,0x8A,0x35,0x75,0xED,0xDA,0xAB,0xAA,0xDE,0x2D,0x24,0x57,0xAF,0xB6,0xF9,0xB6,0x14,0x5D,0x5D,0xA6,0x52,0xD3,0x5C,0x73,0xB6,0xDB,0xB3,0x4F,0x4F,0x89,0x31,0xFF,0x15,0x61,0x51,0x25,0x25,0x79,0x61};
//const uint8_t spCORRECT[] PROGMEM = {0x0A,0x28,0x71,0xD9,0x00,0xB9,0x39,0x97,0xA8,0xD4,0x66,0xF3,0x68,0x32,0xA2,0x94,0xCD,0x35,0x62,0xF2,0x4A,0x4A,0xD1,0x22,0xB7,0xC5,0x2D,0xCD,0x87,0x93,0xD3,0x5A,0xA7,0x34,0x2E,0x0A,0x75,0xEB,0x12,0xD2,0x30,0x31,0x2C,0xBC,0x73,0x48,0xC2,0xC0,0x0C,0x8B,0x4E,0x25,0x4A,0x13,0x4B,0xD2,0x5A,0x8F,0xA0,0x14,0x4E,0x2E,0x5F,0x7C,0xA2,0x56,0x2C,0x34,0x6C,0xF1,0x89,0x5B,0x90,0xF0,0xC8,0x29,0x27,0xEB,0x49,0x2D,0x3D,0xEA,0xB4,0xA2,0x25,0xD6,0xCE,0x9A,0x8C,0x0A,0xA1,0xDC,0x5D,0x44,0x36,0x00,0x00,0x00,0x28,0xE0,0x8A,0x34,0x0D,0x20,0xA0,0x9A,0x86,0xFF,0x11};
//const uint8_t spD[] PROGMEM = {0x0C,0xB8,0xD0,0x64,0x64,0x0F,0x15,0x8B,0x5A,0xE8,0x15,0x6C,0xE1,0xA0,0x39,0x8B,0x8E,0xFB,0x4C,0x00,0x57,0x2F,0x3A,0xEE,0x75,0x09,0x5C,0x33,0xEB,0xF8,0xC7,0x3A,0x70,0xEF,0xEC,0x13,0x6D,0xEB,0x20,0xB3,0xB5,0x46,0x32,0x2D,0x43,0xF6,0xC4,0x1E,0xC5,0x8A,0x0A,0x3A,0x13,0xBB,0x55,0xDB,0x3B,0x70,0x4F,0xE5,0xD6,0xEC,0x68,0xC0,0xBD,0x95,0x7B,0x97,0x87,0x38,0xFD,0x41,0x15,0x41,0x11};
//const uint8_t spDATA[] PROGMEM = {0x65,0x3C,0x3A,0x32,0x23,0x64,0xAF,0x78,0x10,0xA7,0xAC,0x6C,0x78,0xA2,0xA1,0x8D,0x3A,0x6B,0xF1,0x89,0x66,0x4C,0xF2,0xB0,0xC6,0x27,0x9A,0xA1,0x49,0xC3,0x5A,0x9D,0x68,0xC6,0x00,0xAB,0x5C,0x34,0xA2,0x59,0x03,0xD4,0x6B,0x56,0x89,0x47,0x64,0x8C,0xAA,0x5A,0x24,0x16,0xCA,0xDD,0x45,0x64,0x83,0x03,0x36,0x4B,0x33,0xC0,0xC6,0xA1,0xA5,0x28,0x4A,0xBD,0xA5,0xA3,0xAC,0xAA,0x79,0xB3,0xD0,0x9C,0xB2,0xA6,0x16,0xD2,0x53,0xF4,0x71,0x5B,0x4A,0x1E,0x75,0xF3,0x5B,0x61,0xAD,0xB9,0x3D,0xC5,0x2E,0xFD,0x51,0x15,0x41,0x11};
//const uint8_t spDATE[] PROGMEM = {0xAC,0xDD,0xD0,0x3D,0x2D,0x6D,0x8F,0x74,0xB1,0x24,0xB5,0x48,0x7C,0xA2,0x2E,0x8D,0x2B,0xB3,0xF6,0x09,0x87,0x36,0xAE,0xAE,0xC5,0x27,0xA8,0x5A,0x7C,0xAB,0xA7,0xAC,0xB8,0x7B,0xD2,0xAA,0x8E,0xB2,0x8A,0x99,0x1C,0x65,0xBA,0xF6,0xAE,0xC2,0x30,0x0C,0x63,0x6D,0xC7,0x16,0x93,0x50,0xEE,0x2E,0x22,0x1B,0x00,0x40,0x00,0x57,0xA4,0x49,0x00,0x01,0xC5,0xA7,0xFE,0x79,0x11};
//const uint8_t spDO[] PROGMEM = {0x0C,0x98,0x92,0x79,0x04,0x53,0x32,0x57,0x47,0xA7,0x19,0x8C,0xA0,0x90,0x74,0x0D,0xF9,0xDD,0xE2,0x82,0x32,0x34,0x78,0x77,0xCB,0x2B,0xCC,0xB0,0xC0,0x4F,0xA1,0x54,0xA1,0xC4,0xB4,0x4E,0x87,0xC6,0xF1,0x0B,0x75,0x7D,0xE9,0x3A,0x69,0xD7,0x5C,0xE2,0xB1,0x1B,0xBC,0x18,0x4F,0x96,0xD7,0x66,0xB0,0x62,0xDD,0x45,0x1E,0xFD,0x25,0x41,0x19,0x19,0x79,0x11};
//const uint8_t spDOLLAR[] PROGMEM = {0xA4,0xD2,0x34,0xA3,0x2B,0x1D,0x8D,0xA0,0x11,0xF7,0xB0,0x4A,0x7D,0x82,0xA2,0x5B,0xCD,0xBC,0xD3,0x09,0x72,0x98,0x70,0xD5,0x8E,0x27,0xC8,0xE1,0xD2,0xD5,0x32,0x9D,0x30,0x87,0x2D,0x57,0xCB,0x74,0xA2,0x14,0x2F,0x5D,0x3C,0xD3,0x8A,0xB3,0xAB,0x76,0x8A,0x4C,0x2D,0xCD,0x26,0x32,0xA0,0x96,0xD6,0x7C,0xB4,0x39,0x76,0x18,0x77,0xCB,0x36,0xE5,0x9C,0xA1,0x3C,0x95,0xD3,0x94,0x5B,0x99,0x69,0x55,0x8E,0x8B,0x5D,0xFE,0x15,0x39,0x79,0x11};
//const uint8_t spDONT[] PROGMEM = {0x61,0x3C,0xD5,0x4B,0x23,0xEC,0xAE,0xA2,0x0B,0x67,0xF3,0xE8,0x74,0x8A,0x61,0x52,0x2C,0x74,0xF7,0x29,0xBB,0x2E,0xB3,0x94,0x3D,0xA7,0xEC,0x3A,0xCD,0x4B,0xF6,0x9C,0xB2,0x9B,0x54,0x4B,0xD9,0x7D,0xCA,0xAE,0x43,0x3D,0xB9,0xF7,0xA9,0x9A,0x76,0x4B,0x13,0xDF,0xAD,0xCA,0x56,0x3D,0xC8,0x3C,0xA7,0x2A,0x09,0x91,0x55,0x4B,0x1A,0xEA,0xAC,0xB0,0x4B,0xC2,0x0D,0x6A,0x44,0x70,0x17,0x11,0xD9,0x20,0x80,0x2D,0xD2,0x24,0x80,0x80,0xE2,0x53,0xFF,0x39,0x75,0x79,0x11};
//const uint8_t spDOWN[] PROGMEM = {0x08,0x48,0x60,0x82,0xD4,0x8E,0xBA,0x57,0xB4,0xED,0xE6,0x74,0x92,0x6A,0x1E,0x8D,0x4F,0xD4,0x54,0x6A,0x8A,0xB7,0x3A,0x51,0x13,0x2B,0xA5,0xB1,0xE8,0x44,0x55,0x9F,0x95,0x58,0xAB,0x13,0x55,0xFB,0x9E,0xEA,0xAD,0x4E,0x5C,0xED,0x47,0xA9,0x37,0x3C,0x69,0x35,0x1F,0x69,0xD1,0xF0,0xE4,0xD5,0x5D,0xA4,0xF9,0xAA,0x53,0x96,0xB0,0x51,0x66,0x8B,0x4E,0x5D,0xDC,0x7A,0x86,0xAE,0x1C,0x43,0x29,0x6D,0x29,0x76,0x2B,0x8D,0x29,0xA4,0x78,0xE4,0xAC,0x30,0xC5,0xEC,0xE2,0x51,0x93,0xDC,0x14,0x93,0xAB,0xD8,0x34,0x72,0x53,0x32,0x96,0xA2,0x99,0xD9,0x8D,0x49,0xC8,0xB8,0x86,0x67,0x33,0x44,0x21,0x53,0x16,0x5A,0xCC,0xE0,0x65,0x54,0x69,0xBA,0x36,0x7D,0xE4,0xDA,0xA5,0xA3,0xF8,0xFF,0x51};
//const uint8_t spE[] PROGMEM = {0x21,0x3A,0x4A,0x41,0x77,0x63,0xCF,0x68,0x27,0x3B,0x1D,0xC5,0x6A,0x4A,0x38,0x55,0x7B,0x16,0xB3,0x2E,0xED,0xAA,0x42,0x78,0x15,0xB5,0xB6,0xA5,0x9F,0x19,0xD9,0x2F,0xE3,0xD4,0x3E,0x0F,0x69,0x98,0x01,0xD9,0x2F,0xE3,0xE4,0xE1,0xFF,0x09,0x61,0x41,0x51};
//const uint8_t spEACH[] PROGMEM = {0xA5,0x58,0x36,0x91,0xB6,0x1B,0xED,0x62,0x15,0xD3,0x05,0xF0,0xD6,0xC2,0x55,0xCE,0xE0,0x20,0x5B,0x0B,0x77,0xB9,0xCA,0x11,0x05,0x7C,0xBA,0x62,0xA9,0x7A,0x40,0xEE,0xAE,0x8A,0xA8,0x13,0xC1,0x5D,0x44,0x64,0x03,0x28,0x60,0x67,0x17,0x07,0xEC,0xD6,0x19,0x80,0x5D,0x3A,0x03,0xB0,0xFA,0xA6,0x05,0x14,0xB0,0xEA,0xB8,0x00,0xE6,0x6C,0x27,0xC0,0x4C,0x26,0xFF,0x39,0x51,0x35,0x51,0x19,0x51};
//const uint8_t spELEVEN[] PROGMEM = {0x25,0xED,0x5A,0x29,0x36,0xAB,0x8C,0xAC,0x1B,0xC3,0xD8,0x5A,0xB8,0xE2,0x41,0x5C,0xEC,0x32,0xD3,0x48,0x07,0x56,0xB5,0xB2,0x34,0x2D,0xA9,0xC0,0xC3,0x3A,0x56,0xB5,0xA4,0x80,0x08,0xED,0x6C,0xD5,0xE2,0x0E,0xDC,0xB9,0xA3,0xE5,0x09,0x06,0x77,0xEE,0xB4,0x45,0x27,0x1A,0xA2,0x34,0xD2,0x16,0x9D,0xA8,0xCB,0xB4,0x72,0x7F,0x74,0x92,0xAE,0xC7,0xDD,0x78,0x51,0xCB,0x4B,0x2C,0x0F,0x96,0xDA,0xA1,0x69,0xAA,0x2C,0x84,0x63,0xBB,0xB9,0xF1,0x52,0x57,0x4E,0x9C,0xC6,0x5C,0x23,0x9C,0x6C,0x76,0x98,0x72,0xD6,0x22,0xDF,0x3A,0x66,0x4A,0x42,0xBC,0xDD,0x1B,0xDB,0x09,0x8D,0x22,0xB8,0x8B,0x88,0x6C,0x00,0x80,0xFF,0x11,0x51,0x71,0x41,0x71,0x39,0x51};
//const uint8_t spENGAGED[] PROGMEM = {0xA3,0x18,0x41,0xD9,0xAB,0xE6,0x9C,0x7C,0x86,0x64,0x89,0x98,0x7D,0xD2,0x29,0x82,0xB4,0xA3,0x56,0x49,0x93,0x92,0x28,0x4A,0x77,0x35,0x4B,0x59,0x56,0xD8,0x45,0xAD,0x25,0x66,0x28,0x13,0xC1,0x5D,0x44,0x64,0x23,0x20,0x28,0xEA,0x96,0x0F,0x2D,0xE0,0x55,0xB3,0x56,0x3C,0xA4,0x63,0x4E,0xCD,0xBA,0xD1,0x89,0x7B,0x30,0xAA,0x8C,0x3A,0x27,0xE9,0x91,0xB5,0xA2,0xAA,0x9E,0xB4,0x45,0xF2,0x8C,0xAE,0x7B,0x8A,0x9E,0xC8,0x32,0xBB,0xEA,0xA9,0x7A,0x65,0xC9,0xE8,0xAA,0xAB,0x9D,0x39,0x49,0x3A,0x17,0x8F,0x61,0x24,0x43,0x9D,0x7C,0x5C,0xA6,0xEE,0x49,0x6A,0x7A,0x52,0x1A,0x47,0x61,0x8C,0xEA,0x39,0x64,0x10,0xC1,0xDD,0x45,0x64,0x03,0x02,0x40,0xEC,0x0A,0xCF,0xAC,0xEE,0x12,0x2A,0x45,0x00,0x7B,0x99,0x4A,0x40,0x01,0xA7,0x94,0x09,0x60,0x47,0x13,0x04,0x8A,0xE0,0x2E,0x22,0xB2,0xC1,0x4D,0xD7,0xB8,0x8B,0xA9,0x9B,0x34,0x0C,0x23,0xEE,0xE6,0xB6,0xFF,0x25,0x51,0x15,0x39,0x51};
//const uint8_t spENTER[] PROGMEM = {0x23,0x98,0x29,0x45,0xD2,0x9A,0x9C,0x60,0xF9,0x16,0x49,0x6D,0x7C,0x83,0x13,0x6C,0x9D,0xAC,0x65,0x8D,0x57,0xD8,0xA4,0x72,0x79,0xD4,0x6E,0x51,0x91,0x22,0xA7,0x9E,0xA4,0xC4,0x99,0xAB,0x3E,0x55,0x3C,0x97,0x44,0xC1,0xF1,0x12,0x76,0x50,0x23,0x94,0xBB,0x8B,0xC8,0x06,0x03,0x7C,0x11,0xA1,0x80,0x4D,0x23,0x5A,0x96,0x9D,0x79,0x7A,0x57,0x19,0x7D,0xF5,0xEE,0x6E,0xBE,0x78,0x8C,0xD5,0xA5,0x85,0xD9,0xEA,0x36,0x95,0x98,0xE6,0x1A,0xB3,0xCA,0x5C,0x62,0x98,0x5B,0xCE,0xCC,0xF3,0xFF,0x25,0x79,0x25,0x25,0x51};
//const uint8_t spERROR[] PROGMEM = {0x2B,0x98,0xB1,0xC5,0x9C,0x1B,0x1F,0x7F,0xBA,0x96,0x48,0xAE,0x75,0x82,0x1E,0xCA,0xCA,0xA4,0xD1,0x09,0x6B,0xB3,0x12,0xF3,0xC6,0x23,0x2E,0x5B,0x82,0x4B,0x33,0x8F,0xB4,0x2C,0x29,0x2A,0x6F,0xD5,0xB3,0x51,0xD7,0x66,0x23,0x2E,0x8B,0x4E,0x5F,0x4B,0x57,0xA8,0x2C,0x3E,0x43,0x8D,0x55,0xA9,0xB2,0x7A,0x0C,0x25,0x57,0x85,0xCA,0xE3,0x39,0x94,0xB1,0xD4,0x68,0x93,0x9A,0xFC,0x51,0x05,0x41,0x61,0x65,0x51};
//const uint8_t spESCAPE[] PROGMEM = {0x21,0x68,0x5E,0xB9,0x22,0x26,0xAF,0x74,0xB8,0xA4,0x08,0x5F,0x75,0xD2,0xA5,0x9B,0x34,0x6C,0xD5,0xCA,0xAA,0x36,0x29,0xAF,0x49,0x25,0xBF,0x24,0x54,0x2A,0x52,0x09,0xE0,0x12,0x73,0x0B,0x58,0x40,0x01,0xDF,0xB8,0x09,0xE0,0xF1,0x0A,0x04,0x0A,0xE5,0xEE,0x22,0xB2,0x41,0x01,0x53,0xB3,0x35,0xB3,0x79,0xD2,0x89,0x8A,0x73,0xDC,0x16,0x29,0xCA,0x3B,0xCE,0x09,0x7B,0x52,0x29,0xCF,0x3A,0x27,0x1D,0x51,0x39,0xB3,0xEA,0xAC,0x6A,0x14,0x61,0xCF,0xAA,0xDB,0x86,0x11,0x99,0x3C,0xB3,0x0E,0x99,0x84,0x72,0x77,0x11,0xD9,0x00,0x00,0x80,0x80,0x60,0x9D,0x09,0x90,0xB2,0x08,0x02,0x82,0x35,0xFD,0x31};
//const uint8_t spF[] PROGMEM = {0x23,0x1E,0x29,0x44,0x32,0xE6,0x9C,0x70,0xA6,0x16,0x09,0x9F,0x7D,0xC2,0xE5,0x53,0xB4,0xBD,0xF6,0x89,0xA6,0x77,0x89,0xF6,0x25,0x27,0x1D,0x39,0x35,0x9C,0x9B,0x8C,0xA2,0xA4,0x34,0xB7,0xA8,0x8A,0x80,0x14,0xCC,0x09,0x30,0x6C,0x05,0x05,0x38,0xC0,0x80,0xE1,0x2B,0x08,0x30,0x4C,0x3A,0x01,0x9A,0x49,0xC7,0x00,0x06,0xFE,0x75,0x51,0x31};
//const uint8_t spFEW[] PROGMEM = {0x08,0xA8,0x54,0x95,0x02,0x0C,0x68,0xD2,0xC8,0x00,0x33,0x2B,0xB5,0xBC,0x6B,0x45,0xDB,0xAA,0x3C,0xF2,0xE9,0x12,0x68,0x72,0xD1,0x2E,0x56,0x31,0xB4,0x83,0xB5,0xBD,0x5C,0x45,0xC3,0xCE,0xB9,0xB2,0x6A,0x94,0x15,0xBB,0x4C,0xD3,0xE6,0x56,0x55,0xD0,0xA1,0xC9,0xBF,0x5B,0x55,0x50,0x7B,0x04,0xEE,0xEE,0x55,0xA9,0x12,0xDE,0x70,0xA3,0x9D,0xA1,0x8A,0xF4,0xC2,0x8D,0x76,0xDA,0xEA,0xFF,0x51,0x19,0x49,0x31};
const uint8_t spFILE[] PROGMEM = {0x08,0xE8,0xD2,0x95,0x00,0x4D,0xA7,0x09,0xA0,0xC8,0xF0,0xE6,0xE5,0x54,0x9E,0x4A,0x8F,0x4E,0x50,0xFC,0x95,0xB9,0x36,0xB8,0xE1,0x89,0xAA,0xB9,0x52,0xF3,0x86,0x27,0x6E,0xFA,0xDA,0xCD,0x5A,0x9E,0xB4,0xEA,0x6B,0x77,0x6B,0x79,0x8A,0xA6,0xB7,0x32,0xA4,0xD3,0xA9,0xBA,0xDD,0xC8,0x94,0x55,0xA7,0xEB,0xA1,0x3D,0x83,0x17,0x9F,0xBE,0x87,0x90,0x08,0x5B,0x3C,0x86,0xEE,0x4C,0xB2,0x6C,0x71,0x99,0x8A,0x97,0x48,0xAF,0xD9,0x61,0xCE,0x4E,0x2B,0xB4,0xE6,0x84,0x25,0x79,0xCF,0x22,0x5F,0xED,0x67,0x33,0x85,0xEE,0x66,0xD2,0x8D,0xDD,0x18,0x62,0x64,0x52,0xAC,0xB2,0xE3,0xFF,0x15,0x65,0x25,0x49,0x31};
//const uint8_t spFIRST[] PROGMEM = {0x04,0xC8,0x2C,0x94,0x01,0x53,0x54,0x08,0x60,0xB0,0x54,0x01,0x54,0x99,0x3A,0x9C,0xEC,0x53,0xC3,0xB4,0xF6,0xF1,0xAB,0x29,0x0B,0x93,0xD5,0xC7,0x6F,0xAE,0x2D,0x95,0x57,0x9D,0xA8,0xDA,0xD2,0x70,0x5B,0x74,0x92,0x6E,0x5A,0xC3,0x64,0xF3,0x29,0xBA,0x4D,0x4D,0x93,0xCD,0xAB,0xEF,0x36,0x35,0x4C,0x5E,0xA7,0x21,0x5B,0xF7,0xF6,0x9C,0x95,0xC6,0x12,0x4D,0xC3,0x7B,0xB4,0x02,0x82,0xD5,0x12,0xC0,0x42,0xA1,0x0A,0xF8,0xC2,0x9C,0x01,0x5F,0x78,0x0A,0xE0,0x73,0x37,0x01,0x7C,0xE6,0x2E,0x80,0x1F,0xD8,0x10,0x28,0x94,0xBB,0x8B,0xC8,0x06,0x06,0x4C,0xE1,0x25,0x80,0x4D,0x39,0x11,0x30,0x44,0xE8,0xFF,0x11,0x39,0x55,0x79,0x31};
//const uint8_t spFOUND[] PROGMEM = {0x04,0x18,0x2E,0x5D,0x01,0xC3,0xA4,0x2A,0x60,0xEA,0x08,0x0F,0x8C,0x38,0xC5,0xB2,0x30,0x5E,0xB4,0xF2,0x9C,0x2A,0xD2,0x68,0xD5,0x29,0x4A,0xDC,0xC8,0xE0,0x8E,0xA7,0x2A,0x61,0x33,0x92,0x3B,0x9F,0xBA,0xBA,0x8D,0x4C,0xEE,0x74,0xEA,0xEA,0x27,0x32,0x79,0xF5,0x69,0x6B,0x18,0xCF,0xA0,0x55,0xAB,0x2D,0xB1,0xBD,0x94,0x56,0xAD,0xA6,0xA4,0xF2,0x14,0x5E,0xB5,0xEA,0x12,0xD2,0x0B,0x25,0xD3,0xAA,0x8A,0x8B,0x08,0x34,0xCD,0xA3,0xAA,0x2A,0xA4,0x41,0x9D,0xB5,0xAA,0x52,0xA7,0xA5,0x48,0x5A,0xAA,0x22,0x44,0x9E,0x32,0x0E,0x6B,0x82,0x94,0x1C,0x2A,0xC7,0xA1,0xDD,0xC6,0x5D,0x4C,0xDD,0x94,0xBE,0x79,0x71,0x37,0xB7,0xFD,0x59,0x79,0x25,0x31};
const uint8_t spFROM[] PROGMEM = {0x08,0xE8,0xDA,0x84,0x02,0x0A,0x68,0x26,0x54,0x03,0xAE,0x88,0x83,0x2A,0xC4,0x73,0x97,0x2A,0x2D,0x8D,0x90,0xC8,0xBD,0xEA,0x1C,0xAD,0x22,0xA8,0xF7,0x69,0xB2,0xAF,0x8A,0xA4,0x3E,0xA7,0xCD,0xBE,0x2A,0x12,0xF7,0x9C,0x2E,0x9B,0x6D,0x0B,0xEA,0x72,0xFA,0x6C,0x6E,0x34,0xB8,0xF5,0xEA,0xB3,0xBE,0xB5,0xE0,0xD6,0xA3,0xCF,0x7A,0x5A,0x43,0x3D,0xB7,0x2E,0xAB,0xB6,0x14,0x52,0x5D,0xDA,0x24,0x5A,0x43,0x58,0x4B,0x6E,0x43,0x13,0x9D,0x85,0x91,0xB6,0xF1,0xCD,0xFF,0x71};
//const uint8_t spG[] PROGMEM = {0xA1,0xDE,0xDD,0x89,0x30,0xD2,0x58,0x60,0x64,0x2B,0x1A,0xB1,0x45,0x97,0x95,0xCC,0xA8,0xC8,0xD9,0xAB,0x77,0xB8,0xFD,0x13,0x4C,0x2B,0xE8,0x39,0xB5,0x6F,0xB4,0x92,0x6D,0x14,0x38,0xB7,0xF2,0xCE,0x46,0xB5,0xBD,0x22,0xE5,0x34,0x6E,0xDD,0xCE,0x8E,0x90,0x53,0x27,0x0D,0x3B,0x08,0xE2,0x4E,0x9D,0x34,0xAC,0x24,0x88,0xD7,0x75,0xF3,0x90,0x86,0x55,0x04,0x71,0xA7,0x49,0x19,0x66,0x16,0xE0,0xED,0xC5,0x61,0x18,0x01,0xB8,0x7B,0x62,0x87,0x61,0x64,0x22,0xCF,0x8E,0xFC,0x11,0x79,0x79,0x71};
//const uint8_t spGOOD[] PROGMEM = {0xA9,0x2C,0xA9,0xC5,0xD4,0x6C,0x8F,0xA2,0x61,0xD7,0x68,0xE9,0xBC,0xCA,0x22,0xCC,0xDB,0x64,0xCD,0xA9,0x92,0x2A,0x37,0xB3,0xCD,0xB7,0x3A,0x55,0x52,0x19,0xAE,0xFA,0x7A,0x57,0xA3,0xCE,0xC2,0xA3,0x42,0x57,0xD7,0x06,0x35,0x22,0xB8,0x8B,0x88,0x6C,0x70,0xC3,0x36,0xEE,0x62,0xEA,0xC6,0x75,0xCD,0x8B,0xBB,0xB9,0x6D,0xDF,0xFD,0x09};
//const uint8_t spH[] PROGMEM = {0xC3,0x1B,0xD1,0x29,0xA2,0x6A,0xAF,0x68,0xC6,0x46,0xF3,0x6C,0x74,0xC2,0x91,0x12,0xCD,0x7B,0xD1,0x89,0x66,0x2C,0xD4,0xAC,0x45,0x27,0x5E,0xB9,0x91,0xB3,0x16,0xAD,0x6C,0xD5,0x41,0x8C,0x58,0x94,0xAA,0xD9,0x02,0xB8,0x7A,0x11,0xA9,0x84,0x72,0x77,0x11,0xD9,0x00,0xA0,0x80,0x69,0xCC,0x15,0xB0,0xB3,0x8B,0x03,0x76,0xEB,0x0C,0xC0,0x2E,0x9D,0x01,0x58,0x7D,0xD3,0x02,0x0A,0x58,0x75,0x5C,0x00,0x73,0xB6,0x13,0x60,0x26,0x93,0xFF,0x51,0x35,0x41,0x09};
//const uint8_t spHAVE[] PROGMEM = {0xAC,0x19,0xA1,0xBD,0x3C,0x2B,0x8F,0x68,0x44,0x8F,0x54,0x33,0x7D,0x9C,0xEA,0xDD,0x53,0x3D,0xF2,0x71,0x87,0x6B,0x8B,0xB0,0xDA,0x27,0x18,0x6E,0xDD,0xC3,0x6A,0x9D,0x68,0x9A,0x09,0x4F,0x6B,0x74,0xE2,0x69,0x27,0x23,0xA5,0xD1,0x29,0x86,0x9F,0x8C,0xD4,0xC5,0xA7,0x6A,0xA9,0x22,0xC2,0x27,0x8D,0xAE,0xC6,0xB2,0x48,0x2F,0xD5,0xFA,0x1A,0xC2,0xD3,0x7C,0x54,0x1B,0x4A,0x2C,0xF6,0xB4,0xCA,0x69,0x48,0xA1,0xD8,0xD7,0x6A,0xB9,0xC1,0x55,0xD7,0xA9,0xAC,0x64,0x46,0x6F,0x3C,0xCB,0xAD,0x95,0x9A,0x8A,0x31,0x73,0xB6,0xC4,0x6A,0x6C,0x32,0xD4,0x58,0x54,0xFF,0x49};
//const uint8_t spI[] PROGMEM = {0x2B,0x2B,0xA5,0x3A,0xCD,0x9B,0x9C,0xB4,0x9A,0x8B,0x08,0x5B,0xB4,0x92,0xE2,0xDF,0x3D,0xBD,0xE6,0x89,0x4B,0x7C,0xB7,0x88,0x98,0x27,0x2D,0xFE,0xC3,0x22,0x6A,0x9E,0xB4,0xF8,0x0F,0xF7,0x68,0x78,0xB2,0x6A,0x3E,0x23,0x6C,0xE5,0xA9,0x9B,0xBA,0x8C,0xD4,0xD6,0xA7,0x6E,0xFA,0x32,0x4A,0x57,0x9F,0xB1,0xF9,0x89,0x48,0x5B,0x73,0xA6,0x16,0xCB,0x33,0x6C,0xF1,0x5A,0x7B,0x0E,0x8F,0xB0,0xDA,0x63,0x6D,0x51,0x3C,0xB2,0x16,0xB7,0xAD,0x79,0xD5,0xEC,0x9A,0x53,0xB6,0x9E,0x44,0x62,0xBB,0x4E,0xDA,0xBA,0x63,0xCD,0x99,0xCA,0x69,0xED,0x8E,0x2C,0x27,0xE5,0xFC,0x19,0x41,0x71,0x51,0x19,0x19,0x49};
//const uint8_t spILLEGAL[] PROGMEM = {0x25,0x19,0x4C,0xA9,0x6F,0x42,0xF7,0x2C,0x67,0x21,0x5F,0x20,0x38,0xC3,0x1E,0x96,0xE4,0x70,0x65,0x4B,0x5F,0xDD,0xA2,0x43,0x85,0xAD,0xA2,0xF5,0x08,0xB6,0x36,0xD0,0xD6,0x26,0x2B,0x9A,0xD6,0x40,0xBB,0xAA,0xAC,0x64,0x79,0x03,0xDD,0xAE,0x3D,0xB2,0x99,0x08,0x6A,0xBA,0x72,0xA9,0x56,0x37,0xE0,0xE9,0x46,0xA6,0x5A,0xDD,0x81,0xAA,0x67,0x21,0x50,0x04,0x77,0x11,0x91,0x0D,0xAE,0x28,0xA9,0xC1,0xD4,0x6C,0x97,0x36,0xC7,0x46,0xF7,0x48,0x34,0xFA,0xAA,0xC3,0x4A,0x7D,0xF1,0x18,0xB2,0x8F,0x0C,0xCE,0x35,0x65,0x8A,0xB1,0xDC,0x39,0x5B,0x87,0x39,0x94,0x72,0xE3,0x5E,0x1C,0xA6,0x10,0xDB,0x83,0xB2,0xAB,0x1B,0xA3,0x1B,0x6B,0xB4,0xB5,0x7E,0xF8,0x5A,0x39,0x49};
//const uint8_t spIN_[] PROGMEM = {0xCD,0x9E,0xC3,0x89,0x23,0x17,0x9F,0x68,0xC5,0x42,0xCA,0x5C,0x74,0xC2,0xE5,0x12,0xB9,0x62,0xE1,0x09,0x97,0x76,0x92,0x8A,0x46,0x2D,0x28,0x92,0xEC,0x38,0xD3,0x35,0xBF,0x39,0xF4,0xE1,0x74,0xD7,0xFC,0xE6,0xD0,0x46,0x52,0x79,0xF3,0x9B,0x45,0x1F,0x49,0x2D,0x28,0x12,0xCA,0xDD,0x45,0x64,0xC3,0xFF,0x15,0x55,0x05,0x39,0x49};
//const uint8_t spINPUT[] PROGMEM = {0x23,0x58,0x3A,0x90,0xAB,0x56,0x6F,0x6F,0x79,0x4B,0x19,0x5A,0xE7,0xA2,0xE1,0x15,0x21,0xB1,0x1A,0xEE,0x5A,0x5C,0x24,0x45,0x5B,0x68,0x0B,0x49,0x91,0x14,0x6B,0xA5,0xC5,0xA5,0x49,0x72,0x2D,0x95,0x17,0x92,0x0B,0xE5,0xEE,0x22,0xB2,0x01,0x04,0x10,0xB5,0xA6,0x02,0x72,0x34,0x4D,0x55,0x9C,0xC1,0xAA,0x35,0x39,0xD5,0xA1,0xBB,0x98,0xF7,0xE8,0xD4,0xC6,0xA4,0x85,0x39,0x73,0xC8,0x20,0x94,0xBB,0x8B,0xC8,0x06,0x00,0x05,0x5C,0x91,0xA6,0x01,0x04,0x54,0xDF,0xF0,0x65,0x49};
const uint8_t spIS[] PROGMEM = {0xC9,0x5F,0x3E,0x90,0xB2,0x17,0xDF,0xE0,0x04,0xDB,0x04,0x72,0xF5,0xA2,0x13,0x6E,0x1D,0xC8,0xD5,0x8B,0x4E,0xB4,0x5C,0x23,0x65,0x2F,0x3A,0xE9,0x76,0x85,0x1C,0xB5,0xE8,0x94,0x33,0x24,0x89,0xD6,0xA2,0xD5,0xCD,0xD4,0x24,0x54,0x8B,0xC6,0xD8,0x0D,0x4B,0xF8,0xD6,0x29,0x63,0xE2,0x6E,0x9D,0x1D,0x3B,0x8F,0x66,0x3C,0xD0,0xCD,0xA3,0x12,0xDA,0x89,0x01,0x13,0xB0,0x23,0xE0,0x61,0x76,0x04,0x7C,0x4A,0xFA,0x29};
//const uint8_t spJ[] PROGMEM = {0xA1,0xDE,0xDD,0x89,0x30,0xD2,0x68,0x60,0x64,0x2B,0x1A,0xB1,0x45,0x97,0x13,0x75,0x61,0x18,0xBE,0x29,0x4F,0xD4,0x95,0x53,0x45,0x67,0x3A,0xD1,0xF0,0xC1,0x61,0xD1,0xEA,0xC4,0x43,0x17,0x67,0x64,0xEB,0x93,0x74,0xE3,0xDC,0x91,0xAD,0x4F,0xDA,0x83,0x4A,0x78,0x35,0x39,0x79,0x0F,0x2A,0xE5,0x59,0x67,0x55,0xDD,0xA9,0x54,0xD6,0x92,0xD5,0x0E,0x13,0x14,0x13,0x8D,0xC7,0x58,0x95,0xE8,0x4C,0x57,0x2E,0x63,0x35,0x6C,0x33,0x5D,0x25,0x8D,0xCD,0x90,0xD5,0x74,0xE8,0x3C,0x86,0xB1,0x08,0x8E,0xEB,0x35,0xFD,0x69};
//const uint8_t spK[] PROGMEM = {0x06,0xA8,0x86,0x99,0x01,0x2D,0x10,0x0D,0x7F,0x04,0xC5,0x0C,0xB7,0x72,0xBC,0xE6,0xD9,0xDB,0x2A,0xEE,0x71,0x47,0x48,0x0E,0xB7,0x25,0x37,0x38,0x71,0xF7,0x26,0x15,0x39,0xE7,0xA4,0x3D,0xA9,0x94,0x65,0xDD,0x53,0xB4,0xC0,0xDE,0x51,0xD5,0x4E,0xDD,0xBD,0x72,0x55,0xCC,0x39,0x6D,0x77,0xCA,0xD5,0x39,0xA7,0xB5,0xCD,0xB1,0x74,0xF7,0xD4,0xD6,0xF7,0x28,0x1C,0x5D,0x75,0xDA,0x38,0x92,0x90,0x77,0xCD,0xAE,0x63,0x19,0x7B,0x22,0xCE,0x9A,0x2A,0xFF,0x4D,0x51,0x69};
//const uint8_t spKEY[] PROGMEM = {0x09,0xE8,0x9C,0xCD,0x01,0x93,0x4B,0x38,0x60,0x6A,0xD5,0x61,0x4F,0x27,0xE8,0x35,0xB6,0x87,0xB3,0xBC,0x81,0xD5,0xD6,0x59,0xEE,0xB2,0x0A,0xD1,0x9B,0x64,0xFB,0x2B,0x3C,0x56,0xC1,0x7A,0x63,0xCF,0x68,0xE4,0xDB,0x2B,0x48,0x6F,0xEC,0x99,0x97,0x7A,0x07,0x01,0x9D,0xB1,0x5D,0x6B,0xD7,0x2D,0x4D,0x18,0xD3,0x72,0xFE,0x19};
//const uint8_t spL[] PROGMEM = {0x23,0x1A,0x59,0x35,0xD5,0xEB,0xAC,0xA4,0x05,0xC9,0xF0,0xAA,0x73,0x92,0x16,0xD5,0xC3,0xBA,0xCA,0xC9,0x5A,0xF1,0x72,0x8E,0x2A,0xA7,0xA8,0x25,0xDA,0xD9,0xE7,0x9C,0xBA,0xC6,0xEC,0x14,0x5E,0xB3,0xBA,0xE2,0xB3,0x5D,0x69,0x73,0xE9,0xB3,0xB3,0x09,0x91,0xDD,0xA5,0x4F,0x2E,0x3A,0xD9,0xF2,0xA4,0x21,0x79,0x5B,0xA7,0xE8,0xEC,0x86,0x50,0xA2,0x59,0xBA,0xB5,0x1B,0x42,0x8E,0x32,0xAA,0xD6,0x61,0x8C,0xC5,0x5B,0x70,0x1A,0xAB,0x31,0x05,0x6B,0xA1,0x6A,0xFC,0x51,0x71,0x25,0x41,0x19};
//const uint8_t spLARGE[] PROGMEM = {0xA1,0xEA,0x60,0xD8,0x3D,0x6F,0x95,0xBA,0x83,0x96,0xF4,0xBC,0xD5,0xAA,0x0D,0x4A,0xC2,0xEC,0x61,0x2B,0x26,0x68,0x71,0xF7,0x07,0x2B,0x9B,0xB0,0x34,0x55,0x36,0x9D,0x38,0x9B,0x51,0x37,0x7F,0x78,0xE2,0x62,0xC7,0xDC,0x6C,0xE3,0x89,0xB2,0xF9,0x34,0xD5,0x16,0x27,0xCE,0xE6,0xD2,0xC5,0x5A,0x9C,0x24,0xE7,0x4B,0x17,0x6B,0xB1,0xD2,0x5C,0xAE,0xDC,0xB4,0xE1,0xCA,0x73,0xDD,0x72,0x95,0x46,0xA7,0xCC,0xA9,0xCA,0x8D,0x1B,0xAE,0x3A,0xB5,0x4A,0x57,0x6D,0x38,0xBA,0xD4,0xAB,0xC2,0x64,0xD1,0x1A,0x73,0xAE,0x4C,0xE5,0x85,0x6B,0xCA,0xB9,0x22,0x54,0x16,0xB6,0x29,0xC7,0x8C,0x10,0x7B,0x14,0xA6,0x94,0xA4,0xD4,0xA7,0xA1,0x9A,0x93,0x71,0x31,0x8B,0x54,0x64,0x12,0xCA,0xDD,0x45,0x64,0x03,0x02,0x9A,0x23,0x11,0xC0,0x68,0xEB,0x0A,0x58,0x75,0x4C,0x02,0x04,0x18,0x6B,0xFC,0xFF,0x15,0x65,0x41,0x19};
//const uint8_t spLAST[] PROGMEM = {0xA1,0x4D,0xA0,0x6D,0xCC,0x17,0x96,0xA6,0x80,0xB1,0x8C,0x58,0x58,0x9B,0x55,0x75,0x56,0x96,0xA6,0x9B,0x56,0xD5,0xE4,0x44,0x19,0xAE,0x3A,0x75,0x55,0x9D,0x95,0xB4,0xF9,0xD6,0xA7,0x2E,0xAE,0xB3,0x1D,0x37,0x9F,0xA6,0x98,0xA9,0x0A,0xEA,0xBD,0x9B,0xD5,0x54,0x3D,0x99,0x41,0xBD,0x47,0x93,0x5D,0x79,0x51,0x56,0x76,0xF5,0xA1,0xE5,0xE1,0xA2,0xD8,0x00,0x17,0x8B,0x69,0x40,0x00,0x8F,0x91,0x52,0x00,0x81,0x22,0xB8,0x8B,0x88,0x6C,0x60,0xC0,0x91,0x14,0x0C,0x58,0x5C,0xED,0xFF,0x51,0x39,0x49,0x19};
//const uint8_t spLINE[] PROGMEM = {0xA1,0xAC,0x20,0xB9,0x2D,0x57,0x97,0x62,0x81,0xE0,0x0C,0x7B,0x58,0xF2,0x01,0x42,0x3A,0xED,0x45,0x4B,0x27,0x48,0xB7,0x8A,0x95,0x23,0x99,0x20,0x2D,0x4A,0x57,0x9D,0xA8,0x8B,0xD5,0x94,0xB8,0x79,0xA2,0x6A,0xCE,0x43,0x7D,0xE6,0x89,0x4B,0xF8,0x08,0x8B,0x5A,0x27,0x2D,0x75,0xC3,0xBD,0x2A,0x9F,0xAC,0xDA,0x4F,0xB7,0xA8,0x75,0xF2,0x29,0x67,0xC2,0x3C,0xE5,0x29,0xA7,0xE9,0xAA,0x90,0x54,0xA7,0x9A,0xBE,0x3D,0x52,0x5A,0x9D,0x66,0xC5,0x51,0x49,0x6B,0x74,0xFA,0x95,0x46,0x30,0xA2,0xD1,0x18,0x66,0x2E,0xE4,0xCA,0xCA,0x6D,0x58,0x21,0x89,0x3A,0x23,0x87,0xA1,0x70,0xB5,0x71,0x4D,0xEA,0x07,0x33,0x24,0x61,0xB9,0x6A,0x49,0xFE,0x59};
//const uint8_t spM[] PROGMEM = {0x2B,0x1B,0x41,0x55,0x3B,0x9A,0x9C,0x64,0x85,0x34,0x4E,0x6B,0x73,0xA2,0xAD,0x52,0xB4,0xBD,0xD1,0x89,0xA6,0x4E,0xF6,0xF1,0x46,0x27,0x9E,0x32,0x38,0xD6,0x5A,0x9D,0x74,0x86,0x11,0x2F,0x6A,0x74,0xB2,0x61,0xDB,0x23,0xB1,0xF3,0x28,0x7B,0x96,0x18,0x10,0xBB,0xB9,0x73,0x43,0xD2,0x92,0x81,0xBE,0x56,0x0D,0xD1,0x58,0x18,0x56,0x17,0x35,0x78,0xEF,0x26,0xDA,0x4D,0xCC,0x10,0xAD,0xA6,0x52,0x77,0x31,0x43,0x50,0x9A,0x49,0xD1,0x36,0x74,0x39,0x86,0x2B,0x59,0xAD,0xFF,0x4D,0x39,0x41,0x59};
//const uint8_t spMANY[] PROGMEM = {0xAE,0x4D,0x9A,0xEC,0x2C,0x62,0xC7,0xAA,0x54,0x49,0x93,0x6D,0x78,0xE2,0x55,0xF5,0x10,0xA4,0x6E,0xAD,0x4E,0x3D,0x5D,0xB3,0xBA,0xAD,0x3A,0xF5,0xF0,0x2D,0x6A,0xBE,0xEA,0xD4,0xD3,0xA7,0x98,0xF9,0xAA,0xD4,0x54,0x43,0xD2,0xDA,0xB1,0x52,0x9D,0x25,0xEB,0x69,0x85,0x59,0xF5,0xF0,0x4E,0xA6,0xB1,0xE8,0x34,0xD3,0x16,0x71,0xE5,0xC2,0x53,0x2F,0xDB,0x44,0x99,0x2B,0x47,0xDD,0xA3,0x92,0x47,0x8F,0xAE,0xF5,0xFF,0x65,0x55,0x39,0x49,0x59};
//const uint8_t spMINUS[] PROGMEM = {0xAE,0x48,0xCA,0xB4,0x51,0xB6,0xE4,0xA2,0x65,0xD9,0x84,0x25,0xE2,0x96,0x99,0xAE,0xA4,0xEA,0x4B,0x53,0xF1,0x79,0xE2,0xA6,0xB7,0x43,0xAD,0xE5,0x89,0xBA,0xDC,0x0E,0x8D,0x94,0x27,0x1A,0x6A,0x32,0xDC,0x5A,0x9E,0x68,0xD9,0x16,0x0F,0x4F,0x78,0xE2,0xE5,0x97,0xC5,0x22,0xE1,0xCA,0x96,0x1B,0x16,0xA9,0x98,0xAD,0x6C,0x52,0xA9,0xC5,0xA3,0x94,0xA6,0x28,0xD5,0x92,0x48,0xDC,0xDA,0x16,0x22,0xD8,0xAA,0x76,0x1B,0x9B,0x75,0x37,0x8D,0x39,0x69,0x4C,0x26,0x3C,0x6D,0x1A,0x87,0x31,0x45,0x13,0xF3,0xAD,0x25,0x80,0x0D,0xD4,0x05,0xF0,0x39,0x8B,0x00,0xBE,0x10,0x36,0xC0,0xE7,0xEC,0x1A,0xE0,0x00,0x07,0x08,0xF0,0xAD,0xD0,0xFF,0x51,0x25,0x79,0x59};
//const uint8_t spMORE[] PROGMEM = {0xA6,0x2A,0x06,0xA3,0xD1,0x9D,0xE5,0xAA,0x97,0x2D,0xCA,0xEC,0xCA,0x8C,0xF2,0xAC,0x28,0x93,0x4F,0x53,0xEE,0xB9,0xA2,0x4C,0xBE,0x44,0x35,0xE7,0x8A,0x0B,0xDA,0x15,0xF1,0x5C,0x2B,0x29,0x70,0xD7,0xD5,0x7C,0xAF,0x2C,0x91,0x5B,0x17,0xF3,0xB3,0xF2,0x82,0x67,0x5D,0xC4,0xCF,0xAA,0x0A,0x99,0x35,0x51,0xBF,0xA3,0xC9,0xB4,0xD7,0x83,0xF2,0xB6,0x2E,0x89,0x59,0x75,0xEA,0x5B,0xC6,0xA8,0x77,0xC4,0x79,0x4F,0x1A,0x83,0xDB,0x16,0xE3,0xCD,0x65,0x0C,0x7E,0x4B,0x4C,0x36,0x97,0x31,0x9A,0x6D,0x75,0xEE,0x5D,0xC6,0x50,0x3B,0x54,0x75,0xD3,0xFF,0x15,0x65,0x55,0x59};
//const uint8_t spMUST[] PROGMEM = {0xA1,0xCD,0x9E,0xCA,0xC1,0x93,0xB5,0x26,0x3B,0x89,0x04,0x69,0xD3,0xEA,0xEC,0x24,0x0A,0xB4,0xED,0xA8,0xB3,0xD7,0x48,0x90,0x36,0xA3,0xCE,0x5E,0xA3,0x80,0xD2,0x9C,0xBA,0x84,0xC9,0x0A,0xCC,0x74,0xEA,0x6A,0x26,0x23,0x25,0xD3,0xA9,0x9B,0x9E,0x8A,0x94,0x4E,0xA7,0x6A,0x66,0x2A,0x93,0x5B,0xAD,0xAA,0x04,0xAF,0xE0,0xA8,0xDD,0xEA,0x49,0x32,0xDC,0xCC,0x93,0x02,0x2E,0xE6,0x10,0xC0,0x13,0xE4,0x0A,0x78,0x96,0x5C,0x03,0x02,0x78,0x82,0x1C,0x81,0x22,0xB8,0x8B,0x88,0x6C,0x10,0xC0,0x15,0x69,0x12,0x40,0x40,0xF1,0xA9,0xFF,0x39};
//const uint8_t spN[] PROGMEM = {0x27,0x9E,0x71,0x99,0x3D,0x16,0x9D,0x68,0xBA,0x22,0xCB,0xAC,0x75,0xA2,0xE9,0x92,0x22,0x73,0xD6,0x89,0xA6,0x2F,0xF2,0xC8,0x59,0x27,0x59,0x61,0x55,0x4D,0x6A,0x9D,0x7C,0xBB,0x52,0x0D,0xAD,0x35,0xAA,0xAE,0x9D,0x5A,0x3C,0x76,0xAB,0xBB,0x72,0x1A,0x0E,0x3B,0xA5,0xED,0x2A,0x68,0x30,0x9D,0x96,0xBE,0x69,0xE7,0xC1,0x54,0x53,0x87,0x3A,0xD4,0xA1,0x0C,0x4D,0xBB,0x14,0xBA,0xDB,0x34,0x14,0x1F,0x62,0x16,0xB1,0x42,0x57,0x8C,0x49,0x8A,0xC5,0xFC,0x51,0x59,0x41,0x39};
//const uint8_t spNAME[] PROGMEM = {0x24,0x56,0x3C,0xA2,0x3D,0x12,0xAB,0x82,0x99,0xD8,0x96,0x48,0x62,0x32,0x6E,0x7C,0x9B,0xD3,0x8D,0x49,0x95,0xD2,0x6B,0x49,0x3B,0x21,0xF1,0x52,0xFA,0xA5,0xEC,0x9C,0x68,0x89,0xC0,0xD6,0xAA,0x74,0xA2,0xA5,0x8A,0xD3,0xAA,0xD6,0x09,0xA7,0x29,0x4A,0xCB,0x5A,0x27,0x9A,0x2A,0xB9,0xA2,0x6A,0x9F,0x68,0x9A,0xA4,0xCC,0xAA,0x7D,0xD2,0xE5,0x0A,0xCD,0xBB,0xF6,0xC9,0x67,0x4C,0xD4,0x98,0x3A,0xAB,0x1A,0x5E,0xD0,0x7B,0xEA,0x8C,0x76,0x3A,0x03,0xED,0x9E,0xDD,0xDA,0xE1,0x14,0xAD,0x6A,0x96,0xEB,0xAA,0x10,0xA9,0xF4,0x26,0x66,0x48,0x5A,0x32,0xD0,0xD7,0x9A,0x21,0x69,0xAA,0x62,0x4F,0x62,0x87,0xFF,0x51,0x35,0x49,0x15,0x41,0x71,0x51,0x39};
//const uint8_t spNEGATIVE[] PROGMEM = {0x26,0x2E,0x4C,0x24,0xCC,0x13,0xC5,0x32,0x14,0x49,0xD0,0x9C,0xA4,0x9B,0x92,0x25,0xC9,0x33,0x9C,0x6E,0x46,0x32,0x94,0x91,0x7B,0x2C,0x3E,0xD1,0x74,0x21,0x6E,0xD1,0xF8,0x84,0xCB,0x26,0x9B,0x7B,0xE3,0x13,0x4C,0x93,0xE8,0x9D,0xAB,0x46,0x30,0x4A,0x41,0x44,0xCE,0x22,0x49,0xD7,0x06,0x16,0xB5,0x7A,0x64,0xDD,0x15,0x87,0x8A,0xE2,0x95,0x75,0xA3,0xD0,0x13,0xB5,0x56,0xDA,0x94,0x70,0x75,0xD4,0x26,0x9D,0x50,0xEE,0x2E,0x22,0x1B,0x0C,0xB0,0xA8,0x85,0x03,0x16,0x0B,0x0D,0xED,0x16,0x4E,0x5A,0x16,0xBB,0xB4,0xC3,0x2A,0xA5,0x57,0x9D,0x32,0x74,0x27,0x1C,0x59,0x73,0xC2,0xD2,0x8D,0x70,0x65,0xCE,0x76,0x4B,0x33,0x22,0xE5,0x39,0xCB,0x2D,0xD5,0x93,0xA5,0xD5,0x2C,0x33,0x67,0x23,0x5A,0x5A,0x35,0xC5,0x5C,0x55,0x88,0xA9,0x35,0x36,0xF3,0x70,0xA9,0xA9,0xAA,0x98,0x00,0x4D,0x9B,0xFC,0x75,0x51,0x39};
//const uint8_t spNEW[] PROGMEM = {0xAE,0x88,0x82,0xB6,0x2D,0xD5,0xA4,0x3A,0x49,0xF5,0xA1,0x8C,0xDB,0xEB,0x52,0x27,0x25,0xF6,0x62,0x75,0x47,0xDD,0xB5,0xA2,0x6D,0x55,0x1E,0xF9,0x74,0x09,0x34,0xB9,0xA8,0xC5,0x53,0x19,0xE8,0x75,0xE5,0x11,0x0C,0x67,0x60,0x5B,0x0F,0x8F,0xDF,0x64,0xB0,0x87,0xAF,0xDE,0xC1,0x88,0x0A,0x1F,0x55,0xD6,0x57,0x23,0x8D,0x6C,0x54,0x35,0x56,0xA6,0xC2,0x89,0x73,0x31,0xDF,0xE4,0x5A,0xE1,0x4E,0xCD,0xF2,0x91,0x1B,0xB4,0x3A,0x13,0xF3,0x26,0x66,0x64,0x61,0x2D,0xD4,0x93,0xE8,0xF1,0xFF,0x79,0x39};
//const uint8_t spNO[] PROGMEM = {0xAC,0xEF,0xCC,0xD9,0x25,0x6C,0xBB,0xB6,0x50,0xD1,0xC7,0x74,0x17,0x9A,0x42,0xD9,0x1E,0xD3,0x5D,0xAA,0x2B,0x51,0x7D,0x2C,0x77,0x29,0xAF,0xC4,0xF4,0x31,0x93,0xB7,0xAC,0x81,0xE4,0x63,0xAD,0x7F,0xD2,0x2E,0x5B,0x4D,0xBC,0xD1,0x89,0x9B,0x6E,0x33,0xF5,0x4D,0x27,0x6B,0x26,0x3D,0xD8,0x56,0x9F,0xA2,0xEA,0x0E,0x53,0xDB,0x74,0xAA,0xA6,0x32,0x42,0xE5,0xD3,0xEE,0xC7,0xD8,0x44,0xA7,0x19,0x7E,0x0E,0x53,0x32,0xE3,0x6C,0xF6,0x28,0x8C,0xC1,0xB7,0x19,0xE5,0x9C,0x38,0xDA,0xF1,0xFF,0x15,0x79,0x39};
//const uint8_t spNOT[] PROGMEM = {0xA1,0xCD,0x9A,0xA3,0x71,0xEC,0xA6,0x36,0x1B,0xCA,0xA4,0x56,0x9A,0xDA,0x6A,0xB1,0x4D,0x4B,0x73,0x6E,0x4F,0xDD,0x9C,0x7B,0x91,0xA5,0x3D,0x75,0x75,0xD3,0xE6,0x9C,0xFA,0x34,0xC5,0xEC,0xB8,0x4B,0xE6,0xD3,0x14,0xB3,0x6B,0xAE,0x69,0x4E,0x5D,0xCC,0x4E,0x98,0x64,0x3E,0x75,0x71,0x33,0xE6,0x9C,0xA9,0x95,0x39,0x44,0xB9,0x48,0x23,0x53,0x64,0xB7,0xE9,0xE2,0x19,0x51,0x2B,0x82,0xBB,0x88,0xC8,0x06,0x60,0xC0,0x15,0x69,0x1C,0x40,0x40,0xF1,0xA9,0xFF,0x75,0x79,0x39};
//const uint8_t spNOW[] PROGMEM = {0xAE,0x2A,0x92,0x7A,0x28,0x9D,0x86,0xA2,0x48,0xF4,0xA7,0x72,0x56,0xF2,0x2A,0xC8,0x5E,0xD2,0x5E,0xC9,0x2A,0x53,0x7E,0xB5,0xEA,0x27,0xEE,0xBA,0x3C,0xC4,0x3A,0x9E,0xA8,0xEB,0xC9,0x52,0xCD,0x78,0xA2,0xA6,0xB7,0x52,0xAD,0xE5,0x89,0x9A,0xBA,0x0E,0xB5,0x8C,0x27,0xE9,0x6A,0x27,0xCD,0x52,0x9E,0xAC,0xA9,0xED,0x32,0xCD,0x78,0xEA,0xAE,0xB6,0xD3,0x35,0xD7,0x69,0x9B,0xDE,0xCE,0x94,0xCE,0x6B,0xAC,0xEE,0x2A,0x93,0x36,0x8D,0xB1,0xB8,0xCD,0x08,0xDA,0x54,0xA7,0x32,0xA6,0x54,0x1E,0xA2,0xB7,0xC2,0x14,0x73,0x8B,0x85,0xDD,0x32,0x53,0xC8,0x2D,0x2E,0xFE,0xEA,0xFF,0x25,0x51,0x21,0x59,0x55,0x39};
//const uint8_t spNUMBER[] PROGMEM = {0xA6,0x0A,0x42,0x72,0xB9,0xDC,0x84,0x32,0x0A,0x89,0xA3,0x72,0x13,0xF2,0xC0,0x35,0x0E,0xDB,0x4D,0x49,0x13,0x57,0x3D,0xAA,0xA4,0x27,0xAE,0xAE,0xC3,0x25,0x12,0x9F,0xA8,0xBA,0x2D,0x37,0x4F,0x74,0x82,0x62,0xAF,0xC3,0x3C,0xD5,0xF1,0x8B,0xBD,0x0E,0xB5,0x44,0xCB,0xAF,0x72,0xAD,0x91,0xDC,0xAC,0xA0,0xCA,0xB1,0x46,0x4A,0x33,0x82,0x6C,0x46,0x03,0xA4,0x4B,0x8A,0xB2,0x0C,0x2B,0x90,0x2D,0x2A,0x33,0xD2,0xB2,0xC4,0x3E,0x8B,0xCA,0xCA,0xD2,0x10,0x5F,0xD5,0xAA,0xE2,0xDB,0x8C,0x65,0x53,0xAB,0x73,0x09,0x57,0xAE,0xDB,0x6D,0x28,0xB1,0xDC,0xC5,0x1F,0xB7,0x29,0x87,0xF0,0xD0,0xBE,0x94,0xE7,0xB0,0x64,0x1F,0x16,0x5A,0x53,0xEC,0xFA,0x79};
//const uint8_t spO[] PROGMEM = {0x2B,0xC9,0x21,0xCD,0x2C,0x1F,0xEE,0xE4,0xA4,0xC5,0x54,0x9A,0xE9,0xA6,0x9B,0xAE,0x2C,0xBB,0x4A,0x55,0xDB,0xB4,0xB3,0x95,0xA7,0xD4,0x2E,0xEA,0xAB,0x67,0xDE,0xF2,0x68,0xC7,0x4D,0x74,0x63,0x29,0x82,0x5E,0x4F,0xD4,0x9D,0xB9,0x08,0x95,0xB1,0xE7,0x2E,0xB6,0xD1,0x57,0xA6,0x52,0x69,0xD4,0xB5,0x16,0xAA,0xCA,0xB7,0x54,0xE1,0x1C,0xFD,0x69,0x61,0x79,0x19,0x61,0x72,0x79};
//const uint8_t spOCLOCK[] PROGMEM = {0x2B,0xAB,0xA6,0xC3,0x9D,0x37,0xAF,0x3C,0x87,0x0C,0x17,0x79,0xD5,0x8A,0x38,0x9D,0xDD,0x7A,0x16,0x2A,0x84,0x72,0x77,0x11,0xD9,0x00,0x00,0x06,0x28,0xA5,0x3B,0x00,0x5D,0x6B,0xA4,0x60,0x59,0x0D,0x09,0x55,0x32,0xBC,0xA4,0x35,0x4B,0xAD,0xD1,0x70,0x73,0xF6,0x16,0xD7,0x29,0x2B,0xCC,0xAD,0xCA,0x4D,0x67,0xAD,0x2C,0xF5,0xAE,0x50,0x9D,0x38,0x86,0xD4,0x3B,0x4B,0x65,0x65,0x98,0xD2,0x4B,0x75,0xF3,0xDA,0x64,0x12,0xCA,0xDD,0x45,0x64,0x03,0x00,0x00,0x28,0x20,0x15,0x23,0x02,0xE4,0xE4,0x8C,0x80,0x2C,0x07,0xFE,0x31,0x79};
//const uint8_t spOF[] PROGMEM = {0x2B,0x2E,0x6E,0x3A,0x95,0xBA,0x9C,0x28,0xFB,0xCB,0x10,0x5B,0x75,0xA3,0x13,0x67,0xFF,0xE5,0xAC,0xAB,0x57,0x92,0xE2,0x76,0x8A,0x36,0x1E,0x69,0x4A,0x5B,0x26,0xBE,0x78,0xD4,0x29,0x4D,0xBB,0xE8,0xE2,0xD4,0xC6,0x51,0x29,0x5A,0xB7,0xD2,0x10,0x72,0x8E,0x71,0xD7,0x72,0x63,0x52,0xE9,0xAE,0xDA,0xDA,0x8F,0x6E,0x2A,0x3A,0xDD,0x94,0x6D,0xEB,0xE9,0xFF,0x31,0x31,0x79};
//const uint8_t spOFF[] PROGMEM = {0xCD,0xCB,0x7E,0x52,0x55,0x1A,0xAD,0x28,0xFB,0x2B,0x33,0xCD,0x74,0x83,0x13,0x66,0xF7,0xA5,0x6A,0xAD,0x56,0x5C,0xF4,0x4E,0x38,0x75,0x6E,0x79,0x0A,0x5B,0xA6,0xF2,0x28,0xB5,0xA1,0x8E,0x9B,0xC5,0xEC,0xD0,0x27,0x97,0x19,0x6A,0x8D,0x14,0x50,0x6C,0x87,0x00,0x9A,0x6D,0x67,0xC0,0x34,0xE9,0x04,0x98,0xA6,0x82,0x00,0xCD,0x55,0x10,0xA0,0x9B,0x70,0x04,0x54,0x53,0xFE,0x11,0x19,0x79};
//const uint8_t spOLD[] PROGMEM = {0xA9,0x68,0x21,0xBC,0x44,0x1A,0xAF,0xB2,0x98,0x88,0x34,0x7D,0xBC,0xCB,0x55,0xA5,0x54,0xA6,0x1A,0xB7,0x56,0x9D,0x5D,0xBA,0xB1,0x3E,0x1E,0x75,0x8C,0x11,0x42,0xFD,0x78,0xD6,0xA3,0x89,0xAA,0xC3,0x94,0x37,0xF7,0xA6,0x34,0xD1,0x58,0x1B,0x4B,0xDF,0xDA,0xA4,0xBA,0x58,0xEC,0x04,0x4F,0x9F,0xEB,0x5C,0x87,0x2A,0x59,0x2E,0xC7,0x74,0x1F,0xDA,0x5C,0x28,0xCC,0x5C,0x0B,0x19,0x85,0x72,0x77,0x11,0xD9,0xE0,0xFA,0x6D,0xDC,0xC5,0xD4,0x4D,0xEA,0x9B,0x17,0x77,0x73,0xDB,0xFF,0x39,0x79};
//const uint8_t spON[] PROGMEM = {0x25,0x2A,0xF6,0xC6,0xD4,0xE3,0x9C,0xB0,0x89,0xDD,0x14,0x4B,0x7C,0x82,0x2A,0x6E,0x8D,0xA3,0xD6,0x09,0x8A,0xFC,0x51,0xCE,0xD8,0x37,0x3A,0x71,0x76,0x37,0xAA,0xDE,0xF8,0x64,0x39,0xDE,0xA8,0x7A,0xE3,0xD5,0xA4,0x71,0x29,0xEE,0xB5,0x4B,0x5F,0xDC,0x26,0x9B,0x2D,0x29,0x43,0xB6,0x15,0xC2,0x91,0x38,0x0C,0x91,0xA7,0x47,0x58,0xE3,0x30,0x06,0xE9,0x51,0x9A,0x8D,0xDD,0x14,0x94,0x7B,0x69,0xA6,0x76,0x63,0x94,0x1A,0x23,0x9E,0xDA,0x8D,0x51,0x9A,0xBB,0x56,0x9A,0xFF,0x4D,0x19,0x39,0x79};
//const uint8_t spONLY[] PROGMEM = {0x29,0x2B,0xC1,0xDD,0xA4,0x66,0x9F,0xA8,0xEB,0xB2,0x34,0xD9,0x7C,0xA2,0xA6,0xDA,0x5C,0xA5,0xD5,0x09,0x9B,0x2C,0x73,0xD5,0x4D,0x2B,0xC8,0xAA,0xD5,0x2D,0x5E,0x0E,0x3F,0xA9,0x88,0x50,0xDB,0x34,0x82,0xA2,0xC2,0x1A,0x35,0x5D,0x0B,0x0A,0x17,0x5B,0x75,0xF7,0x25,0x2A,0x92,0x62,0x34,0xDC,0xA7,0x28,0x49,0xEA,0xD4,0x4A,0x92,0xB2,0x28,0xB9,0xCD,0x3B,0x51,0xC9,0x33,0x97,0x48,0xAD,0x96,0xB9,0x68,0x75,0xB6,0x6A,0x19,0x5B,0x79,0xF4,0xCD,0x99,0xBA,0xD7,0xE2,0x36,0x34,0xA3,0x96,0xD5,0xB3,0xDD,0x58,0xB4,0x7A,0xE7,0x46,0xB2,0xD3,0xFF,0x25,0x79};
//const uint8_t spOR[] PROGMEM = {0x25,0xCA,0xEC,0xCA,0x8C,0xF2,0xB4,0x28,0x93,0x4F,0x53,0xEE,0x39,0xA2,0x4C,0xBE,0x44,0x35,0x67,0x8B,0x0B,0xDA,0x15,0xF1,0x5C,0x23,0x29,0x70,0xD7,0xD5,0x7C,0xCF,0xA4,0x65,0x89,0xDC,0xBA,0x98,0x9F,0x96,0x17,0x3C,0xEB,0x22,0x7E,0x5A,0x93,0x69,0xAF,0x07,0xE5,0x2D,0x5D,0x12,0xB3,0xEA,0xD4,0x37,0x8D,0x51,0xEF,0x88,0xF3,0x9E,0x30,0x06,0xB7,0x2D,0xC6,0x9B,0xFF,0x05};
//const uint8_t spP[] PROGMEM = {0x0E,0x18,0x5D,0x29,0x79,0x95,0x93,0x6E,0x8D,0x98,0xE1,0x4E,0xC3,0x54,0x35,0x76,0x97,0xBB,0x8C,0x81,0xF7,0xD4,0x19,0xF1,0x75,0x01,0x5C,0x3B,0x7B,0x64,0x3B,0x05,0x50,0x4E,0xED,0xD6,0xEC,0x68,0xC0,0xBD,0x95,0x7B,0x97,0x87,0x38,0xFD,0x25,0x51,0x15,0x51,0x59,0x41,0x25,0x41,0x05};
//const uint8_t spPARAMETER[] PROGMEM = {0x04,0xD0,0xA2,0x3D,0xA5,0xC5,0xA7,0x9B,0x6B,0xCD,0x91,0xE6,0x21,0x85,0xE3,0x71,0x7B,0xDA,0xB2,0x1C,0xB8,0x38,0x3C,0x6E,0xCA,0xD2,0xC5,0x32,0xF5,0xB6,0x31,0x6B,0x69,0x39,0x6C,0x61,0xE9,0x65,0x45,0xA5,0x5B,0x71,0x45,0xA3,0x13,0xD4,0x9C,0x11,0x9A,0x8D,0x4E,0xD0,0xEC,0x46,0xBA,0xD5,0x5A,0x49,0x89,0x9E,0x42,0x39,0xB9,0xE4,0xC9,0x49,0x31,0x74,0xBB,0x92,0x67,0x23,0xA5,0x50,0xDD,0x4A,0x9E,0x8C,0xB4,0x42,0xAE,0x3B,0x65,0x2D,0x5E,0xC6,0x3E,0xA5,0xB5,0xD5,0x69,0x28,0xC7,0x62,0xD2,0x0A,0xE5,0xEE,0x22,0xB2,0x41,0x01,0x9B,0x65,0x1A,0xA0,0xE0,0xF0,0xD6,0x24,0xEF,0x96,0xDA,0xB5,0xCE,0xD0,0x82,0x7B,0xAA,0xAE,0x1E,0x53,0x4D,0x15,0xA1,0xF2,0xB8,0x8D,0x25,0x57,0x84,0xEA,0xE2,0x32,0x96,0x9C,0x11,0xEC,0x93,0xFF,0x51,0x61,0x39,0x51,0x05};
//const uint8_t spPENCE[] PROGMEM = {0x02,0x28,0x46,0xAA,0xB9,0x23,0x1B,0xBB,0x69,0x98,0xE5,0x17,0x2B,0x59,0x96,0x71,0x4F,0xB0,0xC2,0x88,0xA5,0x34,0x3E,0xC9,0x76,0x23,0x96,0xDA,0xE8,0x64,0xC7,0x8E,0x7B,0x48,0xA3,0x55,0x4E,0x53,0x12,0x26,0x89,0x5B,0xDD,0x94,0x4B,0xA9,0xC4,0x29,0x6D,0x51,0x6A,0xC5,0x19,0x27,0xF5,0x45,0xB1,0xAF,0x78,0x5C,0xD5,0x27,0x21,0xB9,0x16,0x95,0x09,0x90,0x61,0x1A,0x01,0x3E,0x43,0x16,0xC0,0x67,0x22,0x0A,0xF8,0x4C,0x4D,0x01,0x9F,0xAA,0x09,0xE0,0x53,0x55,0x02,0x7C,0xA9,0xFC,0x51,0x65,0x41,0x51,0x19,0x05};
//const uint8_t spPLEASE[] PROGMEM = {0x06,0xC8,0xD6,0x4C,0x01,0x45,0x8B,0x05,0xFB,0x18,0x56,0xAA,0x70,0xD2,0x82,0xC3,0x95,0x2D,0x7D,0xF5,0x0C,0x96,0xB7,0xB5,0x81,0xB6,0x36,0x59,0xC1,0xB4,0x06,0xDA,0x55,0x65,0x25,0xCB,0x1B,0xE8,0x76,0xED,0x91,0xCD,0x44,0x50,0xD3,0x95,0x47,0x31,0x87,0x82,0x76,0xCD,0x6A,0xED,0xEA,0x06,0x3C,0xDD,0x28,0x75,0xAB,0x3B,0x50,0xF5,0xAC,0xD4,0xCF,0xA1,0xC0,0x5D,0xB3,0x52,0x3F,0xBB,0x01,0x77,0xD5,0x2E,0xFD,0x6C,0x06,0xDC,0x35,0x3B,0xF5,0x33,0x0B,0x68,0xF7,0xEC,0xD4,0x8F,0x20,0x60,0xD9,0xB3,0x53,0xDF,0xA4,0x50,0x7A,0x57,0x0E,0x5D,0xC7,0xC1,0xE1,0x39,0xDB,0xB4,0x5F,0x93,0xB8,0x64,0x13,0xDB,0x32,0x60,0x01,0x32,0x02,0x7C,0xC1,0x8A,0x80,0xAF,0x44,0x10,0xF0,0x8D,0x39,0x02,0xBE,0x90,0xFA,0x65,0x55,0x19,0x05};
//const uint8_t spPLUS[] PROGMEM = {0x02,0xF0,0xD6,0xCC,0x01,0x51,0x8B,0x8D,0xA2,0x29,0x65,0x4B,0x5F,0x3D,0x8B,0x51,0x34,0xB3,0x99,0x2E,0x0B,0x4F,0xD9,0xF4,0x66,0x84,0xB6,0x3C,0x75,0x35,0x93,0x91,0x92,0xE9,0x54,0xCD,0x4C,0x65,0x72,0xAB,0x55,0x95,0xE0,0x15,0x1C,0xB5,0x5B,0x3D,0x49,0x86,0x9B,0x79,0x52,0xC0,0xC5,0x1C,0x1A,0xD0,0x80,0x06,0x04,0xF0,0x04,0xF9,0xFF,0x15,0x39,0x49,0x79,0x05};
//const uint8_t spPOINT[] PROGMEM = {0x02,0xC8,0x5A,0x5C,0x00,0x45,0x4E,0x25,0xB7,0xF0,0x2C,0x4D,0x74,0xDC,0xDC,0xD8,0x26,0xDD,0x65,0xE6,0x70,0x93,0xDF,0xCA,0xA0,0x8E,0xD3,0x5D,0x5E,0x0E,0x9B,0x19,0xD4,0xF2,0x64,0xD3,0x94,0x69,0x51,0xAA,0x53,0xAC,0x34,0x4A,0x65,0xB5,0x4A,0x3B,0x32,0x69,0x85,0x5B,0x2B,0x7D,0x57,0x6A,0x59,0xE4,0xC6,0x0C,0x45,0xA8,0xB6,0x69,0x5A,0x32,0x09,0xE5,0xEE,0x22,0xB2,0x01,0x00,0x14,0x70,0x45,0x9A,0x06,0x10,0xD0,0x7C,0xC3,0xFF,0x51,0x35,0x49,0x15,0x49,0x65,0x79,0x05};
//const uint8_t spPOSITIVE[] PROGMEM = {0x02,0xF0,0x3E,0xA5,0x45,0x45,0x57,0x5A,0xB0,0xEA,0x15,0xA4,0x56,0xAA,0xA6,0x35,0x57,0x90,0xCA,0x54,0x3A,0xA7,0x3C,0x41,0x8E,0x5B,0x61,0x92,0x69,0x87,0x23,0xAA,0xFC,0xC4,0xC4,0x56,0x05,0x20,0x81,0x8D,0x94,0x5D,0xAC,0x21,0xAA,0x6E,0x56,0x32,0x49,0x8A,0x99,0x6D,0x3A,0xE9,0xE0,0x2E,0x1E,0xB6,0xAA,0x15,0x4D,0x98,0xB8,0xC5,0x22,0x32,0x08,0xE5,0xEE,0x22,0xB2,0x41,0x01,0x57,0xB2,0x19,0x60,0x33,0xB5,0x92,0x54,0x66,0x52,0x13,0xB5,0x47,0x3D,0x9C,0xA1,0x67,0x34,0x6E,0x43,0xF7,0xCC,0x99,0x31,0x3B,0xCD,0xCD,0x91,0x56,0xE4,0x9C,0xB0,0x14,0xE3,0xA6,0xAE,0xBB,0xDD,0x5A,0xAD,0x9A,0x39,0xF7,0x41,0x40,0xB3,0x6A,0xFF,0x5A,0x39,0x55,0x79,0x05};
//const uint8_t spPOUN_[] PROGMEM = {0x04,0xA0,0x4E,0x54,0x01,0x2E,0x98,0x36,0x2B,0xD9,0x09,0x0F,0xAA,0xB5,0x9C,0xBC,0xB2,0x5C,0xA3,0xF4,0xF1,0x4B,0xED,0x4C,0xB3,0x45,0x27,0xC8,0x75,0x32,0x4D,0x17,0x9E,0xA8,0xC4,0xCD,0x32,0x69,0x79,0xE2,0x92,0xB6,0xD2,0xB9,0xE3,0x48,0xF3,0x88,0x51,0xCE,0xCA,0x2D,0xCF,0x23,0xD5,0x35,0x67,0xB6,0x32,0xE5,0x52,0xB3,0x5C,0x59,0x9A,0x94,0xD2,0xC5,0x62,0x63,0xEA,0x62,0xB6,0x42,0xED,0x46,0xA9,0x2F,0x8A,0xBA,0x28,0xB2,0xA4,0xA1,0x48,0xAA,0xE5,0x48,0x1B,0x86,0xA4,0xA4,0x82,0x3D,0x4D,0x1C,0xFC,0xE0,0x87,0xFF,0x65,0x65,0x51,0x25,0x05};
//const uint8_t spPRESS[] PROGMEM = {0x04,0xA8,0x34,0x9D,0x01,0x2D,0x44,0x0A,0x20,0xF7,0xAC,0x60,0xA7,0x2E,0xA6,0xE6,0x76,0xAA,0xBB,0xBC,0x3C,0x28,0xBD,0xAC,0xC9,0xF1,0x6B,0x31,0x37,0xD7,0x35,0x27,0x6A,0x21,0x34,0xC2,0x56,0x9F,0x7C,0xF8,0x12,0x0B,0x59,0x7D,0x9A,0x19,0x4A,0x34,0x65,0xCD,0x6A,0x87,0x77,0x89,0xD4,0x25,0xA9,0x6F,0x8E,0x7C,0x3C,0xEA,0x08,0x20,0x73,0x53,0x01,0x7C,0x25,0xC6,0x80,0x4F,0xD5,0x08,0xF0,0x0D,0x1B,0x03,0xBE,0x21,0x63,0xC0,0x57,0x6C,0x04,0xF8,0x42,0x92,0x00,0x4F,0x90,0x22,0xE0,0x7B,0x56,0x04,0x7C,0x47,0x82,0x80,0xEF,0x84,0x11,0xF0,0x03,0xE9,0xFF,0x59,0x41,0x25,0x71,0x79,0x25,0x05};
//const uint8_t spPROGRAMME[] PROGMEM = {0x0C,0x48,0x2E,0x95,0x03,0x2E,0x0A,0x8D,0x3D,0xDA,0x13,0xD5,0x68,0xF9,0xA9,0x73,0x68,0xC7,0x94,0x13,0x94,0x62,0xA9,0xC6,0xAB,0x4F,0x50,0x63,0x84,0x19,0xAD,0x3E,0x41,0x0B,0xEE,0x6E,0xB8,0xE9,0x04,0xD5,0x69,0x84,0xF0,0xAB,0x11,0x66,0xE7,0x66,0x22,0xAF,0x5C,0x14,0xA3,0x2B,0xAB,0x2E,0x34,0xA9,0x54,0x19,0x1D,0x96,0x4A,0xE5,0x3E,0xAB,0xB8,0x44,0x9C,0x50,0xA7,0x66,0x21,0xA4,0x71,0x52,0x95,0x33,0x17,0x66,0xA7,0x1D,0x75,0x69,0x1A,0x94,0xE9,0x75,0xB5,0xA5,0xA9,0x9B,0xE7,0x9A,0x33,0xB4,0xD8,0xE1,0xC1,0x5D,0xCE,0xD8,0xFC,0x44,0x24,0x75,0x3E,0x53,0x8B,0xE5,0x19,0xBC,0x78,0xCC,0x35,0x76,0x64,0xF2,0xED,0x36,0xD7,0x54,0x51,0xCE,0xB3,0xEB,0x1C,0xE6,0xEC,0x34,0x0C,0xAC,0x89,0x9F,0xED,0xF2,0x45};
//const uint8_t spQ[] PROGMEM = {0x0E,0x58,0x5E,0xD8,0x00,0x3B,0xAA,0x3A,0x60,0xB5,0xF1,0x16,0xF4,0x82,0x54,0xD1,0x65,0x5A,0x3C,0xB4,0x42,0x6E,0x2F,0xDA,0xF1,0x8A,0x9B,0x0C,0xF6,0xF0,0xD5,0x2B,0x29,0x7C,0x54,0x59,0x5F,0xED,0x64,0xA4,0x59,0x1C,0x93,0xFA,0xA6,0x52,0x24,0xB1,0xAA,0x6C,0xAF,0x42,0xE5,0xC5,0x89,0x44,0xAE,0x76,0x95,0x36,0xC7,0xEA,0xB9,0xCA,0x34,0x4A,0xBF,0x70,0xE4,0x12,0xD3,0x28,0xF5,0x2C,0x11,0x8B,0x55,0x2B,0xC2,0xB2,0x69,0x2E,0x96,0xED,0xFF,0x25};
//const uint8_t spR[] PROGMEM = {0x23,0x2C,0xEE,0x2A,0x8C,0x57,0xAE,0x28,0xC7,0x4F,0x33,0x5D,0xB8,0xB2,0xEC,0xAF,0xD2,0x78,0xD5,0xCE,0x46,0x53,0xCC,0x74,0x25,0x6E,0xEE,0x7D,0x19,0xAA,0xDA,0xF1,0xC4,0xCD,0x7D,0xE8,0x73,0x9F,0xFB,0x5C,0x86,0xA2,0x7F,0x2C,0x79,0x55,0x1D,0xD2,0x98,0xE6,0xA6,0xAB,0x8D,0xCE,0xE3,0xFF,0x11,0x51,0x25};
//const uint8_t spRED[] PROGMEM = {0xAA,0xE6,0xBE,0x2D,0x32,0x1C,0x9B,0x4A,0xB8,0x36,0x77,0x73,0x62,0x0A,0x9E,0xDD,0x3C,0xC2,0xB1,0xCB,0x64,0x08,0xF5,0x8C,0xC6,0x29,0x76,0x8D,0x2C,0x3D,0x5A,0x8F,0xA0,0x78,0x0E,0x6F,0x5F,0x74,0xFD,0xE3,0x8F,0x60,0x6A,0xE9,0xAD,0x4F,0x38,0x6D,0x8A,0xA5,0xB7,0x3A,0xF1,0x30,0xCE,0x59,0xB9,0xF8,0x64,0x23,0x38,0x47,0x46,0x93,0x53,0x77,0x67,0x12,0x15,0x4B,0x4E,0xD7,0x9C,0x89,0x77,0x2E,0x1A,0x7D,0x73,0x62,0x56,0x35,0xC9,0x8D,0xCD,0x90,0x86,0x57,0x2D,0x35,0x24,0x49,0x9A,0xD9,0x91,0xC8,0x20,0x94,0xBB,0x8B,0xC8,0x06,0x37,0x6D,0xE3,0x2E,0xA6,0x6E,0xD2,0xD0,0xBC,0xB8,0x9B,0xDB,0xFE,0x15,0x51,0x65,0x51,0x25};
//const uint8_t spRESET[] PROGMEM = {0xAA,0xF0,0x4D,0x54,0x22,0x5B,0xFB,0xAC,0xC5,0x49,0x53,0x66,0x5A,0xCB,0x15,0x76,0xCB,0xA8,0x1B,0xAD,0x56,0x70,0x8C,0x21,0xCF,0x34,0xDA,0xC1,0x76,0x9B,0xBB,0xAC,0x83,0xCC,0x34,0x72,0x7E,0x93,0x42,0x39,0x3D,0x4B,0x01,0x17,0xBB,0x69,0x40,0x00,0x8F,0x85,0x09,0xE0,0xCA,0x0C,0x01,0x5C,0x16,0x29,0x80,0x2B,0x23,0x0C,0xB0,0x69,0x7A,0x2B,0xAA,0x16,0x1B,0xA9,0xD8,0xAB,0x6F,0x56,0x75,0xDC,0x67,0xAF,0xA1,0x7B,0x93,0x4A,0x5B,0x3C,0xC6,0x91,0x42,0xD3,0x74,0x71,0x9A,0xAA,0x93,0x68,0xEB,0x29,0x6C,0x11,0xCA,0xDD,0x45,0x64,0x03,0x28,0x60,0x28,0x77,0x01,0x3C,0x23,0x29,0x80,0x6B,0xD4,0x09,0xB0,0x98,0x27,0x02,0x0A,0x2D,0xFB,0x39,0x25,0x55,0x15,0x51,0x25};
//const uint8_t spRETURN[] PROGMEM = {0xA1,0x8A,0x26,0xD5,0x38,0xB3,0xA4,0x3C,0x26,0xF2,0x08,0xEB,0x3D,0x92,0xEC,0x29,0x2D,0x63,0xD3,0x4A,0x9A,0x27,0xD7,0x8A,0x8E,0xA1,0x6B,0x91,0x8C,0xAD,0x12,0x93,0x4C,0x28,0x77,0x17,0x91,0x0D,0x00,0x06,0x58,0xCA,0xDC,0x01,0x1D,0xB5,0x35,0xBF,0xB0,0x90,0x88,0xA8,0x75,0xFC,0x64,0xDD,0xCB,0xAA,0xD6,0xF1,0x9B,0x0F,0x77,0xD5,0x56,0xC7,0x6F,0xA1,0x23,0x45,0x33,0x9D,0xA0,0xFA,0xF6,0x54,0x6B,0x79,0xA2,0xEA,0xCB,0x42,0x7D,0xD5,0x49,0x6A,0xEC,0x70,0xD5,0x56,0x27,0x6F,0xBE,0x3D,0xC5,0x5A,0xAE,0xAA,0xA6,0x48,0x97,0x58,0xB4,0xBA,0xE6,0xCB,0x53,0xB5,0x65,0x19,0x4A,0xF0,0x70,0xA9,0x49,0x69,0x2C,0x31,0xDC,0x34,0x27,0xA5,0xA9,0xC6,0x0A,0x33,0xAF,0x95,0xE6,0x16,0x23,0xC5,0x3D,0x51,0x98,0x9A,0x13,0x33,0x89,0x44,0x61,0x6A,0xCC,0x34,0x52,0xDD,0xFC,0x39,0x55,0x25};
//const uint8_t spRUN[] PROGMEM = {0x22,0x11,0xAE,0x5C,0xA3,0x94,0x98,0x4A,0xB8,0x0E,0xF7,0x92,0x67,0x0A,0x1E,0xDB,0x4D,0x5B,0xA9,0xC9,0x79,0x49,0xD3,0x0C,0x27,0x21,0x35,0x49,0xCD,0xBB,0xD8,0x8E,0x38,0x35,0x71,0x2D,0xF7,0x70,0xE2,0x12,0x2F,0xDD,0xB5,0xD1,0x49,0xAA,0xBD,0x72,0xB7,0x96,0x27,0x6B,0x76,0x2B,0xC2,0x5A,0x9D,0xA2,0x86,0xAE,0x50,0x6B,0x54,0xFA,0x62,0x2C,0x42,0x3C,0x76,0x1A,0xB2,0x36,0x0B,0xF5,0x46,0x61,0xC8,0x4A,0xB3,0xD8,0x12,0x87,0x21,0x49,0x8D,0x21,0x4F,0x13,0x86,0xA4,0x24,0x5A,0x3C,0x75,0x1A,0x8B,0x0D,0x53,0xF5,0xD8,0xFF,0x71,0x39,0x49,0x39,0x39,0x55,0x25};
//const uint8_t spRUNNING[] PROGMEM = {0x22,0x11,0xAE,0x5C,0xA3,0x94,0x98,0x4A,0xB8,0x0E,0xF7,0x92,0x67,0x2A,0x1E,0xDB,0x4D,0x5B,0xA9,0x29,0x78,0x49,0xD3,0x0C,0x27,0x21,0x37,0x49,0xCD,0xBB,0xD8,0x8E,0x38,0x35,0x71,0x2D,0xF7,0x70,0xA2,0x92,0xB3,0xCC,0x35,0xD5,0x89,0x6A,0xD8,0x0C,0x8D,0x94,0x27,0x6C,0x7E,0x32,0x38,0x5D,0xAE,0xB0,0x7B,0x0F,0xC5,0xF6,0xD8,0xA2,0xCA,0x4D,0x9A,0x5B,0x75,0x49,0x0B,0x75,0x59,0x2A,0xB5,0x2B,0x99,0xCE,0xD1,0x7D,0x22,0x8F,0x7A,0x78,0x25,0xCF,0xA9,0x3C,0xBA,0x15,0x1A,0xA5,0xAA,0x52,0x1A,0x66,0x12,0xE8,0xAE,0xD0,0x7A,0x52,0x53,0x96,0x1A,0x45,0xD6,0x54,0x4D,0x49,0x6A,0x1A,0x79,0x56,0x35,0x66,0xC5,0xE5,0xE4,0x59,0xD4,0x10,0x95,0x95,0x6A,0x64,0xD6,0x83,0x1D,0x5C,0x5F,0x9C,0x4B,0x88,0xD9,0xF1,0x03,0x02,0x9C,0x51,0xFD,0x65};
//const uint8_t spS[] PROGMEM = {0x2D,0x9E,0xC9,0x85,0x3B,0x16,0xAF,0x68,0x87,0x31,0x4A,0x6B,0x74,0xC2,0xA5,0x8B,0xA4,0xA3,0xD1,0x89,0x96,0x4E,0xF2,0xF1,0x46,0x27,0x99,0x26,0xC9,0xC7,0x17,0x9F,0x62,0x85,0x11,0x69,0x6D,0x7D,0xEA,0x11,0x82,0xBD,0x74,0xF5,0x6A,0xBB,0x57,0xA9,0xF0,0x25,0x0C,0x08,0x46,0x52,0x00,0xDF,0xA7,0x69,0x40,0x01,0xDF,0xA5,0x71,0x80,0x00,0x3F,0xA4,0x51,0x00,0x01,0x3F,0xA5,0x61,0x00,0x03,0xFF,0x51,0x59,0x41,0x65};
//const uint8_t spSAME[] PROGMEM = {0x02,0xB8,0x54,0xCC,0x02,0x06,0x38,0x8C,0xDD,0x02,0x27,0x5D,0x22,0xB0,0xB5,0x2A,0x9D,0x74,0xA9,0xE2,0xB4,0xAA,0x75,0x92,0x69,0x8A,0xD2,0xB2,0xD6,0x49,0xA7,0x4A,0xAE,0xA8,0xDA,0x27,0x9D,0x26,0x29,0xB3,0x6A,0x9F,0x72,0xB9,0x42,0xF3,0xAE,0x7D,0xEA,0x19,0x13,0x35,0xA6,0xCE,0xEA,0x86,0x17,0xF4,0x9E,0x3A,0x6B,0x9A,0xCE,0x40,0xBB,0x67,0xB7,0x69,0x38,0x45,0xAB,0x9A,0xE5,0xE6,0x2A,0x44,0x2A,0xBD,0x89,0x5B,0x93,0x96,0x0C,0xF4,0xB5,0x6E,0x4D,0x9A,0xAA,0xD8,0x93,0xD8,0x35,0xCC,0xD9,0x70,0x1B,0x79,0xDB,0xFF,0x51,0x25,0x79,0x61,0x65};
//const uint8_t spSCORE[] PROGMEM = {0x06,0xF8,0x46,0xCB,0x00,0x4F,0x79,0x28,0xE0,0x3B,0x75,0x03,0xFC,0xE0,0xE1,0x80,0xEB,0xAC,0x11,0x28,0x94,0xBB,0x8B,0xC8,0x06,0x05,0xA4,0x51,0xC4,0x80,0x78,0x87,0x8B,0x17,0xF3,0x90,0x9A,0x37,0x3A,0x6E,0xC1,0xD3,0x96,0x94,0xFB,0x78,0x05,0xF5,0x78,0xB1,0xDF,0x13,0x64,0xB2,0x6D,0x41,0x79,0x4E,0x94,0xE9,0xB6,0x39,0xE5,0x59,0x99,0xF7,0x97,0x66,0xB2,0x69,0x14,0x3E,0x4E,0xB8,0xC8,0xAA,0x52,0xFB,0x5C,0x95,0x68,0xAF,0x4B,0x6B,0x7A,0x47,0x50,0x5E,0x2E,0x9D,0xA9,0x55,0x41,0xB1,0xB8,0x74,0x3E,0x66,0x27,0xE9,0x9A,0xD6,0x7B,0xDF,0x55,0xC2,0x5D,0x5B,0x1F,0x5C,0x75,0x33,0x6F,0x6D,0x7D,0xF4,0x55,0xC9,0xB2,0xA5,0x75,0xC9,0x59,0x85,0xFA,0xE6,0x3A,0xFC,0x11,0x39,0x79,0x61,0x51,0x65};
//const uint8_t spSECOND[] PROGMEM = {0x02,0xD8,0xD4,0x53,0x01,0x97,0x6B,0x28,0xE0,0x4B,0x8B,0x62,0x1F,0x92,0xE6,0xA1,0x8E,0x8F,0x5B,0x9D,0x6B,0x6A,0xCD,0x3E,0x7E,0x0F,0xA5,0xA9,0x56,0x7B,0xC5,0x2D,0xB9,0x96,0xE4,0x1C,0xE4,0x0B,0xE5,0xEE,0x22,0xB2,0x01,0x04,0x90,0x7B,0x50,0x29,0xB3,0x73,0x36,0xF7,0x2A,0xA5,0x2D,0x21,0x54,0xB9,0x2E,0xA7,0xBE,0xD8,0x70,0xE3,0xD8,0xE4,0xC6,0x24,0xCD,0x9A,0xB2,0xB5,0x9B,0xB2,0x11,0x0F,0xF2,0xCC,0x66,0xCA,0xCA,0xCC,0xD9,0x72,0x9B,0xB1,0x08,0xD1,0xB2,0xD0,0x62,0xC6,0xC4,0xCD,0xDA,0x3C,0x35,0x02,0x85,0x72,0x77,0x11,0xD9,0x10,0xA6,0x11,0x22,0xA2,0x44,0x76,0x98,0xB6,0x71,0x17,0x53,0x37,0xFF,0x19,0x19,0x41,0x59,0x65};
//const uint8_t spSMALL[] PROGMEM = {0x04,0xF8,0x8A,0x85,0x03,0x12,0x10,0xC0,0xB7,0xA6,0x26,0x0E,0x3E,0x2C,0x50,0xBB,0xD8,0x38,0x46,0x35,0x6C,0x41,0x56,0xE2,0x43,0xD2,0x6C,0x04,0x99,0x67,0x96,0x51,0x9E,0x15,0x24,0x36,0x6D,0xAA,0x79,0x4F,0x98,0xF8,0xB6,0xAA,0xE5,0x59,0x51,0x12,0xDB,0xA6,0x9C,0x67,0xA5,0x89,0xED,0x98,0x5A,0x9E,0x91,0x67,0x3A,0xAB,0xAA,0x7E,0x47,0x9D,0xD8,0xAE,0xBB,0xF8,0x1B,0x43,0x25,0xB9,0x9E,0xE4,0x2F,0x8D,0x51,0xCC,0x7A,0x43,0xDF,0x30,0xFB,0x32,0x69,0x2A,0x3B,0xC3,0xEC,0x73,0xA7,0x1A,0xEF,0x4E,0xB3,0x8F,0xD1,0x2E,0xD2,0x37,0x4D,0x21,0xF8,0x04,0x5B,0xD6,0x30,0x46,0x6F,0xEB,0x22,0xD9,0xDC,0x18,0xA2,0x8F,0x61,0x65,0x31,0x63,0x72,0x36,0x09,0x91,0xF6,0xFF,0x15,0x25,0x41,0x15,0x65};
//const uint8_t spSTART[] PROGMEM = {0x08,0xD8,0x50,0x05,0x01,0x5F,0xB1,0x12,0xE0,0x33,0x55,0x06,0x7C,0xEE,0x66,0x80,0x6F,0x54,0x19,0xF0,0x65,0x18,0x07,0x10,0x28,0x94,0xBB,0x8B,0xC8,0x06,0x03,0x6C,0x96,0x36,0x9C,0xAA,0xD3,0x5D,0xBC,0xD3,0xF1,0x8A,0x52,0x6F,0xE9,0x28,0x27,0x28,0xF1,0x32,0x24,0x3C,0x9D,0x28,0xC7,0x4B,0x97,0xF0,0x74,0xD2,0x9C,0xAE,0x4D,0x23,0xE3,0x2D,0x56,0x95,0xF3,0xB6,0x85,0x76,0x5A,0x5D,0x2E,0xDB,0x1A,0xB6,0x6A,0x8C,0xB9,0x4C,0xAA,0xEB,0xC2,0x36,0x95,0x18,0x15,0x2A,0x0B,0xCB,0x54,0x83,0x8E,0x9B,0xB4,0x24,0x93,0x50,0xEE,0x2E,0x22,0x1B,0x00,0x18,0x70,0x94,0x3A,0x03,0x5E,0x66,0x53,0xC0,0x51,0x96,0x04,0xD8,0x42,0x02,0x01,0x8D,0xBA,0xFD,0x05,0x79,0x15,0x65};
//const uint8_t spSTOP[] PROGMEM = {0x08,0xF8,0x92,0x8D,0x00,0x5F,0x89,0x32,0xE0,0x6B,0x35,0x01,0x7C,0xAD,0x2A,0x80,0xEF,0x55,0x04,0xF0,0xA3,0x08,0x01,0xBE,0x13,0x46,0xA0,0x50,0xEE,0x2E,0x22,0x1B,0x1C,0xB0,0x8D,0xD5,0x70,0x9B,0xCE,0x10,0xB3,0x4E,0x27,0xCC,0xB1,0x3D,0x59,0x33,0x9F,0x38,0xC7,0xA9,0x74,0xD3,0x7D,0xB3,0x51,0xA4,0x58,0x9D,0xC9,0xB9,0x51,0x23,0x94,0xBB,0x8B,0xC8,0x06,0x00,0x60,0x80,0x57,0x96,0x04,0xC8,0xCE,0x1D,0x01,0x79,0x84,0x22,0xC0,0x3B,0xF7,0xFF,0x09,0x61,0x15,0x49,0x75,0x65};
//const uint8_t spSWITCH[] PROGMEM = {0x08,0xB8,0x84,0x95,0x01,0x5F,0x73,0x30,0xE0,0x73,0x0B,0x01,0x7C,0xE9,0xA6,0x80,0x2F,0x22,0x05,0xF0,0xB5,0xB8,0x02,0xBE,0x51,0x53,0xC0,0x6F,0x66,0x02,0xE8,0x3A,0x2B,0x78,0x89,0x47,0xB8,0x89,0x97,0xE2,0x47,0xB5,0x2A,0xA1,0x9F,0x4E,0xD0,0x69,0xAA,0x25,0xAD,0x3E,0xD1,0x94,0xC1,0x3A,0xBA,0xF9,0x14,0x33,0x05,0x69,0xD9,0xE2,0x52,0x0F,0xAF,0xA4,0x59,0x8F,0x51,0x23,0x94,0xBB,0x8B,0xC8,0x06,0x00,0x02,0x74,0x69,0x2E,0x80,0xD3,0x42,0x0C,0x70,0xC6,0x84,0x03,0x76,0x9B,0x72,0xC0,0x1A,0x9B,0x06,0x58,0xF5,0xDC,0x01,0x73,0x6D,0x1A,0x60,0x95,0x4E,0x01,0x8C,0xA8,0x42,0x80,0xAA,0x4C,0x10,0x10,0xA5,0xE9,0xFF,0x15};
const uint8_t spT[] PROGMEM = {0x0E,0x38,0xC2,0xD4,0x00,0x57,0xB5,0x36,0x77,0x29,0x26,0xCF,0xB6,0xBD,0xBC,0xE5,0x0C,0xA4,0xA7,0xF6,0xF2,0x97,0x53,0xB0,0xD9,0xC6,0x3B,0x5C,0xC9,0x76,0x0A,0x32,0x5B,0x7B,0x66,0xA3,0xDC,0x41,0x50,0x7A,0x6A,0xB7,0x66,0x27,0x45,0xDA,0x89,0x53,0xFA,0x95,0x18,0x79,0x27,0x4E,0x19,0x56,0x20,0x94,0xEB,0x3A,0x75,0x4C,0xE3,0x74,0x48,0xFE,0x15,0x27,0x8E,0x71,0x74,0xE3,0xF0,0x20,0x3D,0x15,0xC5,0x0D,0xCD,0xA0,0x6E,0x8F,0xED,0xFF,0x39,0x51,0x15};
//const uint8_t spTEN[] PROGMEM = {0x0E,0x38,0xD4,0x53,0x01,0x8B,0x85,0x68,0x60,0x05,0xDD,0x29,0x5B,0xBA,0xE9,0x1B,0x9D,0x68,0xE6,0x62,0x73,0x6F,0x7C,0xA2,0x19,0x46,0x34,0xBC,0xD1,0x49,0x56,0x68,0xD1,0xB4,0xC5,0x27,0x1F,0x39,0xC5,0xCD,0x67,0x9F,0xB2,0x3B,0xD3,0x8C,0x9C,0x33,0x9A,0xEE,0x4C,0x5D,0x62,0x4E,0xEA,0xAB,0x61,0x4B,0x49,0xB9,0xA9,0xCF,0x4A,0xBC,0x34,0xED,0x84,0x21,0x69,0x4D,0xD7,0x74,0x15,0x86,0x24,0xDC,0xCA,0x4A,0xB1,0x1B,0x92,0x94,0x28,0x4B,0x55,0x6E,0x48,0x52,0xC2,0x33,0x55,0xFF,0x69,0x39,0x41,0x09,0x15};
//const uint8_t spTHANK[] PROGMEM = {0x08,0xC8,0xDC,0x15,0x01,0x4D,0xA8,0x10,0x60,0xF2,0x50,0x01,0x74,0x93,0x3A,0x9C,0xEA,0x5D,0x8B,0x27,0xF6,0x71,0x87,0x2A,0x2E,0xB7,0xC5,0xC7,0x1B,0x7E,0xB4,0xD4,0x26,0x9D,0xA8,0xA7,0xB2,0x94,0x0A,0xBD,0x92,0x5E,0x3C,0x42,0xCB,0xCC,0x68,0x9B,0x09,0xAD,0x54,0xDB,0x65,0xC8,0xC6,0x75,0xD1,0x92,0xF8,0xD1,0x8C,0xC9,0x98,0x17,0x59,0x1A,0x54,0x08,0xE5,0xEE,0x22,0xB2,0x01,0x08,0x50,0x7B,0x38,0x03,0x4A,0x08,0x16,0x40,0x89,0x46,0xFF,0x15,0x41,0x09,0x15};
//const uint8_t spTHAT[] PROGMEM = {0x6C,0x18,0x34,0x25,0xC5,0x57,0xEA,0xC6,0xD5,0x9D,0x06,0x85,0x4A,0x97,0x50,0x77,0x96,0xEC,0xC2,0x6D,0x4A,0xD5,0x65,0x51,0x30,0x35,0x19,0x51,0xD7,0x49,0xCD,0x71,0x7B,0x45,0xC3,0x26,0xB5,0xFA,0xE2,0x93,0xCC,0xD0,0x5C,0xAA,0x8D,0x4F,0x3E,0x72,0x69,0x99,0x36,0x3E,0xD5,0xC8,0xED,0x19,0xD2,0x64,0xB5,0xA3,0x64,0x96,0xE9,0x92,0xD1,0xB7,0xE2,0x19,0x9A,0xB3,0x48,0x2F,0x94,0xBB,0x8B,0xC8,0x06,0x00,0x00,0x05,0x5C,0x91,0xA6,0x01,0x04,0x34,0xDF,0xF0,0x51,0x09,0x15};
const uint8_t spTHE[] PROGMEM = {0xA6,0x48,0xB2,0x28,0xA4,0x26,0xBB,0x3C,0xA9,0xA4,0xE0,0x6C,0x5C,0xD2,0x2A,0x8B,0x83,0x64,0xF1,0x8A,0x3A,0x1F,0x71,0x91,0xC7,0xCB,0xEF,0x74,0xD9,0xC3,0x1F,0x2D,0x7F,0x88,0x96,0x34,0x7D,0x75,0xFC,0xA1,0xD6,0x52,0x79,0xD5,0x89,0x86,0x1C,0x0B,0x93,0xCD,0xA7,0xE8,0x76,0x3C,0x9D,0x56,0xEF,0xA6,0xB5,0xD5,0x87,0xA7,0xFA,0x94,0xFF,0x39,0x51,0x09,0x15};
//const uint8_t spTHEN[] PROGMEM = {0xA6,0x4B,0x24,0x24,0xCD,0x6A,0xD9,0xCE,0xF5,0x99,0x84,0xB8,0xBB,0xEB,0x3C,0x8C,0x6A,0xC8,0xC2,0x30,0x7F,0x7C,0xEA,0x61,0x83,0xD2,0xFC,0xD1,0x69,0xBA,0x4E,0xCA,0x8C,0x57,0xA7,0xED,0x26,0xD9,0xD3,0x3F,0x9D,0x66,0xD8,0x66,0x4B,0xDD,0x74,0x9A,0x69,0x47,0x2C,0x74,0xD5,0x6A,0xA6,0x1E,0x75,0xD7,0xD6,0xA3,0xED,0xC6,0xB1,0xD9,0xE3,0xB6,0xB6,0x1B,0xC5,0xE1,0x74,0x3A,0x9A,0xAE,0x0C,0x9B,0xCB,0xE9,0x68,0x86,0x0C,0x28,0x49,0x67,0xFF,0x11,0x25,0x49,0x09,0x15};
//const uint8_t spTHIRD[] PROGMEM = {0x08,0x28,0xAA,0x8C,0x02,0x0C,0xC8,0xBA,0x8D,0x01,0x4D,0x86,0x1B,0xA0,0xE9,0xB6,0xE3,0x16,0x53,0x9A,0xE2,0xB3,0x8F,0x5D,0x55,0x6A,0x99,0xDD,0x3E,0x76,0x93,0xA5,0x19,0xF6,0xF8,0xB8,0x43,0x97,0xA6,0xF2,0xEA,0xE3,0x77,0xD3,0x96,0xAA,0x8B,0x4E,0xD4,0x74,0x69,0x98,0x3F,0x3E,0x79,0xF3,0xE9,0x29,0x3E,0xE7,0x54,0x2D,0x79,0x1A,0xD7,0xD4,0xD3,0xB6,0xE8,0xE1,0x12,0x73,0x4E,0x57,0xA3,0x87,0x4B,0xCE,0x59,0x7D,0x0B,0xEE,0x21,0x36,0x67,0x0C,0xCD,0xBA,0x85,0xDB,0xE2,0x36,0x54,0x6F,0xEE,0x56,0x97,0xDB,0x58,0x8D,0x7A,0x5A,0x4E,0x2E,0x63,0x51,0x1A,0x15,0x39,0x49,0x8C,0x49,0x8A,0xBA,0x76,0x45,0x36,0x46,0xEA,0x96,0x9E,0x31,0x15,0xD0,0x95,0x85,0x00,0x96,0x90,0x44,0x40,0x96,0xE1,0xFF,0x65,0x49,0x09,0x15};
const uint8_t spTHIS[] PROGMEM = {0xAA,0xF2,0xD2,0x6C,0xA4,0x2A,0xAA,0xCA,0x4B,0xB5,0xB6,0x6C,0x18,0xCA,0xAA,0x94,0x53,0xB4,0xF1,0x8A,0x3B,0x0B,0xEC,0xD2,0x45,0x27,0xEC,0xDC,0x71,0xCA,0x67,0x9D,0x68,0x48,0xC7,0xE9,0x58,0x74,0xD2,0x69,0x13,0x22,0x63,0xF1,0xA9,0x86,0x35,0xEC,0xCC,0xC5,0xAD,0xEE,0x5E,0x68,0xE4,0xE2,0x2A,0x20,0xE3,0x10,0x01,0x2C,0x62,0x66,0x80,0xC7,0xDC,0x15,0xF0,0x98,0x94,0x00,0x3E,0xB7,0x10,0xC0,0xA3,0x96,0x0C,0xF8,0x42,0x9D,0x01,0xDF,0x09,0x33,0xE0,0x1B,0x31,0x02,0x7C,0xA7,0x42,0x80,0x6F,0x94,0x10,0xF0,0x95,0x39,0x02,0x1A,0x0E,0xFD,0x51,0x59,0x49,0x15};
//const uint8_t spTIME[] PROGMEM = {0x0E,0x38,0xD0,0xC3,0x01,0x47,0xBB,0x3A,0x20,0xEB,0x8E,0xE6,0x95,0x14,0x61,0x1A,0xA2,0x96,0x97,0x73,0xBB,0x4A,0x59,0x3E,0x7E,0xC9,0x5B,0xAE,0x99,0xE8,0x04,0xD5,0x7C,0x95,0x78,0xAA,0x13,0x34,0x75,0x55,0x1A,0x89,0x4E,0xD4,0xCC,0x56,0xA9,0xB5,0x3A,0x71,0xF3,0x93,0x65,0xD6,0xE8,0xA4,0xC3,0x8F,0xA7,0x6B,0xAB,0x53,0x8D,0x98,0xE2,0xE6,0x8D,0x46,0x35,0x42,0x90,0x65,0xD6,0x69,0xDD,0xF0,0x46,0x5E,0x55,0xBA,0x0C,0x4D,0x89,0x4E,0x45,0xE4,0x30,0x44,0x25,0xD9,0xE2,0xA9,0xFD,0xA8,0xA6,0xA2,0x30,0xDA,0x2C,0xB5,0x9A,0x8B,0xE6,0x70,0xCC,0x36,0xFF,0x4D,0x25,0x15};
//const uint8_t spTRY[] PROGMEM = {0x06,0x98,0xA9,0x2D,0x01,0x33,0xB5,0x3B,0xA0,0x87,0x8C,0xE6,0xD7,0x10,0xEE,0xC2,0x72,0x86,0x9B,0xA6,0x16,0x95,0x27,0x9C,0xDE,0x09,0x4A,0xDE,0x72,0xF5,0x86,0x27,0xAE,0xEE,0xCA,0xD5,0x53,0x9E,0xAC,0x99,0xAD,0x54,0x4B,0x79,0xBA,0x66,0xB7,0x33,0xA4,0xF5,0x1A,0xAA,0xDB,0x8A,0xD4,0x55,0x6B,0x2C,0x61,0xC3,0xD2,0x66,0x8D,0xA9,0xE4,0x76,0x37,0x9F,0x54,0xA6,0x1A,0x2C,0xC2,0xB2,0x72,0x1A,0xB3,0xD5,0xA8,0xEA,0x32,0x69,0x2C,0x46,0x62,0xAA,0xCA,0x84,0xB1,0x5A,0xB6,0xC9,0x0E,0xEB,0xC6,0x51,0x58,0x34,0x3A,0xAE,0x1B,0x47,0x66,0x89,0x48,0xBB,0xFF,0x51,0x35,0x19,0x51,0x75,0x15};
//const uint8_t spTWELVE[] PROGMEM = {0x06,0x58,0xCA,0xCC,0x00,0x4D,0x57,0x09,0xA0,0xC4,0x88,0xE4,0x85,0x1A,0x66,0xEA,0xAB,0x9A,0x1F,0x6B,0xAB,0x8B,0x6E,0x3A,0x7E,0x71,0xA3,0x6E,0xBC,0xF9,0x84,0xD5,0x8D,0xBA,0xCB,0xCA,0x13,0x35,0xD5,0xEA,0xA9,0x9B,0x4E,0xD2,0xED,0x78,0x18,0xAD,0x3A,0x45,0x0D,0xE5,0xC9,0xB6,0x7A,0x0C,0x25,0xB6,0x25,0xC5,0xED,0x32,0xE4,0xD6,0x16,0x54,0xB7,0xCB,0x9C,0x83,0x57,0x50,0x2D,0x2A,0x6B,0x76,0x9E,0x89,0xBE,0xAA,0x2C,0x29,0x64,0x18,0x59,0xEA,0xB2,0x24,0x9F,0x69,0xE8,0xA9,0xD3,0x12,0x8D,0x75,0xB1,0x75,0x4D,0x4B,0x8C,0x5E,0x46,0xD6,0x3A,0xCD,0xC1,0xB5,0x86,0xF8,0x66,0x04,0xB0,0x16,0x4A,0x80,0xA2,0xCB,0x10,0x50,0x55,0xDB,0xFF,0x51,0x05,0x4D,0x15};
//const uint8_t spTYPE[] PROGMEM = {0x0A,0x38,0xB4,0x53,0x01,0xCB,0xA7,0x8F,0xB0,0x9B,0x4C,0x4F,0xB1,0x35,0xBC,0x66,0x32,0xD4,0x59,0xE3,0xF1,0x4A,0xCF,0x72,0xD3,0xCA,0x27,0xAC,0xB9,0x2A,0x5D,0x1B,0x9D,0xAC,0xE5,0x8A,0x72,0x6D,0xB5,0xDA,0x9E,0x52,0xC2,0x7D,0x55,0x1A,0x9B,0x17,0xC9,0xC8,0x56,0x66,0xEA,0x4D,0xC5,0x24,0x6A,0x93,0x49,0x28,0x77,0x17,0x91,0x0D,0x00,0x00,0x80,0x80,0x10,0xD9,0x10,0x90,0x8B,0x19,0x02,0x52,0x11,0xF9,0x55};
//const uint8_t spU[] PROGMEM = {0xAE,0x5A,0x40,0x2C,0xB7,0xC5,0x84,0x6C,0x42,0xA1,0xD8,0x0D,0x13,0xD2,0x89,0x05,0x6D,0x37,0x74,0x4A,0xA6,0x50,0xB0,0x9B,0x4A,0x2D,0x9E,0xCA,0x40,0xAF,0x2B,0x8F,0x60,0x38,0x03,0xDB,0x7A,0x78,0xFC,0x26,0x83,0x3D,0x7C,0xF5,0x0E,0x46,0x54,0xF8,0xA8,0xB2,0xBE,0x1A,0x69,0x64,0xA3,0xAA,0xB1,0x32,0x15,0x4E,0x9C,0x8B,0xF9,0x26,0xD7,0x0A,0x77,0x6A,0x96,0x8F,0xDC,0xA0,0xD5,0x99,0x98,0x37,0x31,0x23,0x0B,0x6B,0xA1,0x9E,0x44,0x8F,0x6A,0x94,0xE2,0x2B,0x42,0xED,0xA8,0x41,0xA8,0x4F,0x37,0xAD,0xA3,0x06,0xE1,0xD6,0x5D,0x3D,0xAD,0x1A,0x7C,0x6A,0x11,0xC9,0x36,0xFF,0x09,0x55};
//const uint8_t spUH[] PROGMEM = {0x2B,0x68,0x6E,0xD4,0xD4,0x56,0x9D,0xA0,0xB9,0x75,0x13,0x69,0x75,0x82,0xEA,0x2B,0x5C,0x6D,0xD5,0x89,0x5B,0xC8,0x72,0x95,0x45,0x2B,0xAF,0x3E,0x53,0xDD,0x6E,0x8F,0xBA,0xF8,0x4C,0x75,0xBB,0x5D,0xDA,0x5C,0xC3,0xD5,0x2B,0xD6,0xFF,0x05,0x55};
//const uint8_t spUP[] PROGMEM = {0x27,0xAA,0x66,0x33,0x5D,0x16,0x9E,0xB0,0xDA,0xCB,0x32,0x9D,0x79,0xA2,0x2A,0x2F,0x23,0xB4,0xE5,0x49,0xBA,0xB8,0xCE,0xE2,0xCE,0xA7,0x6A,0x72,0xBB,0x9A,0xBA,0x94,0x36,0x87,0xCE,0x66,0x59,0x45,0x26,0xA1,0xDC,0x5D,0x44,0x36,0x00,0x00,0x03,0xBC,0x4F,0x13,0x40,0x52,0xA1,0xFF,0x35};
//const uint8_t spV[] PROGMEM = {0xA6,0x4E,0xCC,0x25,0x42,0x1A,0xB9,0xBA,0x0A,0x23,0x57,0x6E,0xED,0xCA,0xC2,0x94,0x23,0xA4,0xB5,0x2F,0x52,0xD6,0x98,0x61,0xA6,0x35,0x59,0xE1,0xB2,0x01,0xD6,0xD7,0x78,0x45,0xCB,0x1B,0xC8,0x6C,0xEC,0x9D,0xAD,0x7C,0x45,0x03,0x9A,0x89,0x3D,0xAA,0xED,0x98,0x78,0x26,0x76,0x6B,0x76,0x14,0xC2,0x9D,0x3A,0x69,0x58,0x81,0x51,0xAE,0xEB,0xA4,0x71,0x3A,0x22,0xFF,0x8A,0xE3,0xC6,0xAE,0xC1,0x76,0xCA,0xB1,0x1B,0xBB,0x05,0x9F,0x4D,0x3B,0x6E,0x1C,0x11,0xA4,0xA7,0xA2,0xA8,0x61,0x3A,0xA4,0xCE,0x71,0xFA,0x4D,0x25,0x51,0x35};
//const uint8_t spVERY[] PROGMEM = {0xAE,0xAD,0x4A,0xC8,0x4A,0x53,0xE7,0xB6,0x56,0xAB,0xEC,0xBA,0x48,0xD2,0x37,0x9E,0xA2,0xAB,0x22,0x4F,0xFF,0x78,0x8A,0xEE,0x8A,0x33,0x6C,0xD5,0x29,0xAA,0x37,0x6D,0xCF,0xC5,0xA7,0x6C,0x51,0xAC,0x74,0x56,0xB7,0xAA,0x0F,0x49,0xD2,0xCA,0x5A,0xAA,0x3E,0xC4,0x44,0x6A,0xCD,0xA9,0x7A,0x74,0xD2,0xCC,0xD5,0xA7,0xEA,0x2E,0x50,0x27,0x57,0x9F,0x6A,0xB8,0x44,0x99,0x5A,0xBC,0xAA,0xE9,0x0B,0x25,0x73,0xF5,0x68,0x7B,0x14,0x8A,0xA8,0x59,0xA1,0xAB,0x9A,0xB9,0x22,0xA3,0xFC,0x75};
//const uint8_t spW[] PROGMEM = {0xA3,0xBF,0x2A,0xC2,0x43,0x64,0xAD,0xA4,0xA8,0x94,0xF4,0x5A,0x7C,0xE2,0xEA,0xC7,0x52,0x6C,0xD1,0x89,0xAA,0x9B,0x4C,0x97,0x4E,0x27,0x2A,0x71,0xB2,0x8C,0x57,0xB5,0x38,0xFB,0x8A,0x14,0x5A,0xA8,0x32,0x6F,0xCA,0x5C,0x28,0xB5,0x2D,0x46,0x51,0xA2,0x85,0x91,0x6E,0x1E,0x75,0x72,0x22,0x13,0xB5,0xB8,0x37,0x65,0xEA,0x96,0xD9,0x3A,0x1B,0x97,0x29,0x2B,0xB6,0x3E,0xAF,0x95,0xE6,0x64,0xC4,0x27,0x6B,0x66,0x98,0xA3,0x95,0x6C,0x8B,0x45,0x61,0x8D,0x26,0x2D,0x4D,0x5F,0xB9,0xD5,0x87,0x56,0x37,0x7B,0xF4,0x15,0x39,0x41,0x75};
//const uint8_t spWANT[] PROGMEM = {0xAA,0x24,0xBE,0x7D,0x34,0x6C,0x9B,0x9C,0xE6,0xD1,0xF0,0x68,0x58,0xB2,0x80,0x3F,0xDD,0xD4,0xED,0x88,0x23,0xBD,0x6A,0x53,0xBE,0x27,0xCA,0x7C,0xB3,0x4C,0xF5,0x9C,0x28,0xD9,0x2F,0x57,0xF3,0x7C,0xE2,0x94,0xAE,0x5C,0x2D,0xD5,0x29,0xB2,0xDF,0x18,0xD6,0x64,0xBB,0x2E,0x7D,0x56,0x66,0xCE,0x96,0x3B,0x8E,0x64,0x16,0xCA,0xDD,0x45,0x64,0x03,0x80,0x02,0xAE,0x48,0xD3,0x00,0x02,0x9A,0x6F,0xFC,0x65,0x41,0x75};
//const uint8_t spWAS[] PROGMEM = {0x26,0x33,0x36,0xF3,0x90,0x9C,0x98,0xDC,0xB8,0xCC,0x41,0xE6,0x92,0xF2,0x20,0x22,0x2A,0x4D,0x55,0x2B,0x02,0x9F,0xAE,0x54,0x3C,0xAB,0x48,0xBC,0xBB,0x4A,0xF4,0x8E,0xAA,0xA8,0xED,0x48,0xEC,0x33,0xEA,0xA2,0xA6,0x23,0x61,0xCF,0xA8,0x8B,0x9A,0x8A,0xC4,0xDD,0xA3,0xCE,0x66,0xD3,0x9C,0x36,0xCD,0xAA,0x15,0xD9,0x2C,0x87,0xF8,0xEB,0x52,0x34,0x38,0x62,0x62,0x9B,0x7C,0x27,0x80,0x0D,0xC8,0x18,0x70,0x29,0x0B,0x05,0x30,0xF0,0x51,0x25,0x51,0x75};
//const uint8_t spWERE[] PROGMEM = {0xAA,0xF0,0x6C,0xA3,0x02,0x7D,0xD9,0xAC,0x44,0x99,0xB7,0x67,0x50,0xAE,0x13,0x26,0xEB,0x5E,0x56,0xB5,0x4E,0xD8,0x7C,0xB8,0xAB,0xB6,0x3A,0x61,0xF5,0xED,0xA9,0xD6,0xF2,0x44,0xD5,0x97,0x85,0xFA,0xAA,0x93,0xD4,0xD8,0xE1,0xAA,0xAD,0x4E,0xDE,0x7C,0x7B,0x8A,0xB5,0x5C,0x55,0x4D,0x91,0x2E,0xB1,0x68,0x75,0xCD,0x97,0xA7,0x6A,0xCB,0x32,0x94,0xE0,0xE1,0x52,0x93,0xD2,0x58,0x62,0xB8,0x69,0x4E,0x4A,0x53,0x8D,0x15,0x66,0x5E,0xEB,0xFF,0x15,0x41,0x09,0x75};
//const uint8_t spWHAT[] PROGMEM = {0xAA,0xD4,0x2A,0xB3,0x9D,0x59,0x99,0x42,0xDA,0xCC,0x43,0x72,0x62,0x0A,0xE1,0x32,0x07,0x99,0x4B,0xC9,0x03,0xFB,0xCC,0x10,0xAE,0x2B,0x4B,0x6C,0x32,0x53,0xF4,0x9D,0x2C,0xCB,0x29,0x0F,0xF6,0x7B,0xF2,0xAC,0x32,0x27,0x28,0xCF,0x2A,0x8A,0xEE,0xCC,0xC4,0x3C,0xA3,0x2C,0x26,0xB2,0x9C,0x7A,0xB7,0x32,0x7B,0x69,0xB5,0x74,0x83,0x4A,0x11,0xDC,0x45,0x44,0x36,0x80,0x00,0xAE,0x48,0x93,0x00,0x02,0x8A,0x4F,0xFD,0x09,0x61,0x49,0x09,0x75};
//const uint8_t spWHICH[] PROGMEM = {0x6A,0x62,0x7E,0xD2,0x82,0xD5,0xD8,0x3E,0xB5,0xD6,0xAF,0xB9,0xCA,0xAA,0x51,0x27,0xBE,0xE6,0x2A,0xAB,0x4E,0xD9,0xAD,0xA3,0xB5,0xEC,0x3A,0x65,0x0F,0x49,0x92,0xB6,0x6B,0x15,0x3D,0xB3,0xA8,0x55,0x4B,0x54,0x88,0xE0,0x2E,0x22,0xB2,0x41,0x01,0x73,0x8C,0x29,0x60,0xB6,0x0D,0x05,0xEC,0xDA,0xA1,0x80,0xD9,0xB7,0x14,0x30,0xC6,0x04,0x03,0xC6,0x0C,0xC3,0xC0,0xFF,0x0D};
//const uint8_t spX[] PROGMEM = {0xAD,0x18,0x21,0x28,0xCA,0x6A,0x9F,0xA0,0x3B,0xA3,0xCA,0xA8,0x7D,0x82,0x61,0x83,0xA2,0x63,0xD1,0x89,0x86,0x0F,0xCA,0xF2,0xC9,0x27,0x1E,0xA5,0xC8,0xD3,0x96,0x8C,0xB4,0x55,0xD1,0xB4,0x6A,0x42,0x0A,0xA1,0xDC,0x5D,0x44,0x36,0x00,0x00,0x18,0x20,0x5D,0x0B,0x07,0x1C,0xD5,0x69,0x80,0xAB,0x2A,0x14,0x70,0x65,0xA6,0x02,0x8E,0x48,0x67,0xC0,0x57,0x1A,0x0C,0xF8,0x41,0x8D,0x01,0xDF,0x89,0x30,0xE0,0x1B,0x66,0x02,0xFC,0xC8,0x46,0x80,0x27,0x38,0x10,0x50,0x69,0xC6,0xFF,0x4D};
//const uint8_t spY[] PROGMEM = {0xA2,0x64,0xA6,0x72,0x4C,0x1C,0xA9,0x42,0xB8,0xE2,0xB6,0x48,0xE4,0x32,0xE9,0x5B,0x3D,0x75,0x61,0x4B,0xAD,0xB9,0xB4,0x90,0x5C,0x23,0x4A,0xE6,0x52,0x43,0x73,0xAD,0xA8,0xE8,0xAD,0x48,0xCA,0x75,0xA2,0xAA,0xAF,0x2D,0xC4,0xD3,0x89,0x9B,0xBE,0x0E,0x57,0x4F,0x27,0xAB,0x66,0xDB,0x5D,0x32,0x9E,0xBA,0x9A,0xAD,0x0C,0xC9,0x78,0xDA,0x66,0xB6,0xA2,0xB8,0xD3,0xEA,0x9B,0xD9,0x8A,0xE2,0xCD,0x6B,0x6C,0x66,0xD3,0x4A,0x56,0x8D,0xA9,0xD9,0x71,0x4F,0x99,0x39,0xC6,0x6E,0x43,0x22,0x75,0x71,0x1B,0xBB,0x36,0xAE,0xF1,0x59,0x65,0x6C,0x5A,0xA5,0x37,0x2B,0xA7,0xB1,0x5B,0xE1,0x9C,0xAE,0xF5,0x25,0x41,0x51,0x4D};
//const uint8_t spYEAR[] PROGMEM = {0x26,0xEF,0x40,0xB5,0xB6,0x69,0x9B,0x6C,0x01,0x91,0xB8,0xA1,0xEC,0xD2,0x05,0x95,0xF4,0x96,0x76,0x48,0x36,0x61,0xD6,0x59,0xDB,0x25,0x3A,0x5C,0x89,0xE7,0x22,0x8F,0x60,0x49,0x07,0xB9,0xAD,0x3D,0xFD,0x15,0x2C,0x97,0x40,0x53,0xAB,0x4E,0xB0,0x5C,0xA2,0x74,0x2E,0x3A,0xD1,0xD4,0x41,0xB6,0xDE,0xE8,0x64,0xD3,0x06,0xC5,0xD8,0xAA,0x53,0x0C,0x9F,0x9A,0x21,0x8B,0x57,0xD7,0x7D,0x79,0xAA,0x3C,0x19,0x43,0x0B,0x1D,0x29,0x7A,0x79,0x4C,0x35,0x77,0x24,0xC7,0x95,0x36,0xD7,0x34,0x91,0x6C,0x97,0xCB,0x5C,0xD3,0x44,0xB1,0x5D,0x2E,0x73,0x8D,0xEB,0x29,0x36,0x29,0xCD,0xA5,0x76,0x06,0xE7,0xE8,0xFF,0x65,0x51,0x4D};
//const uint8_t spYES[] PROGMEM = {0x21,0x5B,0x2E,0x81,0xA6,0x56,0xF5,0x6C,0xA4,0xCB,0x25,0x4A,0xE7,0xA2,0x93,0x8E,0xE0,0x1A,0x61,0xAB,0x6F,0x72,0xB2,0xE1,0x4B,0x2C,0x64,0xF5,0xAD,0x56,0x37,0x43,0x89,0xA6,0xAC,0xC9,0x23,0x02,0xBE,0x12,0xE3,0x00,0x03,0x3E,0x55,0x23,0xC0,0x37,0x6C,0x0C,0xF8,0x86,0x8C,0x01,0x5F,0xB1,0x11,0xE0,0x0B,0xC9,0xFF,0x25,0x55,0x79,0x4D};
//const uint8_t spYOUR[] PROGMEM = {0xA1,0x69,0x86,0xD1,0xA7,0x2B,0xE5,0x3A,0x55,0x2D,0x08,0xDA,0xC4,0xCA,0x56,0x16,0xA9,0x5C,0xA3,0x3D,0x4F,0x99,0x44,0x59,0x85,0xF4,0x5A,0x65,0x74,0xE3,0xA9,0xDC,0xFB,0x96,0xA7,0x4A,0x7A,0xA2,0x8C,0x72,0x9F,0x2A,0xDA,0xC9,0x54,0xCE,0xBD,0xEA,0x10,0x26,0x42,0xB4,0xF7,0xAA,0xA3,0xDF,0x08,0xD1,0xDE,0xA3,0x8E,0x6E,0x23,0x44,0x73,0x8F,0x3A,0x9A,0x8D,0x54,0xC9,0x35,0xEA,0xE4,0xBA,0xD2,0xB0,0xF7,0x68,0x92,0xDF,0x74,0x91,0x9C,0xA5,0x89,0xBD,0xD3,0x48,0x3B,0xF8,0xF6,0xFF,0x2D};
//const uint8_t spZ[] PROGMEM = {0x08,0x38,0x20,0x4D,0x02,0x12,0x08,0xED,0x05,0x66,0xEE,0x19,0xA7,0x34,0x1B,0xA8,0x86,0x55,0xEA,0x91,0x6C,0x90,0x9C,0x9E,0xB1,0x4E,0xB4,0x71,0x51,0x66,0xCE,0x3A,0xD1,0xD0,0x41,0x65,0x5D,0xFB,0x24,0x43,0x27,0xB5,0x77,0xE3,0x53,0x8C,0x10,0x94,0x96,0x8D,0x4F,0x35,0x5C,0x50,0x46,0xAD,0x3E,0x4D,0xB7,0x41,0x51,0xB9,0xE4,0xF4,0xDD,0x19,0x67,0xD6,0x9C,0x35,0x74,0x6D,0x1C,0x59,0x8B,0xCB,0x38,0xAC,0xB2,0x69,0xB4,0x36,0x43,0xD1,0xCC,0xA6,0x53,0x5A,0x0C,0x91,0x8B,0x56,0xB4,0x25,0x33,0x74,0xC5,0xCE,0xAE,0x4E,0xFE};
void setup() {
CircuitPlayground.begin();
CircuitPlayground.speaker.say(spTHIS);
CircuitPlayground.speaker.say(spIS);
CircuitPlayground.speaker.say(spTHE);
CircuitPlayground.speaker.say(spACORN);
CircuitPlayground.speaker.say(spCOMPUTER);
CircuitPlayground.speaker.say(sp_Z);
CircuitPlayground.speaker.say(spFILE);
CircuitPlayground.speaker.say(spFROM);
CircuitPlayground.speaker.say(spNINE_);
CircuitPlayground.speaker.say(sp_TEEN);
CircuitPlayground.speaker.say(spEIGH_);
CircuitPlayground.speaker.say(spT);
CircuitPlayground.speaker.say(spTHREE);
CircuitPlayground.speaker.say(spPAUSE1);
// Calling speaker.end() after playing a sound is optional -- this
// will turn off the pin 13 LED (it's connected to a microcontroller
// pin that's also related to the speaker), but there's a small
// audible click when it turns off. Tradeoffs!
CircuitPlayground.speaker.end();
}
void loop() {
}

73
arduino-cli/libraries/Adafruit_Circuit_Playground/examples/Speech_Demos/Talk_US_Clock/Talk_US_Clock.ino Normal file
View File

@@ -0,0 +1,73 @@
// Talkie library
// Copyright 2011 Peter Knight
// This code is released under GPLv2 license.
//
// A female voice with an American accent
//
#include <Adafruit_CircuitPlayground.h>
#include <Wire.h>
#include <SPI.h>
const uint8_t spTHE[] PROGMEM = {0x08,0xE8,0x3E,0x55,0x01,0xC3,0x86,0x27,0xAF,0x72,0x0D,0x4D,0x97,0xD5,0xBC,0x64,0x3C,0xF2,0x5C,0x51,0xF1,0x93,0x36,0x8F,0x4F,0x59,0x2A,0x42,0x7A,0x32,0xC3,0x64,0xFF,0x3F};
const uint8_t spTIME[] PROGMEM = {0x0E,0x28,0xAC,0x2D,0x01,0x5D,0xB6,0x0D,0x33,0xF3,0x54,0xB3,0x60,0xBA,0x8C,0x54,0x5C,0xCD,0x2D,0xD4,0x32,0x73,0x0F,0x8E,0x34,0x33,0xCB,0x4A,0x25,0xD4,0x25,0x83,0x2C,0x2B,0xD5,0x50,0x97,0x08,0x32,0xEC,0xD4,0xDC,0x4C,0x33,0xC8,0x70,0x73,0x0F,0x33,0xCD,0x20,0xC3,0xCB,0x43,0xDD,0x3C,0xCD,0x8C,0x20,0x77,0x89,0xF4,0x94,0xB2,0xE2,0xE2,0x35,0x22,0x5D,0xD6,0x4A,0x8A,0x96,0xCC,0x36,0x25,0x2D,0xC9,0x9A,0x7B,0xC2,0x18,0x87,0x24,0x4B,0x1C,0xC9,0x50,0x19,0x92,0x2C,0x71,0x34,0x4B,0x45,0x8A,0x8B,0xC4,0x96,0xB6,0x5A,0x29,0x2A,0x92,0x5A,0xCA,0x53,0x96,0x20,0x05,0x09,0xF5,0x92,0x5D,0xBC,0xE8,0x58,0x4A,0xDD,0xAE,0x73,0xBD,0x65,0x4B,0x8D,0x78,0xCA,0x2B,0x4E,0xD8,0xD9,0xED,0x22,0x20,0x06,0x75,0x00,0x00,0x80,0xFF,0x07};
const uint8_t spIS[] PROGMEM = {0x21,0x18,0x96,0x38,0xB7,0x14,0x8D,0x60,0x3A,0xA6,0xE8,0x51,0xB4,0xDC,0x2E,0x48,0x7B,0x5A,0xF1,0x70,0x1B,0xA3,0xEC,0x09,0xC6,0xCB,0xEB,0x92,0x3D,0xA7,0x69,0x1F,0xAF,0x71,0x89,0x9C,0xA2,0xB3,0xFC,0xCA,0x35,0x72,0x9A,0xD1,0xF0,0xAB,0x12,0xB3,0x2B,0xC6,0xCD,0x4F,0xCC,0x32,0x26,0x19,0x07,0xDF,0x0B,0x8F,0xB8,0xA4,0xED,0x7C,0xCF,0x23,0x62,0x8B,0x8E,0xF1,0x23,0x0A,0x8B,0x6E,0xCB,0xCE,0xEF,0x54,0x44,0x3C,0xDC,0x08,0x60,0x0B,0x37,0x01,0x1C,0x53,0x26,0x80,0x15,0x4E,0x14,0xB0,0x54,0x2B,0x02,0xA4,0x69,0xFF,0x7F};
const uint8_t spA_M_[] PROGMEM = {0xCD,0xEF,0x86,0xAB,0x57,0x6D,0x0F,0xAF,0x71,0xAD,0x49,0x55,0x3C,0xFC,0x2E,0xC5,0xB7,0x5C,0xF1,0xF2,0x87,0x66,0xDD,0x4E,0xC5,0xC3,0xEF,0x92,0xE2,0x3A,0x65,0xB7,0xA0,0x09,0xAA,0x1B,0x97,0x54,0x82,0x2E,0x28,0x77,0x5C,0x52,0x09,0x1A,0xA3,0xB8,0x76,0x49,0x25,0x68,0x8C,0x73,0xDB,0x24,0x95,0xA0,0x32,0xA9,0x6B,0xA7,0xD9,0x82,0x26,0xA9,0x76,0x42,0xD6,0x08,0xBA,0xE1,0xE8,0x0E,0x5A,0x2B,0xEA,0x9E,0x3D,0x27,0x18,0xAD,0xA8,0x07,0xF1,0x98,0x90,0x35,0xA2,0x96,0x44,0xA3,0x5D,0x66,0x8B,0x6B,0x12,0xCD,0x32,0x85,0x25,0xC9,0x81,0x2D,0xC3,0x64,0x85,0x34,0x58,0x89,0x94,0x52,0x1C,0x52,0x2F,0x35,0xDA,0xC7,0x51,0x48,0x23,0x97,0xCC,0x2C,0x97,0x2E,0xF3,0x5C,0xF3,0xA2,0x14,0xBA,0x2C,0x48,0xCE,0xCA,0x76,0xE8,0x32,0x2F,0x34,0xB2,0xDB,0x85,0xC9,0x83,0x90,0xA8,0x2C,0x57,0x26,0x8F,0x9C,0xBD,0xA2,0x53,0xD9,0xC2,0x54,0x59,0x28,0x99,0x4B,0x2C,0x5D,0xFF,0x3F};
//const uint8_t spP_M_[] PROGMEM = {0x0E,0x98,0x41,0x54,0x00,0x43,0xA0,0x05,0xAB,0x42,0x8E,0x1D,0xA3,0x15,0xEC,0x4E,0x58,0xF7,0x92,0x66,0x70,0x1B,0x66,0xDB,0x73,0x99,0xC1,0xEB,0x98,0xED,0xD6,0x25,0x25,0x6F,0x70,0x92,0xDD,0x64,0xD8,0xFC,0x61,0xD0,0x66,0x83,0xD6,0x0A,0x86,0x23,0xAB,0x69,0xDA,0x2B,0x18,0x9E,0x3D,0x37,0x69,0x9D,0xA8,0x07,0x71,0x9F,0xA0,0xBD,0xA2,0x16,0xD5,0x7C,0x54,0xF6,0x88,0x6B,0x54,0x8B,0x34,0x49,0x2D,0x29,0x49,0x3C,0x34,0x64,0xA5,0x24,0x1B,0x36,0xD7,0x72,0x13,0x92,0xA4,0xC4,0x2D,0xC3,0xB3,0x4B,0xA3,0x62,0x0F,0x2B,0x37,0x6E,0x8B,0x5A,0xD4,0x3D,0xDD,0x9A,0x2D,0x50,0x93,0xF6,0x4C,0xAA,0xB6,0xC4,0x85,0x3B,0xB2,0xB1,0xD8,0x93,0x20,0x4D,0x8F,0x24,0xFF,0x0F};
//const uint8_t spOH[] PROGMEM = {0xC6,0xC9,0x71,0x5A,0xA2,0x92,0x14,0x2F,0x6E,0x97,0x9C,0x46,0x9D,0xDC,0xB0,0x4D,0x62,0x1B,0x55,0x70,0xDD,0x55,0xBE,0x0E,0x36,0xC1,0x33,0x37,0xA9,0xA7,0x51,0x1B,0xCF,0x3C,0xA5,0x9E,0x44,0xAC,0x3C,0x7D,0x98,0x7B,0x52,0x96,0x72,0x65,0x4B,0xF6,0x1A,0xD9,0xCA,0xF5,0x91,0x2D,0xA2,0x2A,0x4B,0xF7,0xFF,0x01};
//const uint8_t spOCLOCK[] PROGMEM = {0x21,0x4E,0x3D,0xB8,0x2B,0x19,0xBB,0x24,0x0E,0xE5,0xEC,0x60,0xE4,0xF2,0x90,0x13,0xD4,0x2A,0x11,0x80,0x00,0x42,0x69,0x26,0x40,0xD0,0x2B,0x04,0x68,0xE0,0x4D,0x00,0x3A,0x35,0x35,0x33,0xB6,0x51,0xD9,0x64,0x34,0x82,0xB4,0x9A,0x63,0x92,0x55,0x89,0x52,0x5B,0xCA,0x2E,0x34,0x25,0x4E,0x63,0x28,0x3A,0x50,0x95,0x26,0x8D,0xE6,0xAA,0x64,0x58,0xEA,0x92,0xCE,0xC2,0x46,0x15,0x9B,0x86,0xCD,0x2A,0x2E,0x37,0x00,0x00,0x00,0x0C,0xC8,0xDD,0x05,0x01,0xB9,0x33,0x21,0xA0,0x74,0xD7,0xFF,0x07};
//const uint8_t spONE[] PROGMEM = {0xCC,0x67,0x75,0x42,0x59,0x5D,0x3A,0x4F,0x9D,0x36,0x63,0xB7,0x59,0xDC,0x30,0x5B,0x5C,0x23,0x61,0xF3,0xE2,0x1C,0xF1,0xF0,0x98,0xC3,0x4B,0x7D,0x39,0xCA,0x1D,0x2C,0x2F,0xB7,0x15,0xEF,0x70,0x79,0xBC,0xD2,0x46,0x7C,0x52,0xE5,0xF1,0x4A,0x6A,0xB3,0x71,0x47,0xC3,0x2D,0x39,0x34,0x4B,0x23,0x35,0xB7,0x7A,0x55,0x33,0x8F,0x59,0xDC,0xA2,0x44,0xB5,0xBC,0x66,0x72,0x8B,0x64,0xF5,0xF6,0x98,0xC1,0x4D,0x42,0xD4,0x27,0x62,0x38,0x2F,0x4A,0xB6,0x9C,0x88,0x68,0xBC,0xA6,0x95,0xF8,0x5C,0xA1,0x09,0x86,0x77,0x91,0x11,0x5B,0xFF,0x0F};
//const uint8_t spTWO[] PROGMEM = {0x0E,0x38,0x6E,0x25,0x00,0xA3,0x0D,0x3A,0xA0,0x37,0xC5,0xA0,0x05,0x9E,0x56,0x35,0x86,0xAA,0x5E,0x8C,0xA4,0x82,0xB2,0xD7,0x74,0x31,0x22,0x69,0xAD,0x1C,0xD3,0xC1,0xD0,0xFA,0x28,0x2B,0x2D,0x47,0xC3,0x1B,0xC2,0xC4,0xAE,0xC6,0xCD,0x9C,0x48,0x53,0x9A,0xFF,0x0F};
//const uint8_t spTHREE[] PROGMEM = {0x02,0xD8,0x2E,0x9C,0x01,0xDB,0xA6,0x33,0x60,0xFB,0x30,0x01,0xEC,0x20,0x12,0x8C,0xE4,0xD8,0xCA,0x32,0x96,0x73,0x63,0x41,0x39,0x89,0x98,0xC1,0x4D,0x0D,0xED,0xB0,0x2A,0x05,0x37,0x0F,0xB4,0xA5,0xAE,0x5C,0xDC,0x36,0xD0,0x83,0x2F,0x4A,0x71,0x7B,0x03,0xF7,0x38,0x59,0xCD,0xED,0x1E,0xB4,0x6B,0x14,0x35,0xB7,0x6B,0x94,0x99,0x91,0xD5,0xDC,0x26,0x48,0x77,0x4B,0x66,0x71,0x1B,0x21,0xDB,0x2D,0x8A,0xC9,0x6D,0x88,0xFC,0x26,0x28,0x3A,0xB7,0x21,0xF4,0x1F,0xA3,0x65,0xBC,0x02,0x38,0xBB,0x3D,0x8E,0xF0,0x2B,0xE2,0x08,0xB7,0x34,0xFF,0x0F};
//const uint8_t spFOUR[] PROGMEM = {0x0C,0x18,0xB6,0x9A,0x01,0xC3,0x75,0x09,0x60,0xD8,0x0E,0x09,0x30,0xA0,0x9B,0xB6,0xA0,0xBB,0xB0,0xAA,0x16,0x4E,0x82,0xEB,0xEA,0xA9,0xFA,0x59,0x49,0x9E,0x59,0x23,0x9A,0x27,0x3B,0x78,0x66,0xAE,0x4A,0x9C,0x9C,0xE0,0x99,0xD3,0x2A,0xBD,0x72,0x92,0xEF,0xE6,0x88,0xE4,0x45,0x4D,0x7E,0x98,0x2D,0x62,0x67,0x37,0xF9,0xA1,0x37,0xA7,0x6C,0x94,0xE4,0xC7,0x1E,0xDC,0x3C,0xA5,0x83,0x1F,0x8B,0xEB,0x52,0x0E,0x0E,0x7E,0x2E,0x4E,0xC7,0x31,0xD2,0x79,0xA5,0x3A,0x0D,0xD9,0xC4,0xFF,0x07};
//const uint8_t spFIVE[] PROGMEM = {0x02,0xE8,0x3E,0x8C,0x01,0xDD,0x65,0x08,0x60,0x98,0x4C,0x06,0x34,0x93,0xCE,0x80,0xE6,0xDA,0x9A,0x14,0x6B,0xAA,0x47,0xD1,0x5E,0x56,0xAA,0x6D,0x56,0xCD,0x78,0xD9,0xA9,0x1C,0x67,0x05,0x83,0xE1,0xA4,0xBA,0x38,0xEE,0x16,0x86,0x9B,0xFA,0x60,0x87,0x5B,0x18,0x6E,0xEE,0x8B,0x1D,0x6E,0x61,0xB9,0x69,0x36,0x65,0xBA,0x8D,0xE5,0xE5,0x3E,0x1C,0xE9,0x0E,0x96,0x9B,0x5B,0xAB,0x95,0x2B,0x58,0x6E,0xCE,0xE5,0x3A,0x6A,0xF3,0xB8,0x35,0x84,0x7B,0x05,0xA3,0xE3,0x36,0xEF,0x92,0x19,0xB4,0x86,0xDB,0xB4,0x69,0xB4,0xD1,0x2A,0x4E,0x65,0x9A,0x99,0xCE,0x28,0xD9,0x85,0x71,0x4C,0x18,0x6D,0x67,0x47,0xC6,0x5E,0x53,0x4A,0x9C,0xB5,0xE2,0x85,0x45,0x26,0xFE,0x7F};
const uint8_t spSIX[] PROGMEM = {0x0E,0xD8,0xAE,0xDD,0x03,0x0E,0x38,0xA6,0xD2,0x01,0xD3,0xB4,0x2C,0xAD,0x6A,0x35,0x9D,0xB1,0x7D,0xDC,0xEE,0xC4,0x65,0xD7,0xF1,0x72,0x47,0x24,0xB3,0x19,0xD9,0xD9,0x05,0x70,0x40,0x49,0xEA,0x02,0x98,0xBE,0x42,0x01,0xDF,0xA4,0x69,0x40,0x00,0xDF,0x95,0xFC,0x3F};
//const uint8_t spSEVEN[] PROGMEM = {0x02,0xB8,0x3A,0x8C,0x01,0xDF,0xA4,0x73,0x40,0x01,0x47,0xB9,0x2F,0x33,0x3B,0x73,0x5F,0x53,0x7C,0xEC,0x9A,0xC5,0x63,0xD5,0xD1,0x75,0xAE,0x5B,0xFC,0x64,0x5C,0x35,0x87,0x91,0xF1,0x83,0x36,0xB5,0x68,0x55,0xC5,0x6F,0xDA,0x45,0x2D,0x1C,0x2D,0xB7,0x38,0x37,0x9F,0x60,0x3C,0xBC,0x9A,0x85,0xA3,0x25,0x66,0xF7,0x8A,0x57,0x1C,0xA9,0x67,0x56,0xCA,0x5E,0xF0,0xB2,0x16,0xB2,0xF1,0x89,0xCE,0x8B,0x92,0x25,0xC7,0x2B,0x33,0xCF,0x48,0xB1,0x99,0xB4,0xF3,0xFF};
//const uint8_t spEIGHT[] PROGMEM = {0xC3,0x6C,0x86,0xB3,0x27,0x6D,0x0F,0xA7,0x48,0x99,0x4E,0x55,0x3C,0xBC,0x22,0x65,0x36,0x4D,0xD1,0xF0,0x32,0xD3,0xBE,0x34,0xDA,0xC3,0xEB,0x82,0xE2,0xDA,0x65,0x35,0xAF,0x31,0xF2,0x6B,0x97,0x95,0xBC,0x86,0xD8,0x6F,0x82,0xA6,0x73,0x0B,0xC6,0x9E,0x72,0x99,0xCC,0xCB,0x02,0xAD,0x3C,0x9A,0x10,0x60,0xAB,0x62,0x05,0x2C,0x37,0x84,0x00,0xA9,0x73,0x00,0x00,0xFE,0x1F};
//const uint8_t spNINE[] PROGMEM = {0xCC,0xA1,0x26,0xBB,0x83,0x93,0x18,0xCF,0x4A,0xAD,0x2E,0x31,0xED,0x3C,0xA7,0x24,0x26,0xC3,0x54,0xF1,0x92,0x64,0x8B,0x8A,0x98,0xCB,0x2B,0x2E,0x34,0x53,0x2D,0x0E,0x2F,0x57,0xB3,0x0C,0x0D,0x3C,0xBC,0x3C,0x4C,0x4B,0xCA,0xF4,0xF0,0x72,0x0F,0x6E,0x49,0x53,0xCD,0xCB,0x53,0x2D,0x35,0x4D,0x0F,0x2F,0x0F,0xD7,0x0C,0x0D,0x3D,0xBC,0xDC,0x4D,0xD3,0xDD,0xC2,0xF0,0x72,0x52,0x4F,0x57,0x9B,0xC3,0xAB,0x89,0xBD,0x42,0x2D,0x0F,0xAF,0x5A,0xD1,0x71,0x91,0x55,0xBC,0x2C,0xC5,0x3B,0xD8,0x65,0xF2,0x82,0x94,0x18,0x4E,0x3B,0xC1,0x73,0x42,0x32,0x33,0x15,0x45,0x4F,0x79,0x52,0x6A,0x55,0xA6,0xA3,0xFF,0x07};
//const uint8_t spTEN[] PROGMEM = {0x0E,0xD8,0xB1,0xDD,0x01,0x3D,0xA8,0x24,0x7B,0x04,0x27,0x76,0x77,0xDC,0xEC,0xC2,0xC5,0x23,0x84,0xCD,0x72,0x9A,0x51,0xF7,0x62,0x45,0xC7,0xEB,0x4E,0x35,0x4A,0x14,0x2D,0xBF,0x45,0xB6,0x0A,0x75,0xB8,0xFC,0x16,0xD9,0x2A,0xD9,0xD6,0x0A,0x5A,0x10,0xCD,0xA2,0x48,0x23,0xA8,0x81,0x35,0x4B,0x2C,0xA7,0x20,0x69,0x0A,0xAF,0xB6,0x15,0x82,0xA4,0x29,0x3C,0xC7,0x52,0x08,0xA2,0x22,0xCF,0x68,0x4B,0x2E,0xF0,0x8A,0xBD,0xA3,0x2C,0xAB,0x40,0x1B,0xCE,0xAA,0xB2,0x6C,0x82,0x40,0x4D,0x7D,0xC2,0x89,0x88,0x8A,0x61,0xCC,0x74,0xD5,0xFF,0x0F};
const uint8_t spELEVEN[] PROGMEM = {0xC3,0xCD,0x76,0x5C,0xAE,0x14,0x0F,0x37,0x9B,0x71,0xDE,0x92,0x55,0xBC,0x2C,0x27,0x70,0xD3,0x76,0xF0,0x83,0x5E,0xA3,0x5E,0x5A,0xC1,0xF7,0x61,0x58,0xA7,0x19,0x35,0x3F,0x99,0x31,0xDE,0x52,0x74,0xFC,0xA2,0x26,0x64,0x4B,0xD1,0xF1,0xAB,0xAE,0xD0,0x2D,0xC5,0xC7,0x2F,0x36,0xDD,0x27,0x15,0x0F,0x3F,0xD9,0x08,0x9F,0x62,0xE4,0xC2,0x2C,0xD4,0xD8,0xD3,0x89,0x0B,0x1B,0x57,0x11,0x0B,0x3B,0xC5,0xCF,0xD6,0xCC,0xC6,0x64,0x35,0xAF,0x18,0x73,0x1F,0xA1,0x5D,0xBC,0x62,0x45,0xB3,0x45,0x51,0xF0,0xA2,0x62,0xAB,0x4A,0x5B,0xC9,0x4B,0x8A,0x2D,0xB3,0x6C,0x06,0x2F,0x29,0xB2,0xAC,0x8A,0x18,0xBC,0x28,0xD9,0xAA,0xD2,0x92,0xF1,0xBC,0xE0,0x98,0x8C,0x48,0xCC,0x17,0x52,0xA3,0x27,0x6D,0x93,0xD0,0x4B,0x8E,0x0E,0x77,0x02,0x00,0xFF,0x0F};
//const uint8_t spTWELVE[] PROGMEM = {0x06,0x28,0x46,0xD3,0x01,0x25,0x06,0x13,0x20,0xBA,0x70,0x70,0xB6,0x79,0xCA,0x36,0xAE,0x28,0x38,0xE1,0x29,0xC5,0x35,0xA3,0xE6,0xC4,0x16,0x6A,0x53,0x8C,0x97,0x9B,0x72,0x86,0x4F,0x28,0x1A,0x6E,0x0A,0x59,0x36,0xAE,0x68,0xF8,0x29,0x67,0xFA,0x06,0xA3,0x16,0xC4,0x96,0xE6,0x53,0xAC,0x5A,0x9C,0x56,0x72,0x77,0x31,0x4E,0x49,0x5C,0x8D,0x5B,0x29,0x3B,0x24,0x61,0x1E,0x6C,0x9B,0x6C,0x97,0xF8,0xA7,0x34,0x19,0x92,0x4C,0x62,0x9E,0x72,0x65,0x58,0x12,0xB1,0x7E,0x09,0xD5,0x2E,0x53,0xC5,0xBA,0x36,0x6B,0xB9,0x2D,0x17,0x05,0xEE,0x9A,0x6E,0x8E,0x05,0x50,0x6C,0x19,0x07,0x18,0x50,0xBD,0x3B,0x01,0x92,0x08,0x41,0x40,0x10,0xA6,0xFF,0x0F};
//const uint8_t spTHIRTEEN[] PROGMEM = {0x08,0xE8,0x2C,0x15,0x01,0x43,0x07,0x13,0xE0,0x98,0xB4,0xA6,0x35,0xA9,0x1E,0xDE,0x56,0x8E,0x53,0x9C,0x7A,0xE7,0xCA,0x5E,0x76,0x8D,0x94,0xE5,0x2B,0xAB,0xD9,0xB5,0x62,0xA4,0x9C,0xE4,0xE6,0xB4,0x41,0x1E,0x7C,0xB6,0x93,0xD7,0x16,0x99,0x5A,0xCD,0x61,0x76,0x55,0xC2,0x91,0x61,0x1B,0xC0,0x01,0x5D,0x85,0x05,0xE0,0x68,0x51,0x07,0x1C,0xA9,0x64,0x80,0x1D,0x4C,0x9C,0x95,0x88,0xD4,0x04,0x3B,0x4D,0x4E,0x21,0x5C,0x93,0xA8,0x26,0xB9,0x05,0x4B,0x6E,0xA0,0xE2,0xE4,0x57,0xC2,0xB9,0xC1,0xB2,0x93,0x5F,0x09,0xD7,0x24,0xCB,0x4E,0x41,0x25,0x54,0x1D,0x62,0x3B,0x05,0x8D,0x52,0x57,0xAA,0xAD,0x10,0x24,0x26,0xE3,0xE1,0x36,0x5D,0x10,0x85,0xB4,0x97,0x85,0x72,0x41,0x14,0x52,0x5E,0x1A,0xCA,0xF9,0x91,0x6B,0x7A,0x5B,0xC4,0xE0,0x17,0x2D,0x54,0x1D,0x92,0x8C,0x1F,0x25,0x4B,0x8F,0xB2,0x16,0x41,0xA1,0x4A,0x3E,0xE6,0xFA,0xFF,0x01};
//const uint8_t spFOURTEEN[] PROGMEM = {0x0C,0x58,0xAE,0x5C,0x01,0xD9,0x87,0x07,0x51,0xB7,0x25,0xB3,0x8A,0x15,0x2C,0xF7,0x1C,0x35,0x87,0x4D,0xB2,0xDD,0x53,0xCE,0x28,0x2B,0xC9,0x0E,0x97,0x2D,0xBD,0x2A,0x17,0x27,0x76,0x8E,0xD2,0x9A,0x6C,0x80,0x94,0x71,0x00,0x00,0x02,0xB0,0x58,0x58,0x00,0x9E,0x0B,0x0A,0xC0,0xB2,0xCE,0xC1,0xC8,0x98,0x7A,0x52,0x95,0x24,0x2B,0x11,0xED,0x36,0xD4,0x92,0xDC,0x4C,0xB5,0xC7,0xC8,0x53,0xF1,0x2A,0xE5,0x1A,0x17,0x55,0xC5,0xAF,0x94,0xBB,0xCD,0x1C,0x26,0xBF,0x52,0x9A,0x72,0x53,0x98,0xFC,0xC2,0x68,0xD2,0x4D,0x61,0xF0,0xA3,0x90,0xB6,0xD6,0x50,0xC1,0x8F,0x42,0xDA,0x4A,0x43,0x39,0x3F,0x48,0x2D,0x6B,0x33,0xF9,0xFF};
//const uint8_t spFIFTEEN[] PROGMEM = {0x08,0xE8,0x2A,0x0D,0x01,0xDD,0xBA,0x31,0x60,0x6A,0xF7,0xA0,0xAE,0x54,0xAA,0x5A,0x76,0x97,0xD9,0x34,0x69,0xEF,0x32,0x1E,0x66,0xE1,0xE2,0xB3,0x43,0xA9,0x18,0x55,0x92,0x4E,0x37,0x2D,0x67,0x6F,0xDF,0xA2,0x5A,0xB6,0x04,0x30,0x55,0xA8,0x00,0x86,0x09,0xE7,0x00,0x01,0x16,0x17,0x05,0x70,0x40,0x57,0xE5,0x01,0xF8,0x21,0x34,0x00,0xD3,0x19,0x33,0x80,0x89,0x9A,0x62,0x34,0x4C,0xD5,0x49,0xAE,0x8B,0x53,0x09,0xF7,0x26,0xD9,0x6A,0x7E,0x23,0x5C,0x13,0x12,0xB3,0x04,0x9D,0x50,0x4F,0xB1,0xAD,0x14,0x15,0xC2,0xD3,0xA1,0xB6,0x42,0x94,0xA8,0x8C,0x87,0xDB,0x74,0xB1,0x70,0x59,0xE1,0x2E,0xC9,0xC5,0x81,0x5B,0x55,0xA4,0x4C,0x17,0x47,0xC1,0x6D,0xE3,0x81,0x53,0x9C,0x84,0x6A,0x46,0xD9,0x4C,0x51,0x31,0x42,0xD9,0x66,0xC9,0x44,0x85,0x29,0x6A,0x9B,0xAD,0xFF,0x07};
//const uint8_t spSIXTEEN[] PROGMEM = {0x0A,0x58,0x5A,0x5D,0x00,0x93,0x97,0x0B,0x60,0xA9,0x48,0x05,0x0C,0x15,0xAE,0x80,0xAD,0x3D,0x14,0x30,0x7D,0xD9,0x50,0x92,0x92,0xAC,0x0D,0xC5,0xCD,0x2A,0x82,0xAA,0x3B,0x98,0x04,0xB3,0x4A,0xC8,0x9A,0x90,0x05,0x09,0x68,0x51,0xD4,0x01,0x23,0x9F,0x1A,0x60,0xA9,0x12,0x03,0xDC,0x50,0x81,0x80,0x22,0xDC,0x20,0x00,0xCB,0x06,0x3A,0x60,0x16,0xE3,0x64,0x64,0x42,0xDD,0xCD,0x6A,0x8A,0x5D,0x28,0x75,0x07,0xA9,0x2A,0x5E,0x65,0x34,0xED,0x64,0xBB,0xF8,0x85,0xF2,0x94,0x8B,0xAD,0xE4,0x37,0x4A,0x5B,0x21,0xB6,0x52,0x50,0x19,0xAD,0xA7,0xD8,0x4A,0x41,0x14,0xDA,0x5E,0x12,0x3A,0x04,0x91,0x4B,0x7B,0x69,0xA8,0x10,0x24,0x2E,0xE5,0xA3,0x81,0x52,0x90,0x94,0x5A,0x55,0x98,0x32,0x41,0x50,0xCC,0x93,0x2E,0x47,0x85,0x89,0x1B,0x5B,0x5A,0x62,0x04,0x44,0xE3,0x02,0x80,0x80,0x64,0xDD,0xFF,0x1F};
//const uint8_t spSEVENTEEN[] PROGMEM = {0x02,0x98,0x3A,0x42,0x00,0x5B,0xA6,0x09,0x60,0xDB,0x52,0x06,0x1C,0x93,0x29,0x80,0xA9,0x52,0x87,0x9A,0xB5,0x99,0x4F,0xC8,0x3E,0x46,0xD6,0x5E,0x7E,0x66,0xFB,0x98,0xC5,0x5A,0xC6,0x9A,0x9C,0x63,0x15,0x6B,0x11,0x13,0x8A,0x9C,0x97,0xB9,0x9A,0x5A,0x39,0x71,0xEE,0xD2,0x29,0xC2,0xA6,0xB8,0x58,0x59,0x99,0x56,0x14,0xA3,0xE1,0x26,0x19,0x19,0xE3,0x8C,0x93,0x17,0xB4,0x46,0xB5,0x88,0x71,0x9E,0x97,0x9E,0xB1,0x2C,0xC5,0xF8,0x56,0xC4,0x58,0xA3,0x1C,0xE1,0x33,0x9D,0x13,0x41,0x8A,0x43,0x58,0xAD,0x95,0xA9,0xDB,0x36,0xC0,0xD1,0xC9,0x0E,0x58,0x4E,0x45,0x01,0x23,0xA9,0x04,0x37,0x13,0xAE,0x4D,0x65,0x52,0x82,0xCA,0xA9,0x37,0x99,0x4D,0x89,0xBA,0xC0,0xBC,0x14,0x36,0x25,0xEA,0x1C,0x73,0x52,0x1D,0x97,0xB8,0x33,0xAC,0x0E,0x75,0x9C,0xE2,0xCE,0xB0,0xDA,0xC3,0x51,0x4A,0x1A,0xA5,0xCA,0x70,0x5B,0x21,0xCE,0x4C,0x26,0xD2,0x6C,0xBA,0x38,0x71,0x2E,0x1F,0x2D,0xED,0xE2,0x24,0xB8,0xBC,0x3D,0x52,0x88,0xAB,0x50,0x8E,0xA8,0x48,0x22,0x4E,0x42,0xA0,0x26,0x55,0xFD,0x3F};
//const uint8_t spEIGHTEEN[] PROGMEM = {0x2E,0x9C,0xD1,0x4D,0x54,0xEC,0x2C,0xBF,0x1B,0x8A,0x99,0x70,0x7C,0xFC,0x2E,0x29,0x6F,0x52,0xF6,0xF1,0xBA,0x20,0xBF,0x36,0xD9,0xCD,0xED,0x0C,0xF3,0x27,0x64,0x17,0x73,0x2B,0xA2,0x99,0x90,0x65,0xEC,0xED,0x40,0x73,0x32,0x12,0xB1,0xAF,0x30,0x35,0x0B,0xC7,0x00,0xE0,0x80,0xAE,0xDD,0x1C,0x70,0x43,0xAA,0x03,0x86,0x51,0x36,0xC0,0x30,0x64,0xCE,0x4C,0x98,0xFB,0x5C,0x65,0x07,0xAF,0x10,0xEA,0x0B,0x66,0x1B,0xFC,0x46,0xA8,0x3E,0x09,0x4D,0x08,0x2A,0xA6,0x3E,0x67,0x36,0x21,0x2A,0x98,0x67,0x9D,0x15,0xA7,0xA8,0x60,0xEE,0xB6,0x94,0x99,0xA2,0x4A,0x78,0x22,0xC2,0xA6,0x8B,0x8C,0x8E,0xCC,0x4C,0x8A,0x2E,0x8A,0x4C,0xD3,0x57,0x03,0x87,0x28,0x71,0x09,0x1F,0x2B,0xE4,0xA2,0xC4,0xC5,0x6D,0xAD,0x54,0x88,0xB2,0x63,0xC9,0xF2,0x50,0x2E,0x8A,0x4A,0x38,0x4A,0xEC,0x88,0x28,0x08,0xE3,0x28,0x49,0xF3,0xFF};
//const uint8_t spNINETEEN[] PROGMEM = {0xC2,0xEA,0x8A,0x95,0x2B,0x6A,0x05,0x3F,0x71,0x71,0x5F,0x0D,0x12,0xFC,0x28,0x25,0x62,0x35,0xF0,0xF0,0xB3,0x48,0x1E,0x0F,0xC9,0xCB,0x2F,0x45,0x7C,0x2C,0x25,0x1F,0xBF,0x14,0xB3,0x2C,0xB5,0x75,0xFC,0x5A,0x5C,0xA3,0x5D,0xE1,0xF1,0x7A,0x76,0xB3,0x4E,0x45,0xC7,0xED,0x96,0x23,0x3B,0x18,0x37,0x7B,0x18,0xCC,0x09,0x51,0x13,0x4C,0xAB,0x6C,0x4C,0x4B,0x96,0xD2,0x49,0xAA,0x36,0x0B,0xC5,0xC2,0x20,0x26,0x27,0x35,0x63,0x09,0x3D,0x30,0x8B,0xF0,0x48,0x5C,0xCA,0x61,0xDD,0xCB,0xCD,0x91,0x03,0x8E,0x4B,0x76,0xC0,0xCC,0x4D,0x06,0x98,0x31,0x31,0x98,0x99,0x70,0x6D,0x2A,0xA3,0xE4,0x16,0xCA,0xBD,0xCE,0x5C,0x92,0x57,0x28,0xCF,0x09,0x69,0x2E,0x7E,0xA5,0x3C,0x63,0xA2,0x30,0x05,0x95,0xD2,0x74,0x98,0xCD,0x14,0x54,0xCA,0x53,0xA9,0x96,0x52,0x50,0x28,0x6F,0xBA,0xCB,0x0C,0x41,0x50,0xDE,0x65,0x2E,0xD3,0x05,0x89,0x4B,0x7B,0x6B,0x20,0x17,0x44,0xAE,0xED,0x23,0x81,0x52,0x90,0x85,0x73,0x57,0xD0,0x72,0x41,0xB1,0x02,0xDE,0x2E,0xDB,0x04,0x89,0x05,0x79,0xBB,0x62,0xE5,0x76,0x11,0xCA,0x61,0x0E,0xFF,0x1F};
//const uint8_t spTWENTY[] PROGMEM = {0x01,0x98,0xD1,0xC2,0x00,0xCD,0xA4,0x32,0x20,0x79,0x13,0x04,0x28,0xE7,0x92,0xDC,0x70,0xCC,0x5D,0xDB,0x76,0xF3,0xD2,0x32,0x0B,0x0B,0x5B,0xC3,0x2B,0xCD,0xD4,0xDD,0x23,0x35,0xAF,0x44,0xE1,0xF0,0xB0,0x6D,0x3C,0xA9,0xAD,0x3D,0x35,0x0E,0xF1,0x0C,0x8B,0x28,0xF7,0x34,0x01,0x68,0x22,0xCD,0x00,0xC7,0xA4,0x04,0xBB,0x32,0xD6,0xAC,0x56,0x9C,0xDC,0xCA,0x28,0x66,0x53,0x51,0x70,0x2B,0xA5,0xBC,0x0D,0x9A,0xC1,0xEB,0x14,0x73,0x37,0x29,0x19,0xAF,0x33,0x8C,0x3B,0xA7,0x24,0xBC,0x42,0xB0,0xB7,0x59,0x09,0x09,0x3C,0x96,0xE9,0xF4,0x58,0xFF,0x0F};
const uint8_t spTHIRTY[] PROGMEM = {0x08,0x98,0xD6,0x15,0x01,0x43,0xBB,0x0A,0x20,0x1B,0x8B,0xE5,0x16,0xA3,0x1E,0xB6,0xB6,0x96,0x97,0x3C,0x57,0xD4,0x2A,0x5E,0x7E,0x4E,0xD8,0xE1,0x6B,0x7B,0xF8,0x39,0x63,0x0D,0x9F,0x95,0xE1,0xE7,0x4C,0x76,0xBC,0x91,0x5B,0x90,0x13,0xC6,0x68,0x57,0x4E,0x41,0x8B,0x10,0x5E,0x1D,0xA9,0x44,0xD3,0xBA,0x47,0xB8,0xDD,0xE4,0x35,0x86,0x11,0x93,0x94,0x92,0x5F,0x29,0xC7,0x4C,0x30,0x0C,0x41,0xC5,0x1C,0x3B,0x2E,0xD3,0x05,0x15,0x53,0x6C,0x07,0x4D,0x15,0x14,0x8C,0xB5,0xC9,0x6A,0x44,0x90,0x10,0x4E,0x9A,0xB6,0x21,0x81,0x23,0x3A,0x91,0x91,0xE8,0xFF,0x01};
//const uint8_t spFOURTY[] PROGMEM = {0x04,0x18,0xB6,0x4C,0x00,0xC3,0x56,0x30,0xA0,0xE8,0xF4,0xA0,0x98,0x99,0x62,0x91,0xAE,0x83,0x6B,0x77,0x89,0x78,0x3B,0x09,0xAE,0xBD,0xA6,0x1E,0x63,0x3B,0x79,0x7E,0x71,0x5A,0x8F,0x95,0xE6,0xA5,0x4A,0x69,0xB9,0x4E,0x8A,0x5F,0x12,0x56,0xE4,0x58,0x69,0xE1,0x36,0xA1,0x69,0x2E,0x2B,0xF9,0x95,0x93,0x55,0x17,0xED,0xE4,0x37,0xC6,0xBA,0x93,0xB2,0x92,0xDF,0x19,0xD9,0x6E,0xC8,0x0A,0xFE,0x60,0xE8,0x37,0x21,0xC9,0xF9,0x8D,0x61,0x5F,0x32,0x13,0xE7,0x17,0x4C,0xD3,0xC6,0xB1,0x94,0x97,0x10,0x8F,0x8B,0xAD,0x11,0x7E,0xA1,0x9A,0x26,0x92,0xF6,0xFF,0x01};
//const uint8_t spFIFTY[] PROGMEM = {0x08,0xE8,0x2E,0x84,0x00,0x23,0x84,0x13,0x60,0x38,0x95,0xA5,0x0F,0xCF,0xE2,0x79,0x8A,0x8F,0x37,0x02,0xB3,0xD5,0x2A,0x6E,0x5E,0x93,0x94,0x79,0x45,0xD9,0x05,0x5D,0x0A,0xB9,0x97,0x63,0x02,0x74,0xA7,0x82,0x80,0xEE,0xC3,0x10,0xD0,0x7D,0x28,0x03,0x6E,0x14,0x06,0x70,0xE6,0x0A,0xC9,0x9A,0x4E,0x37,0xD9,0x95,0x51,0xCE,0xBA,0xA2,0x14,0x0C,0x81,0x36,0x1B,0xB2,0x5C,0x30,0x38,0xFA,0x9C,0xC9,0x32,0x41,0xA7,0x18,0x3B,0xA2,0x48,0x04,0x05,0x51,0x4F,0x91,0x6D,0x12,0x04,0x20,0x9B,0x61,0x89,0xFF,0x1F};
const uint8_t spGOOD[] PROGMEM = {0x0A,0x28,0xCD,0x34,0x20,0xD9,0x1A,0x45,0x74,0xE4,0x66,0x24,0xAD,0xBA,0xB1,0x8C,0x9B,0x91,0xA5,0x64,0xE6,0x98,0x21,0x16,0x0B,0x96,0x9B,0x4C,0xE5,0xFF,0x01};
const uint8_t spMORNING[] PROGMEM = {0xCE,0x08,0x52,0x2A,0x35,0x5D,0x39,0x53,0x29,0x5B,0xB7,0x0A,0x15,0x0C,0xEE,0x2A,0x42,0x56,0x66,0xD2,0x55,0x2E,0x37,0x2F,0xD9,0x45,0xB3,0xD3,0xC5,0xCA,0x6D,0x27,0xD5,0xEE,0x50,0xF5,0x50,0x94,0x14,0x77,0x2D,0xD8,0x5D,0x49,0x92,0xFD,0xB1,0x64,0x2F,0xA9,0x49,0x0C,0x93,0x4B,0xAD,0x19,0x17,0x3E,0x66,0x1E,0xF1,0xA2,0x5B,0x84,0xE2,0x29,0x8F,0x8B,0x72,0x10,0xB5,0xB1,0x2E,0x4B,0xD4,0x45,0x89,0x4A,0xEC,0x5C,0x95,0x14,0x2B,0x8A,0x9C,0x34,0x52,0x5D,0xBC,0xCC,0xB5,0x3B,0x49,0x69,0x89,0x87,0xC1,0x98,0x56,0x3A,0x21,0x2B,0x82,0x67,0xCC,0x5C,0x85,0xB5,0x4A,0x8A,0xF6,0x64,0xA9,0x96,0xC4,0x69,0x3C,0x52,0x81,0x58,0x1C,0x97,0xF6,0x0E,0x1B,0xCC,0x0D,0x42,0x32,0xAA,0x65,0x12,0x67,0xD4,0x6A,0x61,0x52,0xFC,0xFF};
//const uint8_t spAFTERNOON[] PROGMEM = {0xC7,0xCE,0xCE,0x3A,0xCB,0x58,0x1F,0x3B,0x07,0x9D,0x28,0x71,0xB4,0xAC,0x9C,0x74,0x5A,0x42,0x55,0x33,0xB2,0x93,0x0A,0x09,0xD4,0xC5,0x9A,0xD6,0x44,0x45,0xE3,0x38,0x60,0x9A,0x32,0x05,0xF4,0x18,0x01,0x09,0xD8,0xA9,0xC2,0x00,0x5E,0xCA,0x24,0xD5,0x5B,0x9D,0x4A,0x95,0xEA,0x34,0xEE,0x63,0x92,0x5C,0x4D,0xD0,0xA4,0xEE,0x58,0x0C,0xB9,0x4D,0xCD,0x42,0xA2,0x3A,0x24,0x37,0x25,0x8A,0xA8,0x8E,0xA0,0x53,0xE4,0x28,0x23,0x26,0x13,0x72,0x91,0xA2,0x76,0xBB,0x72,0x38,0x45,0x0A,0x46,0x63,0xCA,0x69,0x27,0x39,0x58,0xB1,0x8D,0x60,0x1C,0x34,0x1B,0x34,0xC3,0x55,0x8E,0x73,0x45,0x2D,0x4F,0x4A,0x3A,0x26,0x10,0xA1,0xCA,0x2D,0xE9,0x98,0x24,0x0A,0x1E,0x6D,0x97,0x29,0xD2,0xCC,0x71,0xA2,0xDC,0x86,0xC8,0x12,0xA7,0x8E,0x08,0x85,0x22,0x8D,0x9C,0x43,0xA7,0x12,0xB2,0x2E,0x50,0x09,0xEF,0x51,0xC5,0xBA,0x28,0x58,0xAD,0xDB,0xE1,0xFF,0x03};
//const uint8_t spEVENING[] PROGMEM = {0xCD,0x6D,0x98,0x73,0x47,0x65,0x0D,0x6D,0x10,0xB2,0x5D,0x93,0x35,0x94,0xC1,0xD0,0x76,0x4D,0x66,0x93,0xA7,0x04,0xBD,0x71,0xD9,0x45,0xAE,0x92,0xD5,0xAC,0x53,0x07,0x6D,0xA5,0x76,0x63,0x51,0x92,0xD4,0xA1,0x83,0xD4,0xCB,0xB2,0x51,0x88,0xCD,0xF5,0x50,0x45,0xCE,0xA2,0x2E,0x27,0x28,0x54,0x15,0x37,0x0A,0xCF,0x75,0x61,0x5D,0xA2,0xC4,0xB5,0xC7,0x44,0x55,0x8A,0x0B,0xA3,0x6E,0x17,0x95,0x21,0xA9,0x0C,0x37,0xCD,0x15,0xBA,0xD4,0x2B,0x6F,0xB3,0x54,0xE4,0xD2,0xC8,0x64,0xBC,0x4C,0x91,0x49,0x12,0xE7,0xB2,0xB1,0xD0,0x22,0x0D,0x9C,0xDD,0xAB,0x62,0xA9,0x38,0x53,0x11,0xA9,0x74,0x2C,0xD2,0xCA,0x59,0x34,0xA3,0xE5,0xFF,0x03};
const uint8_t spPAUSE1[] PROGMEM = {0x00,0x00,0x00,0x00,0xFF,0x0F};
void setup() {
CircuitPlayground.begin();
CircuitPlayground.speaker.say(spGOOD);
CircuitPlayground.speaker.say(spMORNING);
CircuitPlayground.speaker.say(spPAUSE1);
CircuitPlayground.speaker.say(spTHE);
CircuitPlayground.speaker.say(spTIME);
CircuitPlayground.speaker.say(spIS);
CircuitPlayground.speaker.say(spELEVEN);
CircuitPlayground.speaker.say(spTHIRTY);
CircuitPlayground.speaker.say(spSIX);
CircuitPlayground.speaker.say(spA_M_);
CircuitPlayground.speaker.say(spPAUSE1);
// Calling speaker.end() after playing a sound is optional -- this
// will turn off the pin 13 LED (it's connected to a microcontroller
// pin that's also related to the speaker), but there's a small
// audible click when it turns off. Tradeoffs!
CircuitPlayground.speaker.end();
}
void loop() {
}

444
arduino-cli/libraries/Adafruit_Circuit_Playground/examples/Speech_Demos/Talk_US_Large/Talk_US_Large.ino Normal file
View File

@@ -0,0 +1,444 @@
// Talkie library
// Copyright 2011 Peter Knight
// This code is released under GPLv2 license.
//
// The following phrases are derived from VM61003/4/5 ROMs
//
// A male voice with a US accent.
//
// These phrases have a very military bias
// with lots of very useful engineering words.
// They also have good expression.
//
#include <Adafruit_CircuitPlayground.h>
#include <Wire.h>
#include <SPI.h>
// ROM VM61003
//const uint8_t spZERO[] PROGMEM = {0x69,0xFB,0x59,0xDD,0x51,0xD5,0xD7,0xB5,0x6F,0x0A,0x78,0xC0,0x52,0x01,0x0F,0x50,0xAC,0xF6,0xA8,0x16,0x15,0xF2,0x7B,0xEA,0x19,0x47,0xD0,0x64,0xEB,0xAD,0x76,0xB5,0xEB,0xD1,0x96,0x24,0x6E,0x62,0x6D,0x5B,0x1F,0x0A,0xA7,0xB9,0xC5,0xAB,0xFD,0x1A,0x62,0xF0,0xF0,0xE2,0x6C,0x73,0x1C,0x73,0x52,0x1D,0x19,0x94,0x6F,0xCE,0x7D,0xED,0x6B,0xD9,0x82,0xDC,0x48,0xC7,0x2E,0x71,0x8B,0xBB,0xDF,0xFF,0x1F};
//const uint8_t spONE[] PROGMEM = {0x66,0x4E,0xA8,0x7A,0x8D,0xED,0xC4,0xB5,0xCD,0x89,0xD4,0xBC,0xA2,0xDB,0xD1,0x27,0xBE,0x33,0x4C,0xD9,0x4F,0x9B,0x4D,0x57,0x8A,0x76,0xBE,0xF5,0xA9,0xAA,0x2E,0x4F,0xD5,0xCD,0xB7,0xD9,0x43,0x5B,0x87,0x13,0x4C,0x0D,0xA7,0x75,0xAB,0x7B,0x3E,0xE3,0x19,0x6F,0x7F,0xA7,0xA7,0xF9,0xD0,0x30,0x5B,0x1D,0x9E,0x9A,0x34,0x44,0xBC,0xB6,0x7D,0xFE,0x1F};
//const uint8_t spTWO[] PROGMEM = {0x06,0xB8,0x59,0x34,0x00,0x27,0xD6,0x38,0x60,0x58,0xD3,0x91,0x55,0x2D,0xAA,0x65,0x9D,0x4F,0xD1,0xB8,0x39,0x17,0x67,0xBF,0xC5,0xAE,0x5A,0x1D,0xB5,0x7A,0x06,0xF6,0xA9,0x7D,0x9D,0xD2,0x6C,0x55,0xA5,0x26,0x75,0xC9,0x9B,0xDF,0xFC,0x6E,0x0E,0x63,0x3A,0x34,0x70,0xAF,0x3E,0xFF,0x1F};
//const uint8_t spTHREE[] PROGMEM = {0x0C,0xE8,0x2E,0x94,0x01,0x4D,0xBA,0x4A,0x40,0x03,0x16,0x68,0x69,0x36,0x1C,0xE9,0xBA,0xB8,0xE5,0x39,0x70,0x72,0x84,0xDB,0x51,0xA4,0xA8,0x4E,0xA3,0xC9,0x77,0xB1,0xCA,0xD6,0x52,0xA8,0x71,0xED,0x2A,0x7B,0x4B,0xA6,0xE0,0x37,0xB7,0x5A,0xDD,0x48,0x8E,0x94,0xF1,0x64,0xCE,0x6D,0x19,0x55,0x91,0xBC,0x6E,0xD7,0xAD,0x1E,0xF5,0xAA,0x77,0x7A,0xC6,0x70,0x22,0xCD,0xC7,0xF9,0x89,0xCF,0xFF,0x03};
//const uint8_t spFOUR[] PROGMEM = {0x08,0x68,0x21,0x0D,0x03,0x1C,0x90,0xC0,0x88,0x92,0xB2,0x29,0x87,0x76,0x2B,0x2D,0x5C,0x7B,0x06,0xD9,0xED,0x74,0x64,0x51,0x54,0x4D,0xA2,0xBA,0x99,0xB7,0x3A,0xF8,0xEA,0x74,0xCA,0xD3,0x87,0xBE,0x94,0x3D,0xA4,0xD4,0x4E,0xC9,0x5F,0xF7,0x72,0xA7,0x9C,0x1C,0x63,0xDE,0xF2,0x9B,0xBE,0x34,0x84,0x27,0x2D,0x4B,0xF8,0x53,0x09,0x9C,0x0E,0xB7,0xEE,0xCB,0x5B,0x70,0xDD,0xB2,0xFC,0x3F};
//const uint8_t spFIVE[] PROGMEM = {0x08,0x68,0x4E,0x9D,0x02,0x1C,0x60,0xC0,0x8C,0x69,0x12,0xB0,0xC0,0x28,0xAB,0x8C,0x9C,0xC0,0x2D,0xBB,0x38,0x79,0x31,0x15,0xA3,0xB6,0xE4,0x16,0xB7,0xDC,0xF5,0x6E,0x57,0xDF,0x54,0x5B,0x85,0xBE,0xD9,0xE3,0x5C,0xC6,0xD6,0x6D,0xB1,0xA5,0xBF,0x99,0x5B,0x3B,0x5A,0x30,0x09,0xAF,0x2F,0xED,0xEC,0x31,0xC4,0x5C,0xBE,0xD6,0x33,0xDD,0xAD,0x88,0x87,0xE2,0xD2,0xF2,0xF4,0xE0,0x16,0x2A,0xB2,0xE3,0x63,0x1F,0xF9,0xF0,0xE7,0xFF,0x01};
//const uint8_t spSIX[] PROGMEM = {0x04,0xF8,0xB9,0x55,0x01,0xBF,0xA5,0x1B,0xE0,0x37,0x0F,0x03,0xFC,0x96,0x61,0x80,0xDF,0x3C,0x0C,0xF0,0x93,0xDA,0x4A,0x87,0x49,0x53,0x91,0x37,0x2B,0x6D,0xD2,0x55,0x23,0xDE,0xAC,0xAA,0xB9,0x16,0x09,0xFF,0xB2,0xFA,0x66,0x93,0x3C,0x63,0xF3,0x9C,0x10,0x38,0x45,0xA9,0x0A,0xD5,0x00,0x00,0x02,0x14,0x97,0xAA,0x80,0xAB,0x6B,0x0D,0xF0,0x63,0xA5,0x01,0x7E,0xCB,0x30,0xC0,0x6F,0xE9,0x0A,0xF8,0x25,0x93,0x01,0x3F,0x57,0xFC,0x3F};
//const uint8_t spSEVEN[] PROGMEM = {0x0C,0x78,0xC6,0x95,0x01,0x3F,0xA5,0x28,0xE0,0xB7,0x52,0x0B,0x04,0xE0,0xB7,0x54,0x07,0xFC,0x52,0x66,0x80,0x9F,0xCB,0x56,0x59,0x6C,0x98,0x47,0x3E,0x59,0x4D,0x89,0x69,0x66,0xB9,0x7A,0x34,0x39,0x86,0x9B,0xD9,0xA6,0xD4,0xE7,0x10,0xAE,0xCA,0xAD,0x47,0x97,0x5D,0x9A,0xA9,0xAE,0x1A,0x75,0xB1,0xA5,0x66,0xF9,0xB2,0xD4,0x4D,0x63,0xB6,0x84,0x9A,0x52,0x76,0x45,0x11,0x1A,0xAA,0x4B,0x31,0x0C,0x79,0x4A,0xB0,0x49,0xC5,0x50,0xA2,0x41,0xA1,0xC9,0x65,0xD9,0xAB,0x89,0x56,0x84,0xFF,0x07};
//const uint8_t spEIGHT[] PROGMEM = {0xAD,0x1B,0xDE,0x58,0x23,0x17,0xAF,0x6E,0xE8,0x20,0xEB,0x5C,0xBC,0xEA,0x61,0x03,0xAD,0x73,0xF6,0xAA,0x66,0x4A,0xD0,0xCC,0xD9,0xAB,0x1E,0x45,0xC1,0xA3,0x66,0xAF,0x61,0x36,0x03,0x8B,0x5A,0x9C,0xA6,0x51,0x04,0xA2,0x66,0x96,0xBB,0xBA,0x47,0xEC,0xED,0x8A,0x08,0x9C,0xA2,0x54,0x85,0x6A,0x00,0x80,0x02,0x86,0x74,0x63,0xC0,0xE6,0x6A,0xFF,0x0F};
//const uint8_t spNINE[] PROGMEM = {0x62,0x75,0xDC,0x33,0xB5,0x62,0xB9,0x25,0x0B,0x8E,0x34,0x8F,0xD3,0xA6,0xAE,0x59,0xD2,0x34,0xE9,0x18,0x87,0x27,0xC9,0xD0,0x78,0xAB,0x6F,0xCE,0xC2,0x45,0x1B,0xAF,0xB6,0xF8,0x51,0x73,0x9D,0xB3,0x9A,0x12,0xC7,0x2C,0x6D,0xC9,0xAA,0x73,0x4B,0xF3,0x88,0x26,0xAB,0xCE,0x2D,0xCC,0x23,0xEA,0xAC,0x26,0xB7,0xD0,0x88,0x98,0xB3,0xBA,0x5C,0x43,0x32,0x7D,0xCE,0x1A,0x4A,0x0A,0xCD,0xF4,0x39,0x6B,0xAA,0x3E,0x24,0xCB,0x67,0xAF,0xB5,0xD9,0xE4,0x18,0x5F,0xB4,0xF6,0x6E,0x92,0x62,0x7D,0xD1,0x38,0xBA,0x09,0xF2,0x8D,0x59,0xED,0xE8,0x3A,0xD8,0x27,0x16,0xA6,0xBB,0x7B,0xF2,0x74,0x4F,0x92,0x9E,0x1E,0xC8,0x4A,0xC3,0x49,0x7A,0x9A,0x25,0x2B,0xF5,0x24,0xE9,0xEE,0xD1,0x24,0x25,0x27,0xBA,0xBB,0x25,0x51,0xD3,0xAA,0x24,0xAE,0x5E,0x54,0x55,0x3A,0xD4,0xFF,0x03};
//const uint8_t spTEN[] PROGMEM = {0x0A,0xD8,0x5C,0x4D,0x03,0x2B,0xAB,0x5E,0xC4,0x33,0x2B,0xAF,0x62,0x84,0x12,0x0D,0x7B,0xB3,0xCA,0x66,0x43,0xA2,0xE3,0xF6,0xAA,0xAA,0x4E,0xC9,0x89,0xDB,0xAB,0x6E,0xBA,0xC5,0xDB,0x66,0xAF,0xB9,0xE8,0xE6,0x4C,0xBF,0x3D,0xE6,0x6A,0xC4,0x4B,0xCA,0x49,0xD9,0xBA,0x61,0x2B,0x09,0x25,0xED,0xE8,0x5A,0xB4,0xC4,0xED,0xA6,0x6B,0x18,0xE1,0x56,0xB7,0x9A,0xAE,0xA6,0x44,0x47,0xDC,0x6E,0xBE,0xC2,0xDD,0xA5,0xF0,0xB8,0xD9,0xFD,0x7F};
//const uint8_t spELEVEN[] PROGMEM = {0x29,0x6F,0x52,0xA8,0xBB,0x6A,0x8F,0xBA,0x2B,0xC5,0xE8,0x9C,0xBD,0xAA,0x61,0x1D,0xB5,0xE3,0xF1,0xAA,0x9A,0x35,0xB6,0xB0,0xC5,0xAB,0x5E,0x44,0x53,0x4D,0xBA,0xAD,0x7A,0x42,0x1B,0xE1,0x5C,0xB3,0x9A,0x09,0x6D,0x94,0x62,0xE9,0x6A,0x8A,0x6A,0x37,0x8D,0xC7,0xAB,0x69,0xBC,0xDD,0xCC,0x5F,0xAF,0xB6,0xC9,0x76,0x37,0x7F,0xBD,0xDA,0x62,0xCA,0xDD,0x62,0xD1,0xEA,0xB2,0xCB,0x70,0xA3,0x45,0x69,0xCA,0x36,0xDD,0x14,0x1B,0xAE,0xBE,0x98,0x74,0x33,0x5E,0x39,0xFA,0x6C,0xC3,0x42,0xFC,0xF1,0xE8,0x8B,0x2E,0x71,0x8D,0xDB,0x63,0xA8,0x1A,0xAB,0x39,0x9C,0x8C,0xBE,0x69,0xCA,0xD2,0x50,0x32,0xFA,0xA6,0xD8,0x4B,0x52,0x71,0xEB,0xAA,0xE4,0x28,0x4E,0xD5,0xAD,0xCB,0xC2,0x3C,0x35,0x1D,0xB5,0x36,0xDB,0x14,0xAB,0x8C,0xF4,0xFF};
//const uint8_t spTWELVE[] PROGMEM = {0x09,0x98,0xDA,0x22,0x01,0x37,0x78,0x1A,0x20,0x85,0xD1,0x50,0x3A,0x33,0x11,0x81,0x5D,0x5B,0x95,0xD4,0x44,0x04,0x76,0x9D,0xD5,0xA9,0x3A,0xAB,0xF0,0xA1,0x3E,0xB7,0xBA,0xD5,0xA9,0x2B,0xEB,0xCC,0xA0,0x3E,0xB7,0xBD,0xC3,0x5A,0x3B,0xC8,0x69,0x67,0xBD,0xFB,0xE8,0x67,0xBF,0xCA,0x9D,0xE9,0x74,0x08,0xE7,0xCE,0x77,0x78,0x06,0x89,0x32,0x57,0xD6,0xF1,0xF1,0x8F,0x7D,0xFE,0x1F};
//const uint8_t spTHIRTEEN[] PROGMEM = {0x08,0x18,0xA2,0x12,0x03,0x18,0x40,0xC0,0x50,0x13,0x25,0x1D,0x3A,0x55,0x9D,0x5B,0xAF,0xAA,0xAB,0x74,0x4A,0xE9,0xB6,0xAA,0x6A,0xC7,0xA0,0xDD,0xDD,0xA8,0xAA,0x1F,0x82,0x75,0xED,0xA5,0x2A,0x8D,0x31,0xC6,0xB3,0x21,0x70,0x8A,0x52,0x15,0xAA,0x01,0x00,0x10,0x80,0xED,0x2C,0x12,0x70,0x53,0x55,0x00,0x66,0x2E,0x1D,0xD9,0x8C,0x46,0x14,0xB9,0x64,0xD5,0xD3,0x1B,0xD2,0xD4,0xAC,0xD1,0x2E,0x6B,0x44,0x9B,0xA5,0x46,0xBF,0xAC,0x91,0x6E,0x04,0x19,0xE3,0xD2,0x4A,0x76,0x6E,0xA4,0x2D,0xCB,0x2A,0xC9,0x65,0xE8,0xB6,0x0D,0x29,0x6C,0xEB,0xA1,0xC3,0xD1,0x1D,0x54,0xB9,0x28,0x75,0x67,0xB7,0x90,0xE5,0x6A,0x27,0xDC,0xDD,0xA1,0xB7,0xB9,0x92,0xF2,0x77,0x1B,0x1C,0x92,0x0D,0xDD,0xDF,0x92,0x9A,0x59,0x55,0xFC,0x7F};
//const uint8_t spFOURTEEN[] PROGMEM = {0x08,0xE8,0x2A,0x94,0x00,0xC3,0x56,0x10,0x60,0xFA,0x0A,0x01,0x4C,0x97,0xAE,0x80,0x66,0xCB,0x4A,0x6F,0xF3,0x84,0xB1,0xB4,0x6E,0x9D,0x73,0x57,0x1A,0xD0,0x6E,0x74,0xC1,0x7D,0x71,0x61,0xD6,0x51,0x07,0xF7,0x26,0x25,0xDE,0x46,0x15,0xED,0x52,0x37,0xFB,0x29,0x65,0x1E,0x18,0x61,0xD6,0x1A,0x81,0x53,0x94,0xAA,0x50,0x0D,0x00,0x80,0x02,0x2C,0xE3,0x5E,0x80,0x13,0xBA,0x13,0x30,0x43,0xDB,0x2A,0x46,0x34,0xA2,0x8E,0xC5,0xAB,0x9A,0xDE,0x88,0x2E,0x4A,0xAD,0x7A,0x7A,0x25,0x7E,0x0F,0xB2,0xDA,0x69,0x84,0xED,0xC4,0xEC,0xEA,0xA6,0x15,0xF6,0x53,0xB1,0x6B,0x18,0x56,0x38,0x4F,0xCC,0x8D,0x71,0x5A,0x61,0x7F,0x35,0x3A,0xC6,0xA1,0x44,0xFC,0xCD,0x74,0x9B,0xBA,0xC1,0xCA,0x54,0xAB,0x6D,0x6C,0x06,0x3B,0x5D,0xED,0xB4,0xA1,0x29,0x6A,0x37,0x57,0xDD,0x86,0x2A,0xA9,0x52,0x43,0x51,0xEB,0xAA,0x0E,0x8E,0xA8,0x48,0xFF,0x0F};
//const uint8_t spFIFTEEN[] PROGMEM = {0x02,0x68,0xD6,0xCC,0x00,0x43,0x9A,0x39,0x60,0x3A,0xF7,0x51,0x34,0x5B,0x6A,0x2C,0x6D,0x4E,0xD5,0x92,0x99,0x89,0x2C,0x39,0x55,0xF3,0xAE,0xA6,0x32,0x67,0x54,0xC5,0x99,0xB9,0xC8,0x1C,0x07,0x0C,0xA5,0x94,0x01,0x04,0x4E,0x51,0xAA,0x42,0x35,0x00,0x02,0xB0,0x84,0x4A,0x6B,0x4F,0x6C,0x23,0x15,0x2F,0x6D,0x18,0xC1,0x44,0xC2,0x17,0x8F,0x69,0xBA,0x54,0xA8,0x58,0x3D,0xE6,0x6D,0x53,0xA1,0x73,0xF5,0x5A,0xA6,0x31,0xA2,0x8D,0x89,0x63,0x9D,0xCE,0x88,0xD6,0x47,0xB6,0x75,0x5B,0x13,0x6C,0xAF,0x54,0x96,0x61,0x84,0x22,0x64,0x74,0x59,0x9A,0x61,0x4B,0x0D,0xA7,0x65,0x6A,0x86,0xD2,0x23,0x5C,0xA7,0xB1,0x08,0xCA,0xB0,0x70,0x9D,0x86,0xA2,0x38,0xC9,0xA2,0x55,0xE8,0x32,0x11,0x8F,0x94,0xD6,0xFF,0x0F};
//const uint8_t spSIXTEEN[] PROGMEM = {0x0C,0x78,0xC6,0x95,0x01,0x3F,0xA5,0x28,0xE0,0xB7,0x52,0x0B,0x04,0xE0,0xB7,0x54,0x07,0xFC,0x52,0x66,0x80,0x9F,0xCB,0x96,0xB7,0xA5,0x1B,0x9B,0x66,0x5A,0x59,0xB3,0x26,0x1A,0xF6,0xA6,0x15,0xCD,0x2B,0x59,0xFA,0x6A,0x04,0x4E,0x51,0xAA,0x42,0x35,0x40,0x01,0x25,0xA7,0x24,0xE0,0x98,0x1E,0x07,0xFC,0x9D,0x2E,0x80,0x57,0x9D,0x18,0xB0,0x05,0x6A,0x02,0xAE,0x54,0x1D,0x6D,0x77,0xCA,0xEA,0xF9,0x78,0xF5,0xD3,0x1A,0x51,0xE7,0xE2,0x35,0x4F,0x6F,0xC4,0x53,0x93,0xC6,0x3A,0x9D,0x91,0x6C,0x86,0x6A,0xC7,0x34,0x2A,0x7A,0x66,0x36,0x9D,0xD3,0xA9,0xC8,0x99,0xD5,0x72,0x75,0xC7,0x92,0xA3,0x96,0xC3,0xD3,0x3D,0x46,0xA4,0x3A,0x09,0x4F,0x73,0x98,0xE1,0xEA,0x24,0x3C,0xDD,0x92,0x87,0xBB,0x93,0xF4,0x0D,0x63,0x94,0x2E,0x75,0xFF,0x1F};
//const uint8_t spSEVENTEEN[] PROGMEM = {0x0C,0xF8,0x29,0x45,0x01,0xBF,0x95,0x5A,0x20,0x00,0xBF,0xA5,0x3A,0xE0,0x97,0x32,0x03,0xFC,0x5C,0xB6,0xAA,0x26,0x53,0xD5,0x7D,0xF5,0x6A,0x8A,0x4E,0xB5,0xCC,0x47,0xAB,0xAB,0xAA,0xD4,0xC2,0x36,0xA7,0x31,0xF9,0x30,0x33,0x49,0x9D,0x86,0x6C,0xD5,0x5D,0xA4,0xF5,0xE8,0xAB,0x32,0x37,0x97,0x95,0x69,0xA8,0x0A,0x7B,0x50,0xD5,0xA5,0xA1,0x69,0xA8,0x56,0x63,0x1B,0xC6,0xA6,0xB1,0x43,0xD4,0x35,0x24,0xE0,0x18,0xB3,0x96,0xAF,0xBC,0x99,0x86,0x9A,0x5A,0xD5,0x2C,0x71,0xD6,0xC4,0x5C,0xF5,0x2C,0x4E,0x94,0x31,0x6B,0x35,0x33,0x1A,0xF2,0x64,0xE9,0xD5,0x4F,0xAF,0xA8,0x1B,0x81,0xC7,0xBC,0xAC,0x91,0x9E,0x1B,0x29,0xDB,0x32,0x8A,0x7A,0x19,0xA8,0xEC,0x43,0x08,0xC5,0xB9,0xE9,0xF4,0x34,0x0D,0x35,0xAE,0x76,0xD3,0x5B,0x14,0x76,0xA9,0x3B,0x4A,0x7F,0x77,0x58,0xA1,0xE6,0x38,0xFD,0xDD,0x51,0x9A,0xBB,0xAB,0xF4,0x57,0x67,0x16,0xDA,0xB3,0xFE,0x1F};
//const uint8_t spEIGHTEEN[] PROGMEM = {0x6B,0x18,0x36,0x88,0x3B,0x1B,0xEF,0x61,0x0D,0xD3,0x27,0x52,0xE5,0x9A,0x51,0x8F,0x1E,0xC8,0x96,0x4B,0x5A,0xD5,0x03,0x61,0xD5,0xCC,0x72,0x75,0x35,0x10,0xD3,0x13,0x11,0x81,0x53,0x94,0xAA,0x50,0x0D,0x80,0x02,0x2C,0x95,0x5A,0x80,0x17,0xC7,0x57,0x3E,0xBD,0x33,0x6B,0x36,0x59,0xD5,0xC8,0x4E,0xE4,0xB9,0x64,0xD5,0x33,0x24,0x61,0xE7,0xA4,0x35,0x2C,0xEF,0x28,0x9B,0xA5,0xC6,0x38,0x9D,0xA2,0x5F,0x84,0x6E,0xCB,0x74,0x8A,0x7E,0x6E,0xA6,0xEC,0xCD,0xB0,0x76,0x4B,0xD4,0x72,0x74,0x87,0x1E,0xA9,0x76,0xD2,0x3D,0x3C,0x59,0x84,0x26,0x4D,0x4F,0xD3,0x68,0x15,0xEE,0xE4,0xFF,0x01};
//const uint8_t spNINETEEN[] PROGMEM = {0x6E,0x2F,0x44,0xB4,0x5B,0x93,0xA6,0xAD,0x32,0x96,0x2E,0x69,0xBA,0x96,0x26,0xD3,0xCC,0x65,0xF1,0x1A,0x9B,0x9C,0xE0,0xD4,0x2D,0x6B,0x68,0xA6,0xCD,0xCA,0x56,0xAF,0xAE,0xB9,0x64,0x6F,0x5F,0xB4,0xEA,0xE6,0x84,0xA7,0xA3,0x52,0xAB,0x5B,0x40,0xAB,0x28,0xD3,0xAE,0xCD,0x0A,0xC7,0x5D,0x35,0x23,0x70,0x8A,0x52,0x15,0xAA,0x01,0x50,0x80,0xAB,0x4C,0x0A,0xB0,0x7C,0x4B,0xCB,0x57,0xDE,0x4C,0x43,0x4D,0xAD,0x6A,0x96,0x38,0x6B,0x62,0xAE,0x7A,0x16,0x27,0xCA,0x98,0xB5,0x9A,0x19,0x0D,0x79,0xB2,0xF4,0xEA,0xA7,0x57,0xD4,0x8D,0xC0,0x63,0x5E,0xD6,0x48,0xCF,0x8D,0x94,0x6D,0x19,0x45,0xBD,0x0C,0x54,0xF6,0x21,0x84,0xE2,0xDC,0x74,0x79,0x9A,0x86,0x1A,0x57,0xBB,0xE5,0x2D,0x0A,0xBB,0xD4,0x1D,0x95,0xBF,0x3B,0xAC,0x50,0x73,0x5C,0xFE,0xEE,0x28,0xCD,0xDD,0x55,0xF8,0xAB,0x33,0x0B,0xED,0x59,0xFF,0x0F};
//const uint8_t spTWENTY[] PROGMEM = {0x0A,0xE8,0x4A,0xCD,0x01,0xDB,0xB9,0x33,0xC0,0xA6,0x54,0x0C,0xA4,0x34,0xD9,0xF2,0x0A,0x6C,0xBB,0xB3,0x53,0x0E,0x5D,0xA6,0x25,0x9B,0x6F,0x75,0xCA,0x61,0x52,0xDC,0x74,0x49,0xA9,0x8A,0xC4,0x76,0x4D,0xD7,0xB1,0x76,0xC0,0x55,0xA6,0x65,0xD8,0x26,0x99,0x5C,0x56,0xAD,0xB9,0x25,0x23,0xD5,0x7C,0x32,0x96,0xE9,0x9B,0x20,0x7D,0xCB,0x3C,0xFA,0x55,0xAE,0x99,0x1A,0x30,0xFC,0x4B,0x3C,0xFF,0x1F};
//const uint8_t spTHIRTY[] PROGMEM = {0x02,0x18,0xA2,0x52,0x02,0x16,0x60,0xC0,0x50,0x13,0x25,0x6B,0x2C,0xC4,0xDC,0x52,0xAF,0xB2,0x8B,0x70,0x2A,0xCD,0xBA,0xAA,0xAA,0xC7,0x60,0xCC,0xFD,0xAA,0x8B,0x5D,0x85,0x35,0xED,0xA3,0x2B,0xD3,0x31,0x52,0xF2,0x2A,0xA0,0x7A,0xA5,0x00,0x2C,0xED,0xD2,0xFA,0x9E,0x8C,0x45,0x7D,0xF5,0xD8,0xBA,0x55,0xB2,0xAC,0xD5,0xED,0xE8,0xDE,0x51,0x2A,0x57,0x97,0xA7,0x07,0x41,0xAF,0x5A,0xEC,0xB6,0xEE,0x19,0x7D,0x7A,0xB1,0x9B,0xBA,0x23,0xCC,0xE9,0x5A,0xFF,0x0F};
const uint8_t spFOURTY[] PROGMEM = {0x04,0xC8,0xCE,0x8C,0x01,0xCB,0x94,0x33,0x60,0xDA,0x0C,0x01,0x0C,0x13,0xAE,0x80,0xEA,0xD3,0x4A,0x1D,0xC4,0xB4,0x26,0x39,0x1E,0x75,0xA2,0xB3,0x9C,0xAC,0x7E,0x54,0x51,0xEC,0x52,0xAA,0xFA,0x51,0x05,0x73,0xC1,0xE5,0xDC,0x47,0x9D,0xC2,0x8A,0xB5,0x6A,0x57,0x40,0xF5,0x4A,0x01,0x58,0xDA,0xA5,0x8D,0xC3,0x24,0x89,0x5B,0xAF,0xB1,0xB4,0x20,0xE4,0x5E,0x8B,0xC7,0xDA,0x9D,0xA3,0x54,0xBE,0x4E,0xF7,0x8C,0x41,0x98,0xF1,0xC6,0x3D,0x3D,0x0A,0xEA,0xF4,0x23,0xF7,0x34,0x47,0x9C,0x53,0x93,0xDC,0xD3,0x15,0x63,0x6D,0x4D,0x32,0xCF,0x98,0x41,0xA4,0xB9,0xF8,0xFF,0x01};
//const uint8_t spFIFTY[] PROGMEM = {0x08,0x68,0x3A,0x05,0x01,0x5D,0xA4,0x12,0x60,0xD8,0x0A,0x02,0x4C,0x5F,0x21,0x80,0xE9,0xD2,0x15,0xD0,0x6C,0xD9,0x4A,0x9B,0x09,0x91,0x94,0x2D,0x2B,0xEF,0x2A,0x95,0x52,0x37,0xAF,0xA2,0xD9,0x52,0x09,0xFD,0x4C,0x80,0x61,0x2B,0x08,0x30,0x7D,0x85,0x00,0xA6,0x4B,0x47,0xE0,0x14,0xA5,0x2A,0x54,0x03,0x0A,0x30,0x74,0xD9,0xE8,0xBB,0x34,0xF2,0x8C,0xD5,0x63,0xE9,0x56,0x49,0x2B,0x1F,0xAF,0x6D,0x04,0x27,0xAA,0x58,0x53,0xEE,0x19,0x93,0x30,0xFD,0x4B,0xB9,0x67,0x70,0xE4,0xAA,0xD5,0xEE,0x6D,0x96,0xB1,0xA6,0x66,0x87,0xB7,0x67,0x22,0x8F,0xA9,0xFD,0xFF};
//const uint8_t spSIXTY[] PROGMEM = {0x06,0x78,0x90,0xC4,0x00,0x3F,0x66,0x18,0xE0,0xA7,0x8C,0x04,0x7C,0x9F,0x11,0x80,0xDF,0xDA,0x57,0xD1,0x5D,0xBB,0x2B,0x2D,0x59,0x45,0x6B,0xA9,0xC6,0xB2,0xA6,0x14,0xAD,0x9B,0x18,0x59,0x17,0x04,0x4E,0x51,0xAA,0x42,0x35,0x40,0x01,0x35,0x8D,0x17,0xE0,0xC4,0x9A,0x02,0xBC,0x54,0x85,0xC0,0x29,0x4A,0x55,0xA8,0x06,0x04,0x60,0x48,0x37,0x07,0x6C,0xAE,0xB6,0xAA,0xA9,0x53,0x54,0xA5,0xCB,0xAA,0xBB,0x4B,0x12,0xB7,0x37,0x6B,0x18,0x31,0x51,0xDC,0x5F,0xAF,0x79,0x34,0x47,0xD1,0x58,0x3D,0xD6,0xD1,0x14,0xD5,0x72,0x71,0xDB,0x47,0x51,0xD4,0xC8,0xD7,0xFF,0x0F};
//const uint8_t spSEVENTY[] PROGMEM = {0x0C,0xF8,0x29,0x45,0x01,0xBF,0x95,0x5A,0x20,0x00,0xBF,0xA5,0x3A,0xE0,0x97,0x32,0x03,0xFC,0x5C,0xB6,0x8A,0x2E,0x42,0xDD,0x6C,0xD3,0x2A,0x3B,0x2F,0xD3,0xB4,0xCD,0xAB,0xCA,0xA6,0xD4,0x2B,0x37,0xB5,0x3A,0x3A,0x8F,0x10,0x5B,0x99,0xFA,0x6C,0xC3,0xCC,0x78,0xD5,0x6A,0x8A,0x0D,0x0B,0xF5,0x47,0x63,0xAC,0x9A,0x33,0xC5,0x63,0xA7,0xB1,0x2A,0xEC,0x50,0xD7,0x9C,0x96,0x66,0xB0,0x92,0xC2,0x95,0x01,0x9E,0x32,0x2D,0xDB,0x0B,0xE3,0xE2,0xAC,0xAD,0xED,0x4D,0x39,0xB9,0xD5,0xC6,0xB5,0x0F,0x13,0xCC,0xE1,0x9B,0xC7,0xD1,0x9D,0x93,0x66,0x7C,0x2E,0xE7,0x70,0x49,0x94,0xBE,0xA5,0x5C,0xC3,0x25,0x72,0xC5,0xA6,0x72,0x0F,0xEF,0x28,0x59,0xAB,0xDD,0x3D,0xAA,0x91,0x58,0xAD,0xFA,0x7F};
//const uint8_t spEIGHTY[] PROGMEM = {0x63,0xEA,0xD2,0x28,0x37,0x67,0xAD,0x7E,0xF9,0x26,0xAC,0x58,0xB3,0x9A,0x91,0x1C,0x34,0xB3,0xC9,0x68,0x46,0x13,0x54,0xEF,0x25,0xA3,0x1E,0x85,0xD1,0x7C,0x96,0x88,0x21,0x52,0xB3,0x71,0x4F,0xA4,0x80,0x25,0x42,0x4B,0x37,0x82,0x82,0xD9,0x2C,0x1E,0xD3,0x4C,0x06,0xEA,0xB5,0x64,0xAC,0xCB,0x3B,0x50,0xE5,0xE2,0xB2,0x2F,0xEB,0x40,0x53,0x8F,0xCB,0x39,0xBD,0x21,0x75,0x2D,0xCE,0x6F,0x7A,0x67,0x12,0x90,0xEC,0xD9,0xFF,0x0F};
//const uint8_t spNINETY[] PROGMEM = {0x6E,0x28,0x1C,0xE3,0x38,0xB4,0xB8,0x3E,0x33,0xAA,0xE5,0xF0,0xB2,0xBA,0x26,0xD2,0x5D,0x6C,0xF5,0xA9,0x9A,0x9C,0xB0,0x90,0x35,0xA7,0xAA,0x76,0xDC,0x52,0xD6,0x9C,0xA2,0x56,0xB7,0x70,0x9D,0xB3,0xB2,0x56,0x4C,0xC2,0x7D,0xCA,0xCA,0x7A,0x11,0xF1,0x88,0x31,0xAD,0xE8,0x91,0x34,0xA2,0xCA,0x88,0xD6,0x08,0xAD,0xF4,0x4C,0x5C,0x80,0xA9,0x52,0x5A,0xB7,0xD2,0xB8,0x30,0xB6,0x19,0xC3,0x48,0x4A,0xE2,0xB1,0x64,0xCD,0x33,0x97,0xA0,0xE9,0x96,0xB1,0xCC,0xD8,0x02,0x6E,0x5F,0xDA,0x3A,0xD3,0x30,0xB8,0x7F,0x29,0xEB,0x4C,0x8D,0x10,0xB1,0xE5,0xFF,0x01};
//const uint8_t spHUNDRED[] PROGMEM = {0x04,0xC8,0x7E,0x5C,0x02,0x0A,0xA8,0x62,0x43,0x03,0xA7,0xA8,0x62,0x43,0x4B,0x97,0xDC,0xF2,0x14,0xC5,0xA7,0x9B,0x7A,0xD3,0x95,0x37,0xC3,0x1E,0x16,0x4A,0x66,0x36,0xF3,0x5A,0x89,0x6E,0xD4,0x30,0x55,0xB5,0x32,0xB7,0x31,0xB5,0xC1,0x69,0x2C,0xE9,0xF7,0xBC,0x96,0x12,0x39,0xD4,0xB5,0xFD,0xDA,0x9B,0x0F,0xD1,0x90,0xEE,0xF5,0xE4,0x17,0x02,0x45,0x28,0x77,0x11,0xD9,0x40,0x9E,0x45,0xDD,0x2B,0x33,0x71,0x7A,0xBA,0x0B,0x13,0x95,0x2D,0xF9,0xF9,0x7F};
//const uint8_t spTHOUSAND[] PROGMEM = {0x08,0x48,0xCC,0x0C,0x01,0x5D,0xA9,0x21,0x60,0x2A,0x33,0x04,0x4C,0x65,0x4A,0x80,0xE9,0x52,0x57,0xDD,0x84,0x7B,0x98,0x36,0x3E,0x75,0x13,0x19,0xE1,0xB4,0xE5,0x54,0x55,0x76,0x86,0xCB,0x9A,0x53,0x15,0xDB,0x99,0xAA,0x6B,0x4E,0x51,0x42,0x67,0x8A,0x2E,0x39,0x59,0x0A,0x9D,0xA1,0xB6,0x64,0x64,0x31,0x4F,0xBA,0xDA,0x93,0x55,0x44,0xB7,0xE9,0x2A,0x9B,0x57,0x95,0xF9,0xBA,0xAB,0x74,0x69,0x75,0x62,0x13,0x2A,0xB2,0xB9,0xF5,0x87,0x8B,0x87,0x8B,0x36,0x07,0x3C,0x82,0x1E,0x81,0x32,0xFD,0xEE,0x1A,0xC6,0x52,0xD7,0x3A,0x49,0xBA,0x99,0x6C,0x39,0x7B,0xA7,0xE9,0x1A,0xB2,0xA5,0xED,0x43,0x55,0x88,0xE1,0x97,0xF2,0x74,0x59,0x21,0xC6,0xAF,0xCB,0x33,0x1C,0x99,0xBB,0xC5,0x2D,0xD7,0xB0,0x24,0xE1,0x1A,0x2F,0x9C,0xCD,0xA0,0x85,0xBB,0x5D,0x77,0x16,0x89,0xD1,0x26,0xC9,0xCC,0x95,0x04,0x65,0xBB,0x25,0x25,0xB7,0x11,0x96,0x25,0xBD,0x3A,0x7D,0x53,0xAB,0xB9,0x69,0x1B,0xF3,0x35,0x67,0xA6,0x2A,0x5B,0xFE,0x1F};
//const uint8_t spMILLION[] PROGMEM = {0x69,0xCE,0x5C,0x74,0xD4,0x9A,0xF6,0xF1,0xF4,0x83,0x9B,0x98,0xF9,0xE2,0x53,0xB4,0x60,0xA6,0x6A,0x6B,0x4E,0xD6,0x43,0x9A,0x8A,0xAC,0x39,0x69,0x37,0xE5,0xA6,0xB2,0xE6,0xA4,0x4D,0xB9,0x25,0xCB,0x9A,0x93,0x4E,0x2D,0x62,0x65,0xE9,0x4E,0x36,0x55,0x3A,0x69,0xA4,0x5D,0x55,0xCF,0x8E,0x6A,0xBA,0x66,0xD5,0xCD,0x2B,0x99,0xE7,0x9A,0xD3,0x37,0xAF,0xEC,0x9E,0x6B,0xCE,0xD4,0x4C,0x8A,0x79,0xAC,0x1A,0x7B,0x93,0xA9,0xE1,0xF1,0x69,0x5C,0x95,0x95,0x7A,0xD8,0xC2,0x76,0x35,0x83,0xE1,0xEE,0x6E,0xD2,0xD5,0x2D,0xBA,0x79,0x64,0x09,0xD7,0x48,0xE8,0x1C,0x9A,0x26,0x5D,0xCD,0xA0,0x47,0x84,0x9B,0xF4,0x34,0x8D,0xAE,0x1E,0x59,0xFE,0x1F};
//const uint8_t spPATH[] PROGMEM = {0x08,0x48,0xCC,0x0C,0x03,0xA9,0xAE,0x51,0x2D,0xAD,0x22,0xAF,0xA6,0x24,0xD3,0x8A,0x9C,0xB2,0xBA,0xEA,0x52,0xA2,0x6D,0xF6,0xEA,0xAA,0x4F,0x89,0xB2,0xDB,0x6B,0x68,0xAE,0xC5,0x4B,0x1F,0xAF,0xA5,0xFA,0x96,0x48,0x9B,0x3D,0xB6,0x12,0x52,0xCB,0x63,0xF6,0x38,0x4B,0x28,0x2D,0xF7,0xD9,0xED,0x29,0x29,0xAC,0xA4,0x96,0xA4,0x37,0x07,0x8F,0xE6,0xAE,0x6C,0xFE,0xDC,0x2C,0x42,0xA2,0x2E,0x02,0x92,0x72,0x65,0x40,0x33,0x69,0x0C,0x18,0x2E,0x8D,0x00,0xC3,0x56,0x50,0x80,0x00,0xD3,0xA5,0x23,0xA0,0xD9,0xB2,0xFF,0x07};
//const uint8_t spNEGATIVE[] PROGMEM = {0x66,0x88,0x82,0x3A,0xDD,0xE3,0x84,0x31,0x4B,0x6C,0x0F,0x4F,0x9C,0x86,0xAA,0xA0,0x3D,0xB5,0xF1,0xEA,0xBA,0x33,0x71,0xB5,0x59,0xAB,0x1A,0x36,0x55,0x43,0x57,0xAF,0x72,0xF8,0x52,0x4D,0xDD,0xB2,0xF2,0x91,0x92,0x34,0x64,0x75,0xA9,0x9B,0x31,0x8A,0x94,0x4A,0xA3,0x1E,0x3E,0x41,0x4A,0x56,0xAF,0xB6,0x59,0xC3,0x08,0x5F,0xBD,0xBA,0x6A,0x9C,0xD3,0x7C,0x95,0x9A,0x9D,0xF2,0x28,0x8F,0x06,0x68,0x19,0x4C,0xD8,0xCC,0x6C,0x39,0x60,0x28,0x93,0x00,0x5C,0x19,0xD6,0xCA,0x6A,0x9D,0x5C,0x6B,0xD1,0x18,0x8A,0x31,0xC9,0xA8,0x45,0x63,0xCB,0x3A,0x38,0x2B,0x17,0x95,0xA7,0x04,0x95,0xD0,0x99,0x5D,0x9E,0xE2,0x55,0x43,0xE7,0x75,0x79,0xB3,0x35,0x0D,0xCF,0x55,0xEE,0xCB,0x5E,0x2D,0x38,0x36,0x89,0x3F,0x07,0x33,0x63,0xE9,0x82,0x80,0x60,0x35,0x08,0x50,0x5D,0x2A,0x02,0xAA,0x4D,0xFB,0x7F};
//const uint8_t spPOINT[] PROGMEM = {0x0A,0xC8,0x2E,0x8C,0x01,0xD1,0x85,0x95,0x34,0x8B,0xAA,0x74,0x56,0xBD,0xCA,0xE8,0xA6,0xCA,0x29,0xCB,0x2A,0x92,0xEE,0xCA,0xA4,0x36,0x2B,0x2F,0xAA,0x3C,0x43,0x9A,0xAC,0xBC,0x78,0xF3,0xD0,0x68,0xD4,0xB2,0x6A,0x45,0x4A,0x2A,0xA6,0xC9,0x93,0xC4,0x29,0x09,0xC7,0x24,0x8D,0xB1,0xD3,0xCD,0x08,0x21,0x70,0x8A,0x52,0x15,0xAA,0x01,0xE0,0x80,0x63,0xC2,0x14,0x70,0x94,0x19,0x01,0xA6,0x32,0xFB,0x7F};
//const uint8_t spAFFIRMATIVE[] PROGMEM = {0xA5,0x4F,0x7A,0xD3,0x3C,0x5A,0x8F,0xAE,0xC8,0xA9,0x70,0xED,0xBD,0xBA,0x2A,0x3B,0xC3,0xD9,0x8F,0x00,0x6C,0x4A,0x21,0x40,0xD3,0xCA,0x08,0x18,0xC2,0x04,0x01,0xC3,0x86,0x11,0x60,0xDA,0x4C,0x05,0x54,0x53,0xDA,0x9C,0x58,0x16,0xED,0xC8,0xEB,0x88,0xE2,0x4C,0xEC,0xC1,0x36,0x23,0xC8,0x65,0xD1,0x17,0xBA,0xB4,0x20,0xE5,0xE4,0x6A,0x8A,0x53,0xA2,0xAC,0x0B,0x73,0x38,0xC9,0xC8,0xB2,0x68,0xCE,0x92,0x24,0x33,0x5B,0x45,0xB1,0xA9,0x11,0xB6,0x6A,0x75,0x4D,0x96,0x98,0xC7,0xAA,0xD6,0x37,0x91,0xEC,0x12,0xAF,0xC8,0xD1,0xB1,0x88,0x97,0x25,0x76,0xC0,0x96,0x22,0x01,0xF8,0x2E,0x2C,0x01,0x53,0x99,0xAD,0xA1,0x7A,0x13,0xF5,0x7A,0xBD,0xE6,0xAE,0x43,0xD4,0x7D,0xCF,0xBA,0xBA,0x0E,0x51,0xF7,0xDD,0xED,0x6A,0xB6,0x94,0xDC,0xF7,0xB4,0xB7,0x5A,0x57,0x09,0xDF,0x9D,0xBE,0x62,0xDC,0xD4,0x75,0xB7,0xFB,0xAA,0x55,0x33,0xE7,0x3E,0xE2,0x2B,0xDC,0x5D,0x35,0xFC,0x98,0xAF,0x79,0x0F,0x0F,0x56,0x6D,0xBE,0xE1,0xA6,0xAA,0x42,0xCE,0xFF,0x03};
//const uint8_t spTIMES[] PROGMEM = {0x06,0x18,0xD2,0xCD,0x01,0x9B,0xAB,0x69,0x60,0x15,0xD5,0x74,0x44,0xF2,0x9A,0x55,0x15,0x3B,0xEE,0x29,0x4B,0x76,0xB5,0xEA,0xE2,0xC7,0xBD,0x64,0xC9,0xAA,0x4B,0x18,0xF3,0x94,0x25,0xAB,0x2B,0x61,0xCC,0x53,0x96,0xAE,0xA9,0xC6,0x56,0x4F,0x59,0x32,0xA6,0x9A,0x5D,0x23,0x7C,0xCE,0x58,0x6B,0x54,0x0B,0xCF,0xC9,0x6D,0xAF,0xDE,0x24,0x2A,0x26,0x95,0xBD,0x49,0x61,0x0F,0x8D,0x97,0x8F,0x74,0x56,0x29,0xEC,0x6E,0x55,0xF3,0x69,0x8E,0x26,0x44,0xCC,0xAD,0xAA,0x39,0x9A,0x14,0x71,0x93,0x6A,0xE6,0xAC,0x86,0xCD,0xD5,0xE2,0xA6,0xEB,0x92,0x10,0x71,0xC9,0x9B,0xAE,0x8B,0xD8,0xCD,0xC3,0x4D,0xBE,0xD3,0xFD,0x7D,0x84,0x09,0x33,0x53,0xC0,0xF7,0x48,0x0A,0xD8,0x90,0xF3,0xFF,0x01};
//const uint8_t spDIVIDED[] PROGMEM = {0x0A,0x28,0x30,0x6C,0x2C,0x43,0xAA,0x8B,0x64,0xA4,0xD3,0x0F,0xE5,0x22,0x26,0x5B,0x4E,0xD7,0x8C,0xAB,0x98,0x6D,0x39,0x7D,0xD3,0x66,0x1A,0xDC,0xA5,0x4D,0x85,0x99,0xA9,0x71,0x96,0x36,0x57,0xA5,0x6A,0x62,0x71,0x4E,0x5B,0x64,0xA5,0x07,0xA5,0x59,0x55,0x72,0x95,0x61,0xBC,0xF9,0xA4,0xD9,0x95,0xA7,0xC9,0xE6,0x11,0x95,0x90,0x56,0x62,0xAB,0x5B,0x5A,0xA2,0x6B,0x4A,0xCE,0x2E,0x59,0x73,0x2E,0xC1,0xB9,0xBA,0xB5,0x09,0x9B,0x45,0x54,0xEB,0x36,0x54,0xAD,0x14,0xBC,0x73,0xDA,0xD4,0x8C,0x51,0x48,0x2F,0x6E,0x4B,0x53,0x4E,0xAE,0xB9,0x9A,0x1D,0x8E,0x64,0xA6,0x45,0xA3,0xFF,0x07};
//const uint8_t spBY[] PROGMEM = {0xEC,0x10,0x32,0x23,0xC5,0x3B,0xAF,0xBD,0x69,0x8D,0x72,0xEA,0x72,0xFA,0x2A,0xAB,0xC3,0x68,0xCB,0xE9,0xB3,0x99,0x0C,0x95,0xCD,0xA7,0x4B,0xB1,0x33,0xD4,0x96,0x9C,0x2E,0xFB,0x8D,0x50,0x5B,0x73,0xBA,0x1C,0xD6,0xC2,0x62,0xC9,0xE9,0x53,0x69,0x4B,0x8B,0x39,0x67,0xCA,0xB9,0x2C,0x35,0xE7,0xAC,0x39,0x97,0xF4,0xD4,0x9C,0xB3,0xF6,0x92,0x3C,0x4B,0x72,0xCE,0xD8,0x4B,0xB4,0x28,0xCD,0x29,0xEB,0xA8,0xD9,0xAD,0x34,0x96,0xB4,0xAB,0x56,0xF5,0xD0,0x9E,0x33,0xAE,0x56,0xD4,0xC2,0x7B,0x4D,0xBB,0x5B,0x34,0x89,0xE8,0x35,0xE5,0xE9,0xDD,0x4D,0xD5,0xD7,0xD4,0xEF,0xFF,0x01};
//const uint8_t spHOURS[] PROGMEM = {0x63,0xC9,0x66,0xA2,0xCC,0x57,0x9F,0xB1,0xF1,0xCE,0x6E,0xEE,0x72,0xBB,0xD3,0x24,0x3B,0x99,0x49,0x79,0x6E,0x35,0x2A,0x1F,0x27,0xBD,0xC8,0x4B,0x69,0x4D,0xDA,0xB0,0x54,0x2E,0x65,0xB0,0x65,0x34,0x43,0xF8,0x96,0x31,0x75,0xA5,0x6E,0xEA,0x53,0xD7,0x7C,0xA4,0x27,0xD7,0x00,0x6F,0xD7,0x1B,0x1F,0xFF,0xB8,0xB7,0x26,0x16,0x49,0xEB,0xE6,0x5F,0xF7,0x56,0x2B,0x62,0xEA,0xEB,0xDC,0xDB,0x83,0xB2,0x9A,0x74,0x73,0xEF,0x76,0x9E,0xC4,0xAA,0xDE,0x7D,0xBF,0x87,0xA6,0xA0,0x52,0x06,0x7C,0x4B,0x24,0x01,0x09,0x70,0xE0,0xFF,0x01};
//const uint8_t spPLUS[] PROGMEM = {0x0A,0xC8,0x2A,0x54,0x01,0xCD,0xA1,0xA6,0x22,0x09,0x1B,0x57,0x57,0x35,0xF2,0x2C,0x7C,0x93,0x35,0xF3,0x2A,0x2B,0xD9,0x51,0xD3,0x2D,0xAB,0xCC,0xFC,0x4B,0xC3,0x37,0xAF,0x32,0xC9,0xB7,0x72,0x5F,0x39,0xCA,0xE8,0xD3,0x9B,0x7B,0x72,0xA9,0xBE,0xE4,0x48,0x32,0x27,0x06,0x78,0xC6,0x55,0x01,0x3F,0xA5,0x28,0xE0,0xB7,0x52,0x0E,0x30,0xE0,0xB7,0xD4,0xFF,0x07};
//const uint8_t spMINUS[] PROGMEM = {0x6A,0xCE,0x8C,0xF4,0xD4,0x93,0x86,0xA5,0x49,0xE2,0x31,0x73,0x1B,0x96,0x26,0x48,0xC6,0x25,0x59,0x9A,0x1B,0x67,0xEC,0xD4,0x34,0x69,0xEA,0x16,0x31,0x33,0x92,0x9C,0xA1,0x88,0xEC,0x08,0xEA,0x72,0xBA,0x2A,0xA6,0x2D,0xB4,0xCB,0xC9,0xBA,0x19,0xB5,0xD4,0x35,0x27,0xEB,0xA9,0x29,0xCC,0x67,0x9F,0xAC,0x65,0xE7,0xE0,0x9E,0x32,0xAA,0x11,0xD1,0xCD,0xC3,0x4D,0x6B,0x7B,0xA0,0x54,0xF5,0x4C,0x67,0x68,0xA1,0xC4,0xC4,0x17,0x8F,0xA5,0x46,0x37,0x97,0x5E,0xD2,0xAE,0x12,0xDD,0x5D,0x7A,0x89,0xBB,0x72,0x72,0xF5,0xD8,0xD9,0x02,0xA8,0xB2,0x58,0x01,0xDF,0x9B,0x09,0xE0,0xB7,0x74,0x01,0xFC,0xE6,0xA9,0x80,0x9F,0x52,0x05,0xF0,0x67,0xFB,0xFF,0x03};
//const uint8_t spEQUALS[] PROGMEM = {0x6D,0x18,0x49,0x91,0xBC,0x17,0xEF,0x6E,0x15,0xA3,0x15,0xA2,0xE5,0x93,0x9D,0xB5,0x7C,0x6C,0x07,0xB6,0x7C,0x1C,0xF2,0x11,0x19,0xAC,0xB2,0x0E,0x02,0x45,0x28,0x77,0x11,0xD9,0x00,0x04,0xF0,0xA3,0x88,0x01,0xBE,0x65,0xB4,0x36,0xC8,0x8D,0x08,0xF4,0x33,0xBB,0x39,0xB4,0xB5,0xE2,0xAE,0x0E,0xF2,0xDB,0xD7,0xBA,0xA7,0x23,0xD3,0xEA,0x0E,0xF0,0x9B,0x8E,0xC8,0xAE,0x92,0x24,0x77,0x38,0x33,0xF8,0x68,0xE6,0xD6,0xF1,0x4C,0xD7,0x25,0x21,0xE2,0x92,0x37,0x5D,0x17,0xB1,0x9B,0x87,0x9B,0x7C,0xB7,0xFB,0xFB,0x08,0x13,0x66,0xA6,0x80,0xEF,0x91,0x14,0xB0,0x21,0xE7,0xFF,0x03};
//const uint8_t spRED[] PROGMEM = {0x64,0x94,0x76,0xD2,0x24,0xD2,0xA8,0x45,0x97,0x94,0x72,0x95,0xAB,0x26,0x51,0x9B,0x32,0xCC,0x89,0x9A,0x64,0x0B,0xCE,0x34,0x67,0x61,0xF4,0x4D,0xA4,0x43,0x9C,0x8F,0x3E,0x0F,0xB6,0xB0,0x70,0xBF,0xBA,0x12,0x53,0xC2,0xAD,0xFB,0xEA,0x9A,0x19,0xD1,0xB4,0x2E,0xAB,0xEF,0x76,0x59,0xC2,0x76,0xAF,0xA1,0xAB,0x61,0x29,0xDF,0xB5,0x86,0xA1,0x86,0x35,0xFC,0xD3,0xEA,0x27,0x1F,0x96,0xB0,0x4F,0xA2,0x33,0xAC,0x7D,0x4C,0x43,0x89,0x5E,0xCA,0x8C,0x11,0x0F,0x5D,0xBA,0xC9,0x44,0x25,0x2C,0x49,0x69,0x9A,0x48,0x16,0xCF,0x47,0xAD,0xAD,0xD6,0x45,0xB5,0x66,0x99,0xA6,0x26,0x67,0x86,0x9C,0xAC,0xDA,0x96,0x92,0x99,0x2C,0xF2,0xFF,0x03};
//const uint8_t spYELLOW[] PROGMEM = {0x69,0xBD,0x56,0x15,0xAC,0x67,0xE5,0xA5,0xCC,0x2B,0x8E,0x82,0xD8,0xD6,0x39,0x9E,0xAE,0x85,0x50,0x37,0x5F,0x7D,0xEB,0x53,0x55,0x1B,0xDE,0xA6,0x6B,0x56,0x5D,0x74,0x47,0x2B,0x77,0x6E,0x75,0x87,0x59,0x95,0xA4,0x76,0x76,0x6B,0xCE,0xA2,0xB3,0x4C,0xF2,0xCF,0xBD,0xED,0xC9,0x54,0xB6,0x52,0x9F,0x7E,0xA5,0xDB,0xC7,0xCA,0x46,0x5D,0x13,0xEF,0xF8,0x84,0x37,0xA8,0xA9,0x0C,0xF2,0xE3,0xBE,0x24,0xC6,0x2B,0x48,0xDF,0xFF,0x03};
//const uint8_t spGREEN[] PROGMEM = {0x64,0xD5,0xA2,0x22,0x23,0xAC,0xB0,0x4D,0xF1,0xCA,0x2C,0x55,0x1A,0xF6,0x6C,0x3F,0x24,0xC4,0x72,0x19,0xB2,0xCA,0xA0,0x62,0x67,0xAD,0x8B,0x49,0xCD,0x53,0xDC,0x8D,0x3A,0x55,0x0E,0x4D,0xB5,0x3F,0xAA,0xD2,0x38,0x5C,0xBD,0xFD,0xAA,0x5A,0x51,0x76,0xB7,0x2D,0xA3,0xEE,0xC5,0xD1,0xD2,0x6F,0xAD,0x66,0x78,0x43,0xDB,0x28,0x35,0xDA,0x61,0x15,0xED,0x22,0x4C,0x6B,0x87,0x15,0x8A,0x73,0xB3,0xAD,0xEB,0x52,0xB9,0x4E,0xAD,0xB6,0xAE,0x29,0xB2,0x09,0x0B,0x5B,0xDA,0xA6,0xB1,0xCA,0xDC,0x69,0x69,0xAB,0xC2,0x0A,0x73,0xD5,0xA5,0x6D,0x9A,0xD5,0x3D,0x12,0x95,0xB6,0x7A,0x15,0xB7,0x8A,0x58,0xDA,0xE2,0x54,0x32,0x42,0x62,0x69,0x8A,0x13,0x35,0xCD,0x48,0xFF,0x0F};
//const uint8_t spWHITE[] PROGMEM = {0xAE,0x32,0xFE,0x93,0xC3,0x94,0xF9,0xBA,0x34,0xDE,0x5F,0x71,0xB3,0xB6,0xD5,0x46,0x77,0xA1,0x4D,0x5D,0xD6,0x50,0xD4,0xBA,0x8C,0x6C,0x5E,0x63,0xD3,0xAD,0x32,0xBA,0xBA,0xCC,0x3D,0x38,0x71,0xF9,0xE2,0xBA,0x84,0x75,0x24,0x65,0xAA,0x5C,0x82,0xC0,0x29,0x4A,0x55,0xA8,0x06,0x00,0x28,0x60,0x48,0x37,0x06,0x6C,0xAE,0x86,0xC0,0x29,0x4A,0x55,0xA8,0xC6,0xFF,0x03};
//const uint8_t spTHEE[] PROGMEM = {0x08,0x20,0xBA,0x0D,0x03,0x6D,0x3E,0x2C,0x55,0x45,0xB3,0x8C,0xBE,0x05,0x65,0xD5,0x78,0x32,0xDA,0xEE,0x85,0x34,0xF2,0xF6,0xE8,0x86,0x33,0xE0,0xCA,0xC7,0xAD,0x9B,0xCE,0x81,0xBB,0x66,0xB7,0x61,0x06,0x07,0xEE,0x9C,0xD5,0xC6,0xA9,0x1D,0x65,0x72,0xD1,0xFF,0x03};
//const uint8_t spTHE[] PROGMEM = {0x08,0x20,0xBA,0x0D,0x03,0x69,0xDF,0xA8,0xCD,0x85,0x3B,0xD7,0x79,0xF4,0x59,0xB7,0xA9,0xFA,0xA2,0xD5,0x27,0xD9,0x6E,0x11,0x8B,0xC6,0x90,0xB4,0x47,0xA8,0x6D,0xFA,0x7F};
//const uint8_t spANSWER[] PROGMEM = {0x63,0x6E,0x3E,0xC5,0xC7,0x17,0xEF,0x79,0x8D,0x3D,0xB4,0x68,0xD9,0x9B,0x35,0x0C,0x3F,0x62,0x69,0xAB,0x57,0xD7,0x7C,0x71,0xB8,0x2F,0x59,0x75,0x0D,0xE6,0x4E,0x5D,0xA7,0x55,0xCD,0x60,0x6A,0xB8,0xEB,0x52,0x55,0x89,0x15,0xE1,0x6E,0x6A,0x95,0xAA,0x09,0xC9,0x22,0x2C,0x8B,0x03,0x7E,0x1D,0x75,0xC0,0x6F,0xA5,0x0E,0xF8,0xAB,0xC5,0x01,0x2F,0xBA,0xAF,0xB1,0x89,0x54,0x4E,0xEF,0xBA,0xC6,0x26,0x5B,0x69,0x3C,0xDB,0x58,0xAB,0x1F,0xA6,0x95,0x6C,0x63,0x2F,0x79,0x88,0x97,0xB3,0x96,0xA3,0xD4,0x46,0x5E,0xEA,0x56,0xCE,0xD2,0x0A,0xAD,0xB9,0xCB,0xFF,0x03};
//const uint8_t spIS[] PROGMEM = {0xA3,0xED,0xC6,0x30,0x3D,0x57,0xAD,0x7E,0xA8,0x42,0xA9,0x5C,0xB5,0xFA,0xA9,0x8A,0xB8,0x62,0xF3,0xEA,0x86,0x48,0xE6,0x8A,0x57,0xAB,0xEB,0x22,0x58,0x23,0x5E,0xAF,0xAE,0xCA,0x64,0xF5,0x7C,0x3C,0xBA,0xCA,0x93,0xD5,0xE3,0x76,0xEB,0x3B,0x4E,0x55,0xB3,0x4D,0x65,0xB8,0x58,0x5D,0xDD,0x72,0x97,0xE9,0x1B,0x55,0x27,0x4D,0xD3,0xE6,0x85,0xD5,0x4D,0x3D,0x6B,0xF9,0x5F,0x50,0x1B,0x26,0x27,0x0A,0xF8,0xAD,0x54,0x01,0xBF,0xBA,0x0B,0xE0,0xA7,0xF4,0xFF,0x07};
//const uint8_t spSTART[] PROGMEM = {0x02,0xF8,0x49,0xCC,0x00,0xBF,0x87,0x3B,0xE0,0xB7,0x60,0x03,0xFC,0x9A,0xAA,0x80,0x3F,0x92,0x11,0x30,0x29,0x9A,0x02,0x86,0x34,0x5F,0x65,0x13,0x69,0xE2,0xDA,0x65,0x35,0x59,0x8F,0x49,0x59,0x97,0xD5,0x65,0x7D,0x29,0xA5,0xDE,0x56,0x97,0xF5,0x85,0x8E,0xE4,0x5D,0x6D,0x0E,0x23,0x39,0xDC,0x79,0xD4,0xA5,0x35,0x75,0x72,0xEF,0x51,0x95,0xE9,0x38,0xE6,0xB9,0x4B,0x5D,0x1A,0x26,0x6B,0x3B,0x46,0xE0,0x14,0xA5,0x2A,0x54,0x03,0x40,0x01,0x43,0xBA,0x31,0x60,0x73,0x35,0x04,0x4E,0x51,0xAA,0x42,0x35,0xFE,0x1F};
//const uint8_t spSTOP[] PROGMEM = {0x08,0xF8,0x91,0x55,0x00,0x3F,0x09,0x1B,0xE0,0x9B,0x48,0x03,0xFC,0xE0,0x6E,0x80,0xEF,0xDC,0x1D,0xF0,0x83,0x1B,0x02,0xA7,0x28,0x55,0xA1,0x1A,0x60,0x80,0xA7,0x4C,0x47,0x5C,0x4D,0xA9,0xA6,0xAE,0xD9,0xE9,0x4A,0xAB,0xAA,0xF0,0xE4,0x2D,0x23,0xCB,0x76,0x2B,0x83,0x37,0xCF,0x6C,0xA4,0xC9,0x5F,0xB8,0xEB,0xEA,0x91,0xC4,0x3C,0x91,0x6A,0x8B,0x53,0x1C,0x4A,0xA4,0xA9,0xD7,0x42,0xE0,0x14,0xA5,0x2A,0x54,0x03,0x80,0x00,0xCE,0x85,0x08,0x20,0x27,0xF7,0xFF,0x07};
//const uint8_t spREADY[] PROGMEM = {0x6A,0xB4,0xD9,0x25,0x4A,0xE5,0xDB,0xD9,0x8D,0xB1,0xB2,0x45,0x9A,0xF6,0xD8,0x9F,0xAE,0x26,0xD7,0x30,0xED,0x72,0xDA,0x9E,0xCD,0x9C,0x6D,0xC9,0x6D,0x76,0xED,0xFA,0xE1,0x93,0x8D,0xAD,0x51,0x1F,0xC7,0xD8,0x13,0x8B,0x5A,0x3F,0x99,0x4B,0x39,0x7A,0x13,0xE2,0xE8,0x3B,0xF5,0xCA,0x77,0x7E,0xC2,0xDB,0x2B,0x8A,0xC7,0xD6,0xFA,0x7F,};
//const uint8_t spTEMPERATURE[] PROGMEM = {0x0A,0x38,0xDE,0x32,0x00,0x2F,0xBB,0x37,0xBF,0x59,0x57,0x76,0x6F,0xB8,0xB2,0x16,0xCA,0xC4,0x75,0xCB,0x4A,0xAB,0x4A,0xF3,0xF6,0xCD,0x2B,0x2D,0x66,0x94,0xD7,0xBA,0xB4,0x34,0x79,0x93,0x52,0x97,0x16,0xB2,0x28,0x5B,0x4D,0x43,0x36,0x10,0x20,0xAB,0xB2,0x52,0xC4,0x26,0x9A,0x26,0x49,0x47,0x9B,0x1B,0xA5,0xA6,0x74,0x5D,0x43,0xF1,0x65,0x14,0x91,0xAD,0xED,0xB5,0x99,0xB1,0x69,0x1A,0x20,0xC0,0x0A,0x84,0x0E,0xD8,0xD3,0x23,0x01,0xA3,0x4C,0x1A,0xA0,0xF5,0xC9,0xD6,0x95,0xE0,0x24,0x1D,0xD9,0x5A,0x9B,0x9C,0x8B,0xAE,0x79,0x2B,0x43,0xAC,0xA6,0xDE,0x9C,0x35,0x9D,0xB1,0xB3,0x47,0x52,0xD7,0x74,0xC6,0x2E,0x52,0xA1,0x5E,0xC2,0x1D,0x3B,0xEB,0xB8,0x65,0x0D,0x5F,0xAA,0x26,0xB6,0xE2,0x35,0x7C,0xA9,0x2A,0xFB,0x6A,0x16,0xF7,0xE7,0x9E,0x4C,0xEB,0xD9,0xFE,0x1F};
//const uint8_t spTIME[] PROGMEM = {0x0E,0x18,0xA2,0x34,0x00,0x4B,0x0E,0x2B,0x20,0x5B,0xB7,0x51,0xA4,0x94,0x5A,0xAE,0xA5,0x56,0x99,0x4B,0x6B,0xBA,0xCC,0x5D,0x75,0x8E,0x63,0xD6,0x32,0x67,0x35,0x39,0x8F,0x5A,0xEB,0x9C,0x35,0x16,0xBF,0x26,0x2D,0x4B,0xD6,0x58,0xED,0x39,0x8D,0xAE,0x59,0x47,0xD3,0x1B,0xDC,0xD2,0x66,0x9C,0x5D,0xB6,0xC9,0xE8,0xEA,0x76,0x37,0x9F,0x62,0x6D,0x8B,0xCB,0xD3,0x42,0x88,0x8C,0x2D,0x2A,0x6F,0x8B,0x6A,0x1E,0x36,0xA5,0x7C,0xD5,0xB1,0xBB,0x78,0xE2,0xF2,0x56,0x4B,0x6E,0xEA,0x4E,0xCA,0x5B,0x3D,0x87,0xA8,0x39,0x09,0x6F,0x75,0xE2,0xA6,0x6A,0xF7,0xFF,0x01};
//const uint8_t spA_M[] PROGMEM = {0x6B,0xE8,0xC9,0x44,0x22,0xD7,0xEC,0xE1,0xB4,0x23,0x3B,0xA9,0xE5,0x9A,0x53,0xF5,0x64,0x64,0x59,0x6B,0x4F,0x35,0xB2,0x91,0x45,0x3D,0x39,0xF5,0xC8,0x86,0x1A,0xF9,0xE4,0xF4,0xA3,0x19,0xA9,0xE7,0x92,0xD3,0x8D,0x22,0x64,0xD9,0x4B,0xC6,0x3A,0x8A,0xA1,0x74,0x3D,0x69,0xFB,0xAC,0x89,0xE4,0xF9,0xA4,0x0C,0x3D,0x89,0x6A,0xE5,0xE2,0x33,0xF6,0x2A,0xE2,0xD1,0xAB,0x4F,0xD7,0xAB,0xB3,0x46,0xAE,0x3E,0x75,0x6F,0x66,0x6A,0xB9,0xE6,0xD4,0xAD,0x9A,0xBA,0xE6,0x92,0xD3,0xB6,0xA2,0xEE,0x5A,0x73,0x4E,0x57,0x93,0xBB,0x9B,0x2D,0x39,0x43,0x89,0xE9,0x6E,0xB6,0x64,0x4D,0xC5,0x5B,0x04,0xB9,0xDC,0xB1,0x34,0x2D,0x16,0x64,0x76,0xDB,0x5E,0x95,0x78,0xA0,0xC9,0x2D,0x7B,0xD3,0xE2,0x41,0x26,0xB7,0x9C,0xCD,0x70,0x1A,0x85,0x92,0x74,0x56,0xA5,0x91,0x68,0x4A,0xD2,0xD5,0x0C,0xA5,0x89,0x29,0x49,0x57,0x33,0x1C,0xC9,0x2A,0x27,0xDD,0xCD,0x71,0xAA,0xAA,0xE2,0xF4,0x34,0xCB,0x19,0x6C,0x72,0xD2,0x57,0x95,0x44,0x90,0xC9,0xFD,0x7F};
//const uint8_t spP_M[] PROGMEM = {0x0A,0xC8,0xDC,0x95,0x01,0xC6,0x90,0xB5,0xB4,0x19,0x41,0xCD,0x58,0xD2,0xD2,0xE6,0x51,0xA3,0x7B,0xF6,0xCA,0x46,0x25,0x92,0xAC,0x25,0xAB,0x98,0xCD,0x91,0x2C,0x57,0xAF,0x6A,0x56,0x43,0x8A,0xDA,0x3C,0xBA,0x59,0x0D,0x29,0x6B,0x55,0x9B,0x66,0x35,0xA4,0xAC,0x47,0x6D,0x99,0xD5,0x90,0xAA,0x1E,0xB7,0x75,0x66,0x43,0xEA,0xBA,0x35,0x86,0x9E,0x44,0xB5,0x72,0xF1,0x19,0x7B,0x15,0xF1,0xE8,0xD5,0xA7,0xEB,0xD5,0x59,0x23,0x57,0x9F,0xBA,0x37,0x33,0xB5,0x5C,0x73,0xEA,0x56,0x4D,0x5D,0x73,0xC9,0x69,0x5B,0x51,0x77,0xAD,0x39,0xA7,0xAB,0xC9,0xDD,0xCD,0x96,0x9C,0xA1,0xC4,0x74,0x37,0x5B,0xB2,0xA6,0xE2,0x2D,0x82,0x5C,0xEE,0x58,0x9A,0x16,0x0B,0x32,0xBB,0x6D,0xAF,0x4A,0x3C,0xD0,0xE4,0x96,0xBD,0x69,0xF1,0x20,0x93,0x5B,0xCE,0x66,0x38,0x8D,0x42,0x49,0x3A,0xAB,0xD2,0x48,0x34,0x25,0xE9,0x6A,0x86,0xD2,0xC4,0x94,0xA4,0xAB,0x19,0x8E,0x64,0x95,0x93,0xEE,0xE6,0x38,0x55,0x55,0x71,0xBA,0x9B,0xE5,0x0C,0x36,0x39,0xFF,0x0F};
//const uint8_t spOCLOCK[] PROGMEM = {0xAD,0x8C,0xBE,0x22,0xC5,0x56,0x8D,0xBE,0xC8,0xB1,0x74,0xE9,0x33,0xEA,0xCA,0xD7,0x38,0xB9,0x8F,0xA8,0x63,0x4A,0x14,0xEB,0xCE,0xA0,0x80,0xEC,0xA6,0x14,0xD0,0x94,0x87,0x00,0x06,0x8B,0x6A,0x59,0xE2,0x97,0x6E,0xEC,0x79,0x65,0x49,0x5F,0xA9,0xC9,0xEA,0x55,0x15,0x79,0xAD,0xCE,0x5B,0x56,0x9F,0xD5,0x15,0x87,0xAF,0x59,0x73,0x91,0x57,0x9C,0xBE,0x65,0xAC,0xD9,0x5C,0x4A,0xD8,0xE6,0x71,0xE4,0xB0,0xEE,0x61,0xAB,0xCA,0x93,0x4A,0x7A,0x5A,0x2E,0x42,0xE0,0x14,0xA5,0x2A,0x54,0x03,0x40,0x00,0x75,0x0E,0x71,0x00,0x01,0xD1,0x11,0xFF,0x3F};
//const uint8_t spDEGREES[] PROGMEM = {0x0A,0x28,0x30,0x6C,0x74,0x53,0x25,0xB3,0x67,0xAC,0x95,0x0D,0x63,0x24,0x11,0x8B,0x57,0x31,0xBC,0xA1,0x54,0xAC,0x19,0xF5,0x70,0x06,0x3C,0xB6,0xC6,0x0D,0x91,0xA9,0xCE,0x52,0x28,0x36,0x32,0xDD,0x95,0x69,0xB2,0xF8,0xD8,0xBA,0x6C,0xDA,0x31,0x34,0x69,0xA9,0x53,0x30,0xE3,0x92,0x74,0xA9,0x2A,0x55,0x4D,0x92,0xD3,0x97,0xAA,0x46,0x13,0x2A,0x4D,0xBF,0xEA,0x1E,0x82,0xB1,0x74,0xEB,0xEA,0x86,0x09,0x82,0xF6,0x35,0x6B,0x18,0xCE,0x11,0x27,0x66,0x8D,0x69,0x38,0x47,0x9C,0x5C,0x3C,0x96,0xE9,0x1C,0xA1,0x73,0xF5,0xD8,0xA7,0x33,0xA4,0xCE,0xC5,0xE5,0x18,0x41,0x91,0x3B,0x1F,0xB7,0x73,0x04,0x25,0xAA,0x5C,0x53,0xDE,0x19,0x83,0x30,0x6C,0x6B,0x7A,0x87,0x77,0xE4,0x8C,0x3D,0xE5,0x1D,0xD1,0x50,0xCC,0xB7,0xA6,0x6F,0x38,0x27,0x76,0xDD,0x12,0xBE,0xA1,0x83,0x38,0x78,0xAF,0xF9,0x9A,0x0A,0x14,0xB7,0xCF,0xE9,0xBF,0x24,0x44,0x5C,0xF2,0xA6,0xFF,0x22,0x76,0xF3,0x70,0x93,0x7F,0x05,0x7C,0x8F,0xA4,0x01,0x01,0x6C,0xC8,0xC9,0x80,0x1F,0x3C,0xFE,0x1F};
//const uint8_t spCELCIUS[] PROGMEM = {0x08,0x68,0x48,0x94,0x00,0x37,0x30,0x0A,0xE0,0x0F,0x17,0x05,0xFC,0xEE,0x64,0x80,0xDF,0x8B,0x0D,0xF0,0x6F,0x89,0x01,0xDE,0x54,0x4D,0xCD,0xB7,0x5E,0xCA,0xE2,0x65,0x65,0x4D,0x87,0x99,0xD9,0x9A,0x95,0x57,0xD9,0x6E,0x61,0x6B,0x56,0x96,0xD5,0x84,0xA7,0xAC,0x5E,0x69,0x08,0x1B,0x6E,0xB6,0x79,0xC4,0xC1,0x6F,0x96,0x48,0xA7,0x96,0x44,0x7D,0x9E,0xC2,0x9D,0x5A,0xD6,0x51,0x45,0x18,0x7B,0x31,0xC0,0x63,0xC4,0x0E,0xF8,0xD5,0x24,0x00,0x7F,0xB8,0x07,0xE0,0x77,0xD5,0xD6,0x2D,0x11,0x4E,0x6A,0x59,0x5B,0x57,0xAD,0x70,0x44,0x3C,0x1E,0x43,0xD7,0x46,0xD6,0xF6,0x68,0x2C,0x55,0x2A,0xC7,0xC4,0xAA,0xB6,0x36,0x65,0x1C,0xE3,0x8F,0xC6,0xD6,0x55,0x88,0x96,0x2F,0x6E,0x47,0xB1,0x21,0x9E,0xF9,0x78,0x3C,0x55,0x96,0x46,0xF8,0xAA,0xF2,0x57,0x35,0xAC,0x91,0x8B,0xD2,0x5F,0x79,0x4B,0x4A,0xAE,0x66,0xC0,0x67,0xA4,0x0A,0xF8,0xC9,0xC4,0x00,0xAF,0x38,0x2B,0xE0,0x35,0x55,0x0E,0x30,0xE0,0xB5,0x92,0xFF,0x07};
//const uint8_t spFARENHEIT[] PROGMEM = {0x04,0xE8,0xDE,0x1D,0x01,0x4B,0xBB,0x12,0x60,0x7A,0x77,0x01,0x0C,0xED,0x36,0x8A,0xEA,0xDD,0xDC,0x64,0xCD,0x2A,0x6A,0x34,0x4F,0xAD,0x25,0xBB,0x5C,0x55,0xCB,0xE6,0x29,0xBD,0x64,0xD7,0xAB,0xA9,0xC5,0x3C,0xA4,0xEB,0x88,0x56,0x35,0xB6,0x74,0x57,0x97,0xBA,0xD8,0xD8,0xDC,0xDD,0x59,0xE9,0x73,0xE3,0x94,0x30,0x6F,0x6B,0x2C,0xC1,0x42,0xC3,0xBA,0xAE,0xBA,0x85,0x14,0xB7,0x9C,0x5D,0xCE,0x6E,0x49,0x53,0x3D,0x6E,0x3A,0x9B,0x46,0x29,0xF3,0x78,0x0C,0x28,0xAE,0x53,0x03,0x1A,0x58,0x5D,0xD5,0x93,0x19,0xB2,0x66,0xF5,0xC5,0x4C,0x64,0xC8,0x9A,0xB1,0xB6,0x58,0x96,0x66,0x4F,0xC6,0xD5,0x5C,0x8B,0xA7,0xBE,0x2E,0x57,0xB3,0xC9,0x59,0xF1,0x66,0xDC,0x3D,0xB7,0xB8,0xD9,0x9A,0x72,0xB7,0x22,0xA6,0xDE,0xB5,0xD3,0xD7,0x1A,0xB9,0xF4,0xCE,0x46,0xE0,0x14,0xA5,0x2A,0x54,0x03,0x00,0x14,0x30,0x85,0xBA,0x00,0x9E,0xAF,0xF8,0x7F};
//const uint8_t spERROR[] PROGMEM = {0x6D,0x6C,0x6E,0x89,0x5B,0x36,0x8F,0xA9,0x9B,0x11,0x5A,0xE9,0x33,0xA7,0x31,0x17,0xB7,0x4A,0x47,0xFD,0xC6,0x92,0x9A,0x8B,0x2F,0x65,0x4B,0x6B,0x1C,0xE4,0xD5,0xD8,0x2D,0xAF,0x65,0x8D,0x83,0xAD,0x9A,0xB2,0x95,0x23,0x76,0x93,0x58,0xCA,0xD7,0xCE,0xEC,0x57,0xF8,0xD8,0x5B,0x3A,0x8B,0x3D,0xC5,0xE7,0x7C,0xE9,0xCD,0xBD,0x30,0x86,0xDA,0x86,0x2F,0x97,0x82,0x38,0xEC,0x13,0xFE,0xE4,0x07,0xED,0x35,0x4B,0xF8,0x73,0x4E,0xEC,0xD2,0x3C,0xEE,0x2F,0xCB,0xB9,0x9D,0x3B,0xFF,0x3F};
const uint8_t spMILES[] PROGMEM = {0xA5,0xA8,0x86,0xDA,0xD9,0xDC,0x8E,0xB2,0x1A,0xCD,0x22,0x53,0x32,0xEA,0x64,0xB3,0x92,0x43,0xC9,0xAA,0x63,0x69,0x77,0xD3,0xB9,0xA3,0x49,0xEE,0x42,0x5A,0x67,0xAF,0x36,0x9B,0x73,0x19,0x5D,0xBC,0xBA,0xA2,0xD7,0x65,0x64,0xF1,0xEA,0x8B,0x59,0xD3,0x96,0xC7,0x6B,0x28,0xA1,0xC5,0x4B,0x1F,0xB7,0xB1,0xEA,0x55,0x19,0x79,0xD5,0x96,0xE2,0x46,0xAC,0x65,0x51,0x59,0xB3,0x1F,0xB6,0xB1,0x47,0x6D,0x4D,0x6E,0x3C,0x5D,0x16,0xA5,0x2D,0xBA,0x89,0x52,0xD9,0xE8,0xB6,0xE0,0x36,0x4A,0x74,0x57,0xD8,0x83,0xE9,0x2A,0xE3,0xCE,0xE6,0x88,0x26,0x2B,0x59,0x5A,0x89,0x33,0x98,0xAC,0x44,0x4B,0x1D,0xAE,0x4B,0x42,0xC4,0x25,0x6F,0xB8,0x2F,0x62,0x37,0x0F,0x37,0xF1,0x56,0xC0,0xF7,0x48,0x02,0xD8,0x90,0xF3,0xFF,0x01};
const uint8_t spPER[] PROGMEM = {0x0A,0x28,0xC2,0x44,0x01,0xD1,0x88,0x2A,0x20,0x67,0xB7,0xD2,0x85,0xAA,0xDC,0x4D,0x6B,0x4E,0x9B,0xC3,0x30,0x1D,0x65,0x5B,0x6D,0xF1,0xC3,0x74,0x9C,0x6D,0x8C,0x25,0x0C,0xF1,0x71,0xB6,0xB1,0xE6,0x5A,0xA8,0x2B,0x59,0xCA,0x99,0xAA,0x63,0x9C,0x64,0x49,0x57,0x69,0x8D,0xB2,0xE2,0x25,0xDD,0xA5,0x25,0xEA,0x8A,0x97,0xF0,0xE4,0x21,0x54,0xA3,0x59,0xFE,0x1F};
const uint8_t spHOUR[] PROGMEM = {0xA5,0x8E,0x2D,0x23,0xA2,0xEA,0x9C,0xA3,0x98,0xC9,0x70,0x5B,0x72,0xC6,0xA2,0x36,0x23,0x74,0xCD,0x19,0x8A,0xDA,0x0C,0xD7,0x2D,0xA7,0xCB,0x7A,0x33,0x5D,0xB6,0x9C,0x36,0xDA,0xAD,0x72,0xEE,0x32,0x5A,0x9F,0xBA,0xD2,0xA9,0xF3,0xE8,0x5C,0x9C,0x8C,0x60,0x2F,0x63,0x70,0x79,0x3C,0x82,0xBD,0xCC,0x61,0x2C,0x31,0xA7,0x54,0x73,0x96,0xB1,0xA6,0xE6,0x1C,0x43,0x59,0xDA,0x9E,0x9A,0x53,0x2C,0x77,0x29,0x47,0xEE,0x46,0x31,0xDC,0x25,0x9D,0xB9,0x3A,0xFA,0x4A,0x96,0x74,0x15,0xDF,0x82,0x17,0xDA,0xC2,0x95,0xA7,0x60,0xAE,0x66,0xF9,0x7F};
//const uint8_t spMINUTES[] PROGMEM = {0x66,0x55,0xD2,0xA2,0xD3,0xEB,0xBA,0xD5,0x0B,0xB5,0x2A,0x4B,0x66,0x16,0xA7,0x38,0x2A,0x22,0x4D,0x9B,0xB2,0x32,0x35,0xF3,0x36,0xAB,0xAE,0x8E,0x42,0xB3,0xA6,0x9C,0xAA,0x58,0x76,0xCF,0x2E,0x7D,0x8A,0xEA,0xC5,0x2C,0x7A,0xCA,0xCA,0x9A,0xE3,0x54,0x8E,0x26,0xA3,0xE8,0x16,0xD3,0x4B,0x93,0xAC,0xBA,0x5B,0x36,0x17,0x5D,0x73,0xFA,0xE6,0x52,0xD4,0x62,0xF1,0x59,0xBA,0x49,0x31,0x8B,0xD5,0x63,0xAF,0xDE,0xC5,0xAC,0xDF,0x20,0x70,0x8A,0x52,0x15,0xAA,0x01,0x00,0xC0,0x80,0xE9,0x24,0x04,0xB0,0xDC,0xAE,0x01,0x9E,0x71,0x55,0xC0,0x4F,0x29,0x0A,0xF8,0xAD,0x54,0x03,0x0C,0xF8,0x2D,0x95,0x01,0xBF,0x94,0xFD,0x3F};
const uint8_t spGUSTING_TO[] PROGMEM = {0x0A,0x28,0xB9,0x65,0xEC,0x5D,0x8F,0xAA,0xB8,0xEB,0x55,0x16,0x1B,0x62,0x69,0x6B,0x56,0x55,0xD4,0x98,0xA7,0xAF,0x5E,0x75,0xB1,0x27,0xEE,0xB1,0xB9,0x34,0x9D,0x87,0x64,0x52,0x42,0x07,0xFC,0xC0,0xA2,0x80,0x7F,0x53,0x05,0xF0,0x47,0x09,0x02,0x6E,0x10,0x71,0xC0,0x61,0x6E,0xA3,0xAD,0xDA,0xC5,0xB5,0x56,0x8F,0xB6,0x1B,0x23,0xCD,0x58,0xDD,0xFA,0xEE,0x15,0x63,0xAD,0x52,0xEA,0x9B,0x45,0x6F,0x53,0xF9,0xA9,0x6F,0x9A,0xAC,0xDD,0xEC,0xA5,0xBE,0x6A,0x8C,0x49,0x97,0x67,0x86,0xA2,0xA0,0xCA,0x59,0x0B,0x59,0x0A,0x51,0x73,0xAF,0x34,0x01,0xD8,0x22,0x2C,0x00,0xC7,0x45,0x95,0xA1,0x1A,0x63,0xF1,0x58,0xD5,0xC6,0x6A,0x44,0x35,0x74,0x4D,0x9B,0x8A,0x30,0xB3,0x94,0x2D,0x65,0xCA,0xD4,0x3D,0x8B,0xD6,0xA4,0x29,0xE3,0x48,0x2B,0xDC,0x9C,0xA6,0x8C,0x22,0xA2,0x61,0x73,0x98,0x12,0xAA,0x92,0xA4,0xCD,0x69,0x4E,0xA4,0x43,0x9D,0xB6,0xA4,0x39,0xF2,0x36,0x57,0x5E,0x1D,0x96,0xC8,0x47,0x43,0x75,0x73,0x58,0x32,0x2D,0x2D,0xD5,0x5E,0xFF,0x0F};
//const uint8_t spGUST[] PROGMEM = {0x0A,0x28,0x30,0x6C,0x74,0xDD,0x8C,0x93,0x71,0x9B,0x55,0x55,0x5B,0x26,0x6A,0x6B,0x56,0x95,0x63,0xBA,0x59,0x2D,0x5E,0x55,0x0E,0xED,0x6E,0xB9,0x7A,0x54,0x29,0x8E,0x85,0xD6,0xA2,0xD1,0xA4,0xD8,0x16,0x56,0x8B,0x19,0x90,0x8D,0xB8,0x02,0x9E,0x32,0xD3,0x80,0x02,0xBE,0xB3,0xD0,0x80,0x01,0xBE,0x37,0x55,0xC0,0xCF,0x6E,0x04,0xF8,0x33,0x15,0x81,0x53,0x94,0xAA,0x50,0x0D,0x30,0xC0,0x90,0x6E,0x02,0xD8,0x5C,0x0D,0x81,0x53,0x94,0xAA,0x50,0x8D,0xFF,0x07};
//const uint8_t spEAST[] PROGMEM = {0xAD,0x9A,0xD1,0x10,0xAB,0xE7,0x8C,0x62,0x25,0x43,0x8C,0x5E,0x32,0xF2,0x99,0x04,0xA9,0x66,0xC9,0xC8,0x67,0x62,0xE4,0xEE,0x25,0xA3,0x98,0x59,0x90,0xB2,0xE7,0x8C,0x72,0x46,0x01,0xA9,0x9E,0x3D,0xFA,0x99,0x18,0xB5,0x7A,0x76,0x9B,0x87,0x25,0xF4,0xE9,0x59,0x65,0xED,0x8A,0xB0,0xAB,0x56,0x0A,0xE0,0x0F,0x13,0x03,0xFC,0xE8,0x66,0x80,0x9F,0xD3,0x0C,0xF0,0x67,0x99,0x05,0x0C,0xF0,0x93,0xBB,0x02,0x7E,0xA9,0x44,0xE0,0x14,0xA5,0x2A,0x54,0x03,0x0C,0x30,0xA4,0x9B,0x02,0x36,0x57,0x43,0xE0,0x14,0xA5,0x2A,0x54,0xE3,0xFF,0x01};
//const uint8_t spWEST[] PROGMEM = {0x6C,0x65,0x7E,0xD3,0xCD,0x1C,0x8B,0x83,0xBA,0x4B,0x37,0xB3,0xC3,0x0E,0x56,0x36,0xD9,0xDD,0x61,0xD8,0x75,0x9C,0x34,0xA1,0xAE,0x6B,0x49,0x72,0xDC,0x83,0xD6,0xAE,0xAE,0xDA,0xD6,0x70,0x7E,0xB3,0xBA,0xEA,0x5C,0xCB,0xE3,0xCE,0x1A,0x9A,0x6B,0xF1,0xB0,0xC7,0x6B,0x6E,0xBA,0x39,0xD2,0x5E,0xB5,0xB3,0xDA,0xE4,0xF4,0x9C,0xED,0xDE,0x96,0xC3,0x83,0x22,0xB1,0x01,0x9E,0x71,0x55,0xC0,0x4F,0x29,0x06,0xF8,0xAD,0xD4,0x02,0x01,0xF8,0x2D,0xD5,0x01,0xBF,0x94,0x19,0xE0,0xE7,0x32,0x04,0x4E,0x51,0xAA,0x42,0x35,0x00,0x14,0x30,0xA4,0x1B,0x03,0x36,0x57,0xFB,0x7F};
//const uint8_t spSOUTH[] PROGMEM = {0x0C,0x78,0xC6,0x95,0x01,0x3F,0xA5,0x28,0xE0,0xB7,0x52,0x0B,0x04,0xE0,0xB7,0x54,0x07,0xFC,0x52,0x66,0x80,0x9F,0xCB,0x4E,0x56,0xE5,0x24,0xA7,0xB6,0x3D,0x45,0x15,0x53,0x5A,0xBA,0xF5,0x54,0xD9,0x6D,0x58,0xEA,0xEA,0x55,0xA7,0xB8,0x6E,0xE5,0xAB,0xC7,0x98,0xEC,0x85,0x94,0xAD,0x6E,0x4B,0xB4,0x97,0x52,0xB6,0x2A,0x6C,0x31,0x6C,0x98,0xDB,0x46,0xF3,0xF8,0xB2,0x69,0xE6,0x1B,0xCD,0xE3,0x6A,0xBB,0xA9,0x2F,0x12,0xAF,0x4B,0xE3,0xC1,0xDE,0x89,0x01,0x43,0x54,0x72,0x80,0x03,0x14,0xA0,0xC0,0xFF,0x03};
//const uint8_t spNORTH[] PROGMEM = {0x6E,0x4A,0x9C,0x62,0x4A,0xEB,0x84,0xA5,0x08,0xD2,0x2E,0x69,0x92,0x96,0xAA,0x48,0x33,0xA5,0x69,0x9A,0x8B,0x24,0x8F,0x90,0xA6,0x63,0xAA,0xD6,0x42,0x9C,0xD7,0xAC,0x3E,0x1B,0xCB,0x52,0x5A,0xB2,0xDA,0xE8,0x3A,0xC3,0x68,0xCD,0xAA,0x42,0xDE,0xF0,0xE0,0x2C,0xAB,0x08,0x6D,0x35,0x83,0xB3,0x8C,0x32,0xD4,0xE1,0x2A,0xEA,0x33,0x86,0xD8,0x9B,0x3A,0x69,0xCF,0x58,0x73,0x6E,0xEA,0xA2,0xDC,0xE3,0xCC,0xD5,0x78,0x52,0x73,0xB5,0x33,0x37,0x93,0x48,0xD9,0x14,0xAE,0x52,0x5C,0x35,0x74,0x12,0x03,0x86,0xA8,0xE4,0x00,0x07,0x08,0x30,0xD4,0x04,0x01,0x1A,0x1F,0xFB,0x7F};
const uint8_t spNORTHEAST[] PROGMEM = {0x66,0x4E,0x92,0xBD,0x43,0x67,0xBB,0x35,0x4A,0xAA,0xF4,0x68,0x1C,0xD6,0xAC,0xB0,0x32,0x2C,0x71,0x59,0xB2,0x62,0x0B,0xB7,0xA6,0x63,0x4C,0x3A,0x2C,0x43,0x96,0xAE,0x21,0xE9,0x8A,0x0A,0x4E,0xBA,0x9A,0xE8,0xD6,0x33,0x25,0xDE,0xA8,0x62,0x6C,0xED,0xE2,0x78,0x2B,0x4D,0x61,0xB8,0x06,0xBB,0x8C,0x38,0x35,0x95,0x31,0x59,0xD9,0x92,0x32,0x85,0x8B,0xB5,0x75,0x2A,0xB6,0x5C,0x51,0x65,0x25,0x0C,0x18,0x6A,0x82,0x01,0xDD,0xAC,0xA6,0x78,0xEB,0x35,0x53,0x4C,0xBD,0xE2,0x61,0x1C,0xCD,0x6C,0xC9,0x48,0x86,0x31,0xE4,0x8E,0x27,0x2D,0x9D,0xCE,0x81,0x3A,0x1F,0xB7,0x6C,0xA6,0x00,0xAC,0x5A,0xDC,0xFA,0xE9,0x1D,0xA8,0x6B,0x76,0x99,0x67,0x51,0xE0,0xA8,0xD9,0x61,0x9D,0xD9,0x80,0xAA,0x1E,0x9B,0x6D,0x54,0x26,0xF6,0x5A,0xA2,0xF6,0xA1,0x8D,0xD4,0xBC,0xB5,0x01,0x9E,0x71,0x55,0xC0,0x4F,0x29,0x06,0xF8,0xAD,0xD4,0x02,0x01,0xF8,0x2D,0xD5,0x01,0xBF,0x94,0x19,0xE0,0xE7,0x32,0x04,0x4E,0x51,0xAA,0x42,0x35,0x00,0x40,0x01,0x4F,0xA9,0x31,0x60,0x73,0xB5,0xFF,0x07};
//const uint8_t spNORTHWEST[] PROGMEM = {0x2A,0x4D,0x9C,0x7D,0x4A,0xE2,0x84,0x35,0x49,0xCA,0x34,0xAB,0xDD,0xD6,0x6A,0xC5,0xD4,0xA5,0xC9,0x18,0x8B,0x4E,0x57,0xD7,0xAE,0x6B,0x48,0x7A,0xD2,0x92,0xBB,0xAE,0x2E,0x9A,0x4D,0x2B,0xF1,0xB6,0xEA,0x64,0xCE,0xB5,0xC5,0xEF,0x2A,0x53,0x5C,0xAE,0xD4,0x5C,0xAB,0xCA,0x35,0xA9,0x42,0x5B,0x29,0x60,0x88,0x4A,0x05,0x0C,0x35,0x21,0x80,0x6E,0x56,0x5D,0xEB,0xD4,0xB9,0x26,0xA7,0x76,0x9D,0x51,0x5F,0x1C,0x9C,0xA7,0x75,0x51,0x5E,0x71,0x52,0xDF,0x55,0x67,0x75,0x2E,0x45,0x9B,0x57,0x5D,0xEC,0x88,0x95,0xBE,0x5E,0x5D,0xB1,0xA1,0x6D,0x71,0x7B,0xAD,0xD5,0x87,0x96,0xE6,0xED,0x75,0x54,0x1B,0x5A,0x16,0xAB,0xDB,0x53,0x43,0x58,0x68,0x2C,0x16,0x7F,0xF2,0x61,0xD1,0xBB,0x49,0x01,0x99,0x37,0x3A,0xE0,0xBB,0x0E,0x07,0x7C,0xB7,0xE5,0x80,0xD7,0x3B,0x1D,0xF0,0xCA,0x24,0x02,0xA7,0x28,0x55,0xA1,0x1A,0x00,0x0A,0x18,0xD2,0x8D,0x01,0x9B,0xAB,0x21,0x70,0x8A,0x52,0x15,0xAA,0xF1,0xFF};
//const uint8_t spSOUTHEAST[] PROGMEM = {0x0C,0x78,0xC6,0x95,0x01,0x3F,0xA5,0x28,0xE0,0xB7,0x52,0x0B,0x04,0xE0,0xB7,0x54,0x07,0xFC,0x52,0x66,0x80,0x9F,0xCB,0x56,0x5D,0xF5,0x84,0xA5,0xAE,0x59,0x75,0x36,0x13,0x11,0xB6,0x7A,0x95,0xC9,0x6E,0x78,0xFA,0xEA,0x95,0xC5,0xDC,0x1E,0x16,0x93,0x5B,0x1A,0x6A,0xBB,0x73,0xCC,0x4E,0x59,0x74,0x15,0x4D,0x3C,0x3B,0x54,0x5B,0x96,0x99,0x8A,0x2D,0x03,0x0C,0x51,0xE9,0x80,0x6E,0x56,0x2D,0xD0,0xA2,0xEA,0x98,0xCD,0x73,0x4E,0xCB,0x87,0x17,0x94,0xCC,0xC7,0xA5,0x18,0x4E,0x81,0xA7,0x6E,0x97,0x6A,0x5A,0x01,0xD9,0x9E,0x5D,0xDA,0xE5,0x0D,0xA8,0x7B,0x56,0x19,0x67,0x12,0xA4,0xAA,0xD9,0x65,0x1B,0x89,0x50,0xBA,0x67,0xA7,0x63,0x38,0x22,0x9D,0x5A,0x9C,0x8E,0x21,0x8D,0xD9,0xBB,0xB3,0x01,0x9E,0x71,0x55,0xC0,0x4F,0x29,0x06,0xF8,0xAD,0xD4,0x02,0x01,0xF8,0x2D,0xD5,0x01,0xBF,0x94,0x19,0xE0,0xE7,0x32,0x04,0x4E,0x51,0xAA,0x42,0x35,0x00,0xC0,0x01,0x53,0xA8,0x0B,0xE0,0xF9,0x8A,0xFF,0x07};
//const uint8_t spSOUTHWEST[] PROGMEM = {0x0C,0xB8,0x5E,0x92,0x01,0xCF,0xB8,0x32,0xE0,0xA7,0x14,0x05,0xFC,0x56,0x6A,0x81,0x00,0xFC,0x96,0xEA,0x80,0x5F,0xCA,0x0C,0xF0,0x73,0xD9,0x6A,0x8B,0x19,0xF7,0xD4,0xCF,0xAB,0xCD,0x66,0x23,0x42,0x37,0xAF,0x3A,0xAB,0x4B,0x4B,0xEB,0xBC,0xAA,0x18,0x37,0xDC,0x6C,0x55,0x2B,0x42,0xDA,0x08,0x91,0x59,0xA9,0x88,0x7A,0xAC,0x89,0x5A,0xAA,0x61,0x50,0x37,0x53,0x95,0xA2,0x80,0x21,0x2A,0x05,0xD0,0xCD,0x6A,0x68,0xAB,0x0E,0x53,0x33,0xC7,0xAE,0x0B,0x6A,0x8A,0x9D,0x52,0x97,0x2E,0xE8,0x6B,0x32,0xEE,0xBA,0xAA,0xC2,0xBA,0xB4,0xA8,0xEB,0xAA,0xAB,0x1C,0x97,0xE6,0x2F,0xAB,0x69,0xAA,0x34,0x5A,0x5E,0xAF,0xA9,0x9A,0x92,0x4C,0x7F,0xB4,0xF6,0x6A,0x4B,0x2A,0xF2,0x56,0x3B,0x4B,0x48,0x49,0xAF,0xD9,0xE9,0x29,0x3E,0xA4,0xF8,0x16,0x1B,0xE0,0x19,0x57,0x05,0xFC,0x94,0x62,0x80,0xDF,0x4A,0x2D,0x10,0x80,0xDF,0x52,0x1D,0xF0,0x4B,0x99,0x01,0x7E,0x2E,0x43,0xE0,0x14,0xA5,0x2A,0x54,0x03,0x00,0x1C,0x30,0x85,0xBA,0x00,0x9E,0xAF,0xF8,0x7F};
//const uint8_t spHAIL[] PROGMEM = {0x08,0x28,0x5A,0x1C,0x01,0x45,0x7B,0x94,0x62,0x04,0x21,0xB3,0x8C,0xB3,0xF2,0xAA,0x59,0x3B,0xDB,0xF2,0x4A,0x9B,0x27,0x89,0x9A,0x3A,0x2B,0xED,0x41,0xD8,0xBA,0x97,0xAC,0x74,0x44,0x25,0xCD,0x5E,0xBD,0xB2,0x11,0x95,0xB4,0x6A,0xCD,0xCA,0x47,0x74,0x92,0x8C,0x3B,0x3B,0x5F,0xD5,0x30,0x4E,0x3A,0xF1,0x78,0xF5,0x5D,0x05,0x6B,0xDB,0xEB,0xB1,0x36,0x5E,0xE6,0x25,0x9F,0xC7,0x9E,0x74,0x47,0xBA,0x6C,0x2E,0x47,0xF0,0x1B,0xEA,0xB6,0xB9,0x9C,0x41,0x6F,0x96,0x72,0x9F,0x72,0x25,0x3E,0x55,0x46,0xDE,0xD2,0x1D,0xE5,0x55,0x08,0x67,0xCB,0xF7,0xFF,0x03};
//const uint8_t spTORNADO[] PROGMEM = {0x01,0xD8,0x5C,0xCD,0x03,0x25,0xCF,0x6E,0x54,0xC5,0x9D,0xB4,0x22,0x4C,0x17,0x2B,0x69,0xB5,0xAA,0x94,0x5B,0x6D,0x28,0xEB,0x6A,0x72,0x6C,0x93,0xE1,0x6C,0xAB,0xAD,0xC5,0xDC,0xD4,0x93,0xAD,0xBE,0x59,0x91,0x32,0x89,0xB7,0xBA,0x1E,0x59,0x4B,0xD5,0xDE,0xEA,0x86,0x2B,0xE1,0xD0,0xD5,0xAB,0x9D,0xAE,0x95,0x52,0x37,0xAF,0x76,0xF9,0x51,0x4C,0x5D,0xB3,0x9A,0xE5,0x8A,0xB1,0x6C,0xF5,0x6A,0xA6,0x2F,0x41,0x97,0x2E,0xA1,0xCD,0x5C,0x24,0xD3,0xDA,0xAC,0x69,0xC8,0x60,0x4D,0xFD,0xBC,0xE6,0x22,0x4A,0xAC,0x7C,0xF3,0x58,0x63,0x0C,0xCE,0x88,0xD6,0x6D,0x8E,0x29,0x25,0xD2,0x37,0x96,0x2D,0x74,0xB3,0xB0,0x58,0x55,0xF6,0x58,0x4B,0x2C,0x6C,0x57,0x39,0x42,0x2B,0xF6,0x88,0x3D,0xE9,0xF4,0x65,0x38,0x25,0xF7,0x86,0xCB,0xB5,0x21,0xCB,0xEA,0xAB,0xEE,0xE0,0xAB,0x93,0xCC,0xE9,0xFF,0x03};
const uint8_t spWIND[] PROGMEM = {0x22,0xA7,0x75,0xCD,0xC5,0x6D,0x9B,0x85,0xF5,0x74,0x4D,0xB7,0xEC,0x66,0x5E,0x2A,0x34,0x3C,0x56,0x99,0x4D,0xED,0x60,0x95,0x46,0x6B,0x48,0xAA,0xDD,0x0C,0x57,0xAF,0xBA,0x59,0x17,0x0B,0x5A,0xB3,0xCA,0x9E,0x9C,0x4D,0xF5,0xC9,0x2A,0x9A,0x77,0x71,0x8F,0xD9,0xAB,0x68,0x21,0xC4,0xDC,0x67,0xAF,0xB6,0x1A,0xB7,0x70,0x9F,0x3C,0xFA,0xA6,0xD9,0x52,0xCC,0x69,0x5B,0x9A,0x60,0x69,0x35,0x7B,0x65,0x6D,0x92,0x65,0x54,0xEC,0xA7,0xBD,0x69,0xD4,0x31,0xB3,0x17,0xCE,0xAA,0x30,0x92,0x32,0x89,0xB9,0xB2,0xC4,0x09,0x8B,0x54,0xEC,0x16,0x22,0x73,0x3D,0x13,0x93,0xDB,0x91,0xF4,0xC9,0x48,0x45,0x6F,0x06,0x14,0x18,0xD6,0xCE,0x1E,0x53,0x44,0x6C,0xCB,0xFF,0x03};
//const uint8_t spWEATHER[] PROGMEM = {0x6A,0xA5,0xFE,0xB2,0x48,0x95,0xE8,0x55,0xAF,0x7C,0x65,0x1B,0x73,0x37,0xE1,0xAA,0x58,0x6C,0xBC,0xAC,0xAB,0xBA,0x1D,0xB3,0xAA,0x7C,0x4E,0x26,0xAB,0xDB,0x10,0xD4,0xB8,0x07,0x6D,0x5D,0x4D,0x71,0x29,0xE1,0xFC,0x78,0xD5,0x35,0xBA,0xA6,0xF8,0x92,0x55,0x94,0x10,0x12,0x52,0x4B,0x5A,0x9E,0x83,0xBA,0xF2,0xC6,0x71,0x45,0xB6,0x2E,0x8E,0xDD,0x28,0xF4,0x59,0x87,0x24,0x55,0xC3,0x34,0xC4,0x60,0x92,0x36,0x95,0xDB,0x50,0x9C,0x9A,0x4B,0x3E,0x6E,0x73,0x31,0xC5,0x5A,0xB6,0xB9,0xAD,0xD5,0x35,0xC9,0x48,0x9F,0x72,0xD5,0xB0,0xC8,0xCB,0x79,0xD2,0x55,0x6A,0x41,0x2C,0xED,0x4D,0x7F,0x99,0x06,0x9D,0xBA,0x35,0xFD,0x65,0x27,0x8C,0x59,0xD6,0xFF,0x07};
//const uint8_t spSHOWERS[] PROGMEM = {0x0C,0x38,0x71,0x54,0x01,0xBB,0x6D,0x69,0xC0,0x02,0x1E,0xF0,0x40,0x04,0x34,0xB0,0x8A,0x1A,0x4A,0x2D,0x75,0xCB,0x2A,0x72,0x68,0xF3,0xD6,0xCD,0x2B,0x4F,0x61,0xDD,0x5B,0x57,0x8F,0x2C,0xD6,0x71,0x4F,0x59,0x5D,0x72,0x3F,0x3B,0x32,0xB8,0x69,0x2A,0xED,0x89,0x28,0x93,0xB4,0xA1,0xF7,0x6D,0xA4,0x0A,0x7A,0xA7,0x31,0x9A,0x57,0x3E,0xF4,0x93,0xD6,0xEC,0x8E,0xE4,0x30,0x4F,0x3A,0x73,0x1E,0xF0,0xC5,0x3E,0xE1,0x28,0xAD,0xC1,0x86,0xF3,0xB8,0xA3,0x4C,0x83,0x4A,0xE9,0xEB,0xCE,0x1C,0x02,0x6D,0x22,0xAB,0x39,0x4B,0x08,0xD4,0xCE,0xFC,0xE6,0xCA,0xDE,0x30,0xAA,0xFA,0xB9,0xEB,0x92,0x10,0x71,0xC9,0x1B,0xEE,0x8B,0xD8,0xCD,0xC3,0x4D,0xBC,0xDD,0xF3,0x7D,0x84,0x09,0x33,0x53,0xC0,0xF7,0x48,0x02,0xD8,0x90,0xF3,0xFF,0x01};
//const uint8_t spSLEET[] PROGMEM = {0x06,0x78,0xC6,0x55,0x01,0x3F,0xA5,0x18,0xE0,0xB7,0x52,0x0B,0x04,0xE0,0xB7,0x54,0x07,0xFC,0x52,0x66,0x80,0x9F,0xCB,0xC6,0xD0,0x70,0x44,0xA8,0x78,0x5D,0x45,0xC7,0xDE,0x2E,0x94,0x77,0x15,0x93,0x68,0x99,0x72,0xD6,0x95,0x35,0x6D,0xAA,0x66,0x8F,0x57,0x3A,0xA2,0xB0,0x98,0x3F,0x59,0xC5,0x08,0x4C,0x56,0xBD,0xB8,0x35,0xD3,0x29,0x70,0xF7,0xE3,0x34,0xCE,0xA8,0xC0,0x5D,0x8F,0xDD,0x32,0x3C,0xA1,0x6D,0x5F,0x42,0xE0,0x14,0xA5,0x2A,0x54,0x03,0x00,0x14,0x30,0xA4,0x1B,0x03,0x36,0x57,0x43,0xE0,0x14,0xA5,0x2A,0x54,0xE3,0xFF,0x01};
//const uint8_t spSMOKE[] PROGMEM = {0x08,0xE8,0x58,0x94,0x01,0xDF,0x30,0x33,0xE0,0x7B,0x65,0x03,0xFC,0x12,0xEA,0x80,0x5F,0x8B,0x1D,0xF0,0x7B,0xA8,0x03,0x5E,0x53,0x56,0x40,0xA1,0x1C,0xAE,0xF1,0x2C,0xA2,0x52,0xDD,0xA4,0x3A,0x2B,0xCC,0x71,0x89,0x37,0xEA,0x2C,0x33,0x5D,0xA1,0xCD,0x2A,0x92,0xEC,0x56,0xE7,0x36,0x23,0x0F,0x7E,0x4B,0x4C,0xD6,0x8C,0x3C,0xDA,0x69,0x35,0x5E,0xDD,0xEA,0x68,0xB7,0x55,0xA9,0x6F,0x19,0x82,0xBD,0x14,0x95,0xBE,0x61,0xF1,0x76,0xC3,0x85,0xFB,0x88,0x25,0xE8,0x29,0x63,0x73,0x87,0xC0,0x29,0x4A,0x55,0xA8,0x06,0x00,0x08,0xA0,0x94,0x62,0x0C,0x20,0xA0,0xA4,0x20,0x04,0x94,0xE2,0xF6,0xFF};
//const uint8_t spSTORM[] PROGMEM = {0x0C,0xF8,0x59,0x51,0x01,0x3F,0x07,0x19,0xE0,0xB7,0x91,0x00,0xFC,0x3E,0x9C,0x80,0x5F,0xC3,0x0C,0xF0,0x57,0x0B,0x02,0xA7,0x28,0x55,0xA1,0x1A,0xC0,0x80,0xCD,0xD5,0x5A,0x5C,0x79,0x16,0x07,0x67,0x1B,0x45,0x92,0x5D,0x96,0xD8,0x77,0xE4,0x3E,0x6E,0x99,0x63,0x97,0x96,0xF9,0xB8,0x69,0xC6,0x4D,0x5A,0x16,0xDA,0x64,0x88,0x26,0x69,0x65,0x28,0x13,0xE6,0xA1,0xB6,0xB5,0xB1,0xB4,0x5B,0xA4,0xBA,0xD6,0xA5,0x9C,0x1A,0x2D,0x79,0xDA,0x90,0x63,0x8B,0x0D,0xE7,0x29,0x53,0x4E,0x2D,0x36,0x94,0xB7,0xCC,0xD9,0x15,0x75,0xB1,0xDD,0xB2,0x16,0xDD,0x98,0x45,0xE6,0xCA,0x56,0x45,0x8B,0xB9,0x4A,0x2D,0xFB,0x20,0xED,0xEA,0x64,0xB5,0x9C,0x4D,0x96,0xA4,0x70,0xD4,0x72,0x75,0x15,0x92,0x2A,0x56,0xCB,0xDD,0x94,0x6B,0x89,0x45,0xFD,0x7F};
//const uint8_t spSNOW[] PROGMEM = {0x04,0x78,0xC6,0x95,0x01,0x3F,0xA5,0x28,0xE0,0xB7,0x52,0x0D,0x18,0xE0,0xB7,0x54,0x05,0xFC,0x52,0x56,0xAA,0xAA,0x30,0x2B,0xC5,0x6E,0xAD,0x56,0xD1,0x95,0xB9,0x26,0xAD,0x59,0x79,0x95,0x91,0x52,0xB2,0x76,0x65,0x55,0x54,0x73,0xC9,0xD6,0x95,0x15,0x51,0x2D,0xC9,0x6B,0x56,0x99,0xD4,0xB4,0xA4,0x6C,0x19,0x43,0xB4,0x5B,0x12,0xB2,0xA5,0x0C,0x3E,0x6D,0xAA,0xDB,0x9E,0xB2,0xFA,0xB0,0x11,0x26,0x5B,0xD2,0xEE,0xD2,0x44,0x88,0xAE,0x4E,0xB7,0x2B,0x1D,0xC9,0xBA,0xC5,0xFD,0xAE,0x4C,0xAA,0x58,0x37,0xF7,0xBB,0x3A,0x6E,0xA2,0x59,0xDC,0xA3,0xD3,0x86,0x8B,0xF4,0x75,0x8F,0x8F,0x95,0x41,0xDA,0xC7,0xDD,0xD1,0x55,0x05,0x86,0xEB,0xFF,0x07};
//const uint8_t spSAND[] PROGMEM = {0x0C,0xF8,0x55,0x45,0x01,0xBF,0x1A,0x1B,0xE0,0x47,0x23,0x07,0xFC,0x64,0xE2,0x80,0x5F,0x5C,0x02,0xF0,0x63,0xBA,0x01,0x7E,0x4A,0x5C,0x49,0x53,0xA9,0x6A,0xFE,0x78,0xD5,0xCD,0x96,0x68,0xC6,0xE3,0x55,0x15,0xE7,0x9A,0x55,0x93,0x57,0x55,0xBD,0x69,0x67,0xD5,0x5A,0x65,0xCB,0x62,0xE5,0x53,0x7B,0x95,0x35,0xA8,0x75,0x56,0xA5,0x55,0x55,0x67,0xDA,0x99,0x95,0x56,0x5F,0xAD,0x4B,0x67,0x4C,0x5A,0x43,0xD3,0xC5,0x99,0x31,0x71,0xAD,0x8D,0xB5,0x64,0xF9,0xCC,0xB6,0x35,0x3A,0x1A,0x61,0x8B,0xD2,0xD1,0x34,0x6B,0xAB,0xDB,0x09,0x67,0x93,0x22,0xAB,0x66,0x2F,0x9C,0x55,0x61,0x24,0x65,0x12,0x73,0x65,0x89,0x13,0x16,0xA9,0xD8,0x2D,0x44,0xE6,0x7A,0x26,0x26,0xB7,0x23,0xE9,0x93,0x91,0x4A,0x00,0x05,0x86,0xA5,0xBD,0x3B,0x23,0x17,0xDB,0xF2,0xFF};
//const uint8_t spPELLETS[] PROGMEM = {0x06,0xA8,0xDC,0x55,0x01,0xC5,0x2A,0xB7,0xAC,0x58,0x53,0xB3,0x48,0x31,0xF2,0x12,0xCD,0xCD,0xAB,0xF6,0xCA,0x8B,0x2B,0x37,0xB7,0xC7,0xAB,0xC8,0x72,0xD3,0x52,0x17,0x8F,0xA2,0xE0,0x1D,0x0E,0x6D,0x3D,0xAA,0x82,0x77,0x28,0x3C,0xC9,0xA8,0xB3,0xB8,0xB0,0xB0,0x55,0x63,0x6A,0x7C,0x5D,0xC3,0x37,0x8D,0xB5,0xC8,0x91,0x88,0x7A,0x55,0x8E,0x62,0x8B,0x32,0x66,0x16,0x02,0xA7,0x28,0x55,0xA1,0x1A,0x00,0x04,0x18,0x54,0x8C,0x01,0x3F,0x28,0x1A,0xE0,0x1B,0x57,0x05,0xFC,0x94,0xC2,0x80,0xDF,0x4A,0x39,0xF0,0xFF};
//const uint8_t spRAIN[] PROGMEM = {0x62,0xE1,0x7E,0x5D,0x2D,0xEC,0x88,0x49,0xB4,0x64,0x4F,0x77,0x6A,0x26,0xDB,0xD8,0xA3,0x54,0x6B,0xEB,0x72,0x97,0xD4,0xE2,0xAC,0xAB,0x29,0x49,0xDD,0xD2,0xD6,0xAC,0xBA,0x3A,0xE7,0x6C,0x7F,0xB4,0xAA,0x16,0x8C,0x62,0x63,0xD2,0xA8,0x86,0x0D,0xD2,0x8B,0x4A,0xA3,0x19,0x3E,0x48,0x2F,0x2B,0xCD,0xA6,0xF5,0xC3,0x39,0xD9,0x45,0xA8,0x32,0x0D,0x6B,0xE4,0x67,0x81,0xEB,0x54,0xD6,0xAA,0x45,0x6B,0x2D,0x70,0x59,0x9B,0xC6,0x2A,0x57,0x25,0x69,0x2F,0x8A,0x32,0x2D,0x14,0xA5,0xAB,0x69,0xF6,0x52,0xB7,0x93,0xAF,0xF4,0x34,0xAD,0x96,0xE6,0x89,0xC2,0xD3,0x44,0xAA,0xB5,0x37,0xFC,0x7F};
//const uint8_t spICE[] PROGMEM = {0xA9,0x89,0xE1,0x3C,0x3C,0x66,0x8F,0x31,0xEB,0x0B,0x2B,0x5F,0xBD,0xA6,0x62,0xC6,0xA2,0xEC,0xF1,0x6A,0xAB,0x6B,0xAE,0xF6,0x47,0xAB,0x6A,0x31,0xB0,0x3C,0x17,0x8F,0xAE,0x67,0x43,0x8B,0x5A,0x5C,0xC6,0x9E,0x18,0x2D,0x6B,0x76,0x58,0x5A,0x40,0xF1,0x98,0xC6,0x6A,0x6F,0xD2,0x20,0xBD,0x1B,0x1B,0xE0,0x49,0x13,0x03,0x7C,0x13,0x66,0x80,0x1F,0x3D,0x0C,0xF0,0x53,0x84,0x02,0x7E,0x77,0x57,0xC0,0x0F,0x66,0x0A,0xF8,0x29,0x44,0x01,0xBF,0x16,0x0B,0xE0,0x8F,0x34,0x01,0x7C,0x6B,0xF9,0xFF};
//const uint8_t spHEAT[] PROGMEM = {0x04,0x18,0xB6,0x82,0x00,0xD3,0x57,0x50,0x40,0x00,0xD3,0xA5,0x8F,0x62,0xC6,0x20,0x48,0x7F,0x3A,0xCA,0x19,0x83,0x20,0xF3,0x49,0x6F,0x46,0x3F,0x83,0x02,0x57,0xCF,0x6E,0xEB,0x74,0x06,0xDC,0x7D,0x2B,0x5D,0xD3,0x28,0xC8,0xF4,0x6C,0x75,0x75,0x29,0x64,0x1D,0x2B,0x11,0x38,0x45,0xA9,0x0A,0xD5,0x00,0x00,0x03,0x4C,0xA1,0xEE,0x80,0xE7,0x2B,0x04,0x70,0x63,0xE6,0xFF,0x03};
//const uint8_t spFOG[] PROGMEM = {0x08,0xE8,0x26,0x15,0x01,0x5D,0xBB,0x22,0x60,0xEA,0x34,0x06,0x0C,0x9B,0xCE,0x80,0x2C,0xD3,0x46,0x96,0x64,0xAF,0x06,0x65,0x1B,0x45,0xB4,0x33,0x1A,0xD4,0x6D,0x94,0xD1,0xEC,0x68,0x70,0xD7,0x51,0x45,0xB3,0xAD,0xC1,0x7D,0x47,0x13,0xED,0xB6,0x86,0xF4,0x19,0x43,0xB4,0xDB,0x1E,0xDC,0x67,0x8C,0xD1,0x6E,0xA9,0x6B,0x9F,0xB6,0x45,0xBF,0xA9,0x61,0x7D,0xDA,0x99,0xF4,0x96,0x86,0xE7,0x6D,0x4F,0x32,0xA7,0x16,0xE2,0xC7,0x9D,0x71,0x26,0x99,0xB3,0x67,0x77,0x0A,0x35,0x1E,0x91,0xB1,0xC2,0x19,0x48,0x7A,0x45,0x26,0x12,0x40,0xC9,0x2D,0x69,0xEF,0x7A,0x54,0xC5,0x5D,0xFF,0x3F};
//const uint8_t spHEAVY[] PROGMEM = {0x08,0xC8,0x46,0x13,0x03,0xAB,0xAE,0x5E,0xCC,0xB3,0x6B,0xAF,0xB6,0x99,0x10,0xAB,0xBC,0xB3,0xEA,0xE6,0x52,0x34,0xE2,0xF6,0xAA,0x8A,0x73,0x55,0xD7,0x35,0xA6,0xF1,0xDA,0x55,0xC3,0x56,0x85,0x76,0xC8,0x10,0x63,0xB3,0x33,0xB2,0x16,0x54,0xC4,0x6D,0xF1,0xCA,0x7A,0x50,0x96,0xC8,0x25,0xA3,0xE8,0x41,0xD1,0x32,0x1F,0xCF,0xA2,0x56,0xFF,0x0F};
//const uint8_t spLAND[] PROGMEM = {0x6E,0x5A,0x88,0xA6,0x58,0xD6,0xA6,0x6D,0x00,0x5B,0x23,0x6F,0x56,0xD6,0x0E,0x6C,0x83,0xAD,0x5D,0x59,0x06,0xB0,0x75,0xB2,0xF6,0x6B,0xC8,0x7A,0xCA,0x54,0x56,0xAF,0xA1,0xB3,0x2E,0x4B,0xDD,0xBC,0x86,0x21,0x3B,0x34,0x6D,0xCD,0xEA,0x86,0x6A,0xD5,0xB2,0xD5,0xAB,0x19,0xA6,0xC5,0xD2,0x56,0xAF,0xB2,0x9B,0xE2,0xAC,0x58,0xB4,0x8A,0xE6,0x5C,0xDA,0x6B,0xF6,0xCA,0x4B,0x34,0x4F,0x9B,0xDA,0x2B,0xCD,0x3E,0xAC,0x65,0xA3,0xB4,0xA4,0x19,0x2A,0x37,0x57,0xD5,0xE2,0xAE,0x29,0x52,0x53,0x73,0x49,0x9A,0xC2,0x6A,0x73,0xB5,0x08,0x28,0x30,0xAC,0xE5,0x55,0x84,0x84,0xE6,0xA2,0xFF,0x07};
//const uint8_t spTHIN[] PROGMEM = {0x08,0x48,0xCC,0x0C,0x01,0x5D,0xA9,0x21,0x60,0x2A,0x33,0x04,0x4C,0x65,0x4A,0x80,0xE9,0x52,0x57,0xDD,0x43,0x88,0xA8,0x3D,0x5E,0x55,0x0F,0xC1,0xEA,0xFE,0x68,0x95,0xCD,0x99,0x78,0xE4,0xA4,0x55,0x14,0x6B,0x1A,0x56,0x93,0x57,0xD1,0x2D,0x79,0xB8,0x29,0x5D,0x45,0x37,0x14,0x1E,0xEE,0x64,0x55,0x4D,0x85,0x86,0xFA,0xEC,0xFF,0x07};
//const uint8_t spOF[] PROGMEM = {0x65,0x4A,0xEA,0x3A,0x5C,0xB2,0xCE,0x6E,0x57,0xA7,0x48,0xE6,0xD2,0x5D,0xBB,0xEC,0x62,0x17,0xBB,0xDE,0x7D,0x9F,0xDA,0x5C,0x5C,0x7A,0xAA,0xB5,0x6E,0xCB,0xD0,0x0E,0xAD,0x6E,0xAF,0xEE,0xF9,0x88,0x67,0xBC,0xDC,0x3D,0xAC,0x60,0xB8,0x45,0xF3,0xB7,0xBF,0xC3,0xDD,0xA2,0xBB,0xAB,0xCD,0x89,0x8F,0x7F,0xFE,0x1F};
//const uint8_t spAERIAL[] PROGMEM = {0xE2,0x8A,0xCC,0xD5,0xDC,0xDD,0x9A,0xAB,0x09,0x13,0x55,0x53,0xE2,0x8E,0xA6,0x4C,0xC4,0xC4,0xC9,0xDA,0x6A,0x72,0x13,0x97,0x36,0xAB,0xAF,0x3E,0x8C,0x4B,0xB7,0xAC,0x36,0x87,0x90,0x48,0xDF,0xB2,0xEA,0x94,0x4D,0xAB,0x6C,0xD3,0xAA,0x63,0x13,0x6F,0xCB,0xDC,0xAD,0x4A,0x9D,0x3A,0x3C,0x7C,0xB7,0x2A,0x0F,0x6A,0x2E,0xF7,0x3D,0xDA,0xD2,0xD9,0x43,0x23,0xF7,0x1A,0x6A,0x08,0xF4,0xB6,0xDD,0x63,0x6C,0x21,0xC1,0xCA,0x37,0xAF,0xB9,0x9B,0x22,0x49,0xDD,0xB2,0xB6,0x6E,0x46,0x29,0x74,0xF3,0x38,0x9A,0x2A,0x97,0x90,0x2E,0xEE,0x08,0xBA,0x4C,0xCC,0xD2,0x20,0x00,0xBC,0x32,0x02,0x58,0x9D,0x9A,0xCE,0x60,0xA6,0x4D,0xA4,0x5B,0xBA,0x83,0x9D,0x56,0x93,0xAC,0xE1,0xF6,0x71,0x8B,0xD5,0xBB,0xA6,0xD7,0xA7,0x29,0x63,0xC9,0x12,0x7E,0x1F,0x36,0x4D,0xB8,0xAD,0xFB,0xBD,0xB9,0x66,0xD1,0x74,0xEE,0x0F,0x7A,0x5A,0x9C,0x3B,0xFF,0x3F};
//const uint8_t spOBSCURED[] PROGMEM = {0xA3,0xAF,0xDA,0xB4,0x42,0x57,0x8F,0x21,0xB9,0x34,0x35,0x6B,0x2D,0x06,0xEE,0x46,0x2D,0x32,0x16,0x1B,0x99,0x6B,0xB7,0xA8,0x98,0x69,0x1E,0xDA,0xD4,0x45,0xD4,0x3A,0xE0,0xA6,0x08,0x07,0xDC,0x30,0x15,0x80,0x57,0xBC,0x10,0xB0,0xB8,0x38,0x02,0xBA,0x37,0x51,0x40,0x14,0xA2,0xA3,0xE9,0xA9,0x18,0x4A,0xBA,0x8D,0xB6,0xD9,0x60,0x5C,0xE9,0xDA,0xBA,0xAC,0x4A,0x68,0x25,0x5F,0x19,0xA3,0x2F,0x96,0xE3,0x3C,0x69,0x0A,0xD5,0x38,0x9B,0xF3,0x84,0x3D,0x34,0x95,0x09,0xE9,0x13,0xF6,0x58,0x85,0xD7,0xB4,0x4F,0xBA,0x72,0x0F,0xCA,0xE4,0xDC,0xE1,0xCD,0x31,0x49,0x87,0xFB,0x86,0x3F,0x67,0xA1,0x2C,0xE9,0x13,0xFE,0xDA,0x95,0x35,0x25,0x8B,0xFA,0x4B,0x66,0x51,0xF7,0x76,0xEC,0xCF,0x5C,0x38,0xBA,0xD4,0xB8,0x7F,0x04,0x51,0x31,0xB7,0x1D,0xFE,0x26,0x93,0x35,0x7D,0x4B,0x78,0x6B,0x32,0xD6,0x8C,0x4D,0x08,0xC8,0x1E,0xED,0xFF,0x01};
//const uint8_t spBROKEN[] PROGMEM = {0x0C,0x08,0x51,0xBC,0x74,0xB1,0x49,0x72,0x8A,0xF7,0xD5,0xC5,0xAC,0xA9,0xAE,0xE9,0x56,0x9B,0xCC,0x06,0x85,0xF5,0x5D,0x6D,0x52,0x97,0x1C,0xB2,0xBB,0x75,0x51,0x4E,0x58,0xE0,0x66,0x60,0x40,0x99,0x4E,0x04,0xE0,0x3E,0x7C,0xED,0xC5,0x9B,0x7A,0xF8,0xE2,0xB5,0x77,0x19,0x26,0xA5,0x5B,0xCA,0xD5,0xA4,0x9B,0xA5,0xAC,0x4E,0x7F,0x37,0x6C,0xED,0x62,0x3D,0xFD,0xCD,0xB0,0x85,0x99,0xDD,0xF4,0x0D,0xCF,0x12,0xE6,0x51,0xCB,0x57,0x8D,0x84,0x69,0xC4,0x71,0x5F,0xAD,0x66,0x4C,0x99,0xE8,0xFF,0x01};
//const uint8_t spALOFT[] PROGMEM = {0xAD,0xCE,0xE2,0xC2,0x5C,0x57,0xF7,0xB6,0xB5,0xDE,0x74,0x05,0x6B,0x93,0xD2,0x7A,0xD3,0x1D,0xE0,0x4D,0x6A,0xBB,0xDA,0xCC,0xA6,0x4B,0x25,0xC9,0x68,0xA2,0xBE,0x72,0xD1,0x35,0xA3,0x09,0xEE,0xD2,0x45,0xBB,0xAC,0x36,0xC4,0x0F,0x89,0x6C,0xBD,0xFA,0x90,0x2E,0xCC,0xBC,0xF3,0x9A,0x83,0xBF,0x30,0xF3,0xCE,0xE3,0x88,0xF1,0x5C,0x2D,0x36,0xB7,0x3B,0xDA,0x2B,0x33,0xED,0x9C,0x9E,0x50,0xC7,0x4D,0xF3,0x75,0x7A,0x52,0xEC,0x74,0xD1,0x49,0x02,0xA8,0x26,0x55,0x00,0x5D,0x87,0x32,0xA0,0x9B,0x52,0x0E,0x20,0x70,0x8A,0x52,0x15,0xAA,0x01,0xA0,0x80,0x21,0xDD,0x18,0xB0,0xB9,0x1A,0x02,0xA7,0x28,0x55,0xA1,0x1A,0xFF,0x0F};
//const uint8_t spCEILING[] PROGMEM = {0x0C,0xF8,0x29,0x45,0x01,0xBF,0x95,0x5A,0x20,0x00,0xBF,0xA5,0x3A,0xE0,0x97,0xB2,0x95,0x0E,0xED,0x8A,0x61,0x6B,0x46,0x39,0x7C,0x30,0x86,0x7E,0x19,0xC5,0x88,0x4E,0x94,0xFA,0x65,0x15,0xDD,0x29,0x6B,0xEB,0xEA,0x56,0x54,0xA6,0x16,0xC5,0xAB,0x47,0x31,0xB0,0xA6,0x85,0xB6,0x59,0x79,0x53,0xCE,0x91,0x3E,0x6B,0x14,0x4D,0xA9,0x54,0x79,0xA9,0x52,0x54,0x8D,0x39,0x21,0x56,0x4B,0xD1,0x34,0x76,0xB9,0xDA,0x2D,0x79,0xD3,0x58,0xED,0x6A,0x37,0xE5,0x59,0x51,0x55,0xB0,0x13,0x91,0x31,0x57,0x61,0x6A,0x69,0x48,0xA6,0x59,0x55,0x85,0xCB,0xF9,0x7F};
//const uint8_t spPARTIALLY[] PROGMEM = {0x0A,0x68,0xD2,0x88,0x01,0xD1,0x9A,0x8F,0x3C,0x94,0x76,0x77,0xEE,0xB4,0xEA,0xE8,0xCE,0xB5,0x69,0xCB,0xAA,0xB3,0x3E,0xE7,0x91,0x3E,0xAB,0x8A,0xA1,0x65,0x4A,0x36,0x97,0x2A,0x15,0x93,0xF5,0xEC,0x24,0x80,0xA0,0x84,0x13,0x30,0xC3,0x78,0x00,0x56,0x9A,0x4A,0xC0,0x8C,0x53,0x0E,0x68,0x61,0xB2,0x65,0x4D,0x9A,0x7B,0xAA,0xDA,0xD2,0x36,0x90,0xE3,0xAC,0xE9,0x46,0xD7,0xA0,0x77,0x88,0xB8,0x4B,0xDB,0x02,0xB2,0xA6,0xEA,0xBE,0x1D,0x87,0x62,0x27,0x4B,0xB2,0xB5,0x57,0x59,0xE6,0x2E,0xBB,0xC7,0x31,0x59,0x3A,0x96,0x6F,0x69,0x4F,0x17,0xC1,0xDA,0xFE,0x39,0xDD,0x3D,0x1B,0x8B,0xC7,0xAA,0x7C,0xA5,0xB3,0x47,0x61,0xB7,0x5C,0xF2,0xFF};
//const uint8_t spVISIBILITY[] PROGMEM = {0xE6,0xCA,0xCA,0x8D,0x55,0x73,0x9B,0x23,0x09,0x77,0x76,0xCB,0xE2,0x8E,0x2A,0x4C,0xD5,0xD4,0xB5,0xDB,0x8B,0x50,0x35,0x15,0xDF,0x6B,0xEC,0x36,0x5C,0x95,0x5D,0xAD,0xB6,0x19,0x33,0x75,0xDD,0xB2,0xEA,0xA6,0x4C,0xDD,0xED,0xCD,0xAA,0x9B,0x72,0x75,0xF1,0xD5,0xAB,0xFE,0xCE,0xC4,0x44,0x9D,0x06,0xE0,0x0A,0xE3,0x51,0xBE,0x50,0xE9,0xCC,0x52,0x57,0x31,0x54,0xB8,0x28,0x6D,0x59,0x65,0x55,0xE6,0x6A,0xBC,0x57,0xB5,0xD4,0x87,0xBB,0x67,0x2B,0xD6,0x93,0x50,0xE6,0x9E,0xAD,0x56,0x59,0x6C,0x98,0xAA,0x6C,0x5E,0x65,0x36,0x69,0xA6,0xBE,0x79,0x15,0x8D,0x56,0xB8,0xC9,0xE6,0x52,0x75,0x10,0x2D,0x1C,0x4D,0x57,0xD5,0x70,0x87,0xAB,0x74,0x5E,0x45,0x65,0x63,0x2E,0xB6,0x69,0x55,0x55,0xB6,0x39,0x59,0x6B,0x33,0x64,0xEA,0xE6,0xA4,0xB9,0x0C,0x30,0x85,0x7A,0xCB,0x9F,0x0C,0x66,0xD5,0xDC,0x2B,0xEF,0xC1,0x48,0x2C,0x97,0xAC,0x7C,0x58,0x47,0xAA,0x58,0x3C,0xF2,0xA1,0x0C,0x69,0x72,0x71,0x2A,0xBA,0x10,0xB4,0x8D,0x99,0xAC,0x21,0xA6,0x6A,0x4C,0x6D,0xFF,0x3F};
//const uint8_t spDRIZZLE[] PROGMEM = {0x69,0xDD,0x6E,0xD2,0x4D,0x48,0x97,0x6D,0xC6,0xF0,0x66,0x96,0x5D,0x86,0x62,0xC3,0x54,0x2D,0xD9,0x68,0x73,0x92,0x64,0xB7,0x74,0xAB,0x2A,0x4E,0x43,0xCD,0xB6,0xAC,0xB2,0xEA,0x54,0x35,0x7D,0xDD,0xCA,0xC6,0xDA,0xC8,0x7C,0x73,0xA9,0xBF,0x90,0x30,0x92,0xAC,0x65,0xF8,0xB7,0xD0,0x45,0x95,0x08,0x20,0x83,0xE8,0x31,0x67,0x9E,0xE1,0xAE,0x6B,0xDA,0x14,0xD5,0x46,0x98,0x6C,0x71,0x7B,0x30,0x1F,0x6A,0xB6,0x35,0x9C,0x41,0x5F,0x99,0x68,0x5B,0x77,0x07,0xFD,0xC9,0xEA,0x6D,0xDD,0xED,0xED,0xA7,0xA8,0xB7,0xFD,0x7F};
//const uint8_t spINDICATED[] PROGMEM = {0xAB,0x1B,0xD6,0xC9,0xAB,0x26,0xAD,0x72,0xA8,0x64,0x99,0x9C,0xB5,0xB2,0x26,0x4D,0x33,0x62,0xF2,0xC8,0xBA,0xC1,0xF2,0x34,0xD7,0x2D,0x6B,0x1A,0x3B,0x5C,0xDD,0x84,0x3C,0x09,0x1A,0xF1,0x4E,0x34,0xEA,0xA1,0x5C,0x99,0xAD,0xD9,0xAA,0xA7,0x70,0x91,0xD4,0x35,0xA3,0x19,0x26,0x90,0x4B,0x5F,0x9B,0xB9,0x39,0xA4,0x59,0xA9,0x84,0xE6,0x29,0x54,0xC4,0xCC,0x71,0x2A,0x66,0xDE,0xD0,0x88,0xB8,0x0E,0x98,0xD6,0xB9,0x55,0x55,0x33,0x67,0x46,0xED,0x55,0xF7,0xA8,0x64,0x99,0x8B,0x57,0x37,0x7C,0x92,0xA4,0xBF,0x59,0x5D,0x0F,0x89,0x1A,0xB1,0x78,0xF5,0xCD,0x18,0x86,0xF7,0xE2,0x34,0x1C,0x67,0x21,0x24,0x91,0xDB,0x74,0x75,0x38,0xB1,0x65,0x59,0x73,0x71,0xCA,0xEE,0x3D,0x67,0xCD,0xD5,0x98,0x98,0xE7,0xE3,0xB1,0x34,0x6B,0xCA,0xE2,0xAB,0xC5,0x2A,0x64,0x45,0x44,0x44,0x94,0xEB,0xFF,0x03};
//const uint8_t spSEVERE[] PROGMEM = {0x06,0x78,0xC6,0x55,0x01,0x3F,0xA5,0x18,0xE0,0xB7,0x52,0x0B,0x04,0xE0,0xB7,0xD4,0xD5,0x76,0x11,0x41,0xAE,0x5B,0x56,0x5B,0xB4,0xB9,0xBA,0x6C,0x4D,0x43,0x16,0xEA,0x1A,0xE2,0xD6,0x8D,0x99,0xBB,0xB3,0x4B,0xBA,0x34,0x36,0x69,0x26,0x21,0xEA,0x56,0xD9,0x7D,0x28,0x05,0x77,0x5B,0xE9,0xF0,0x25,0x18,0xB2,0x65,0xC5,0x2D,0x24,0x72,0xC9,0xEA,0x15,0x35,0x3F,0xC4,0x43,0x9B,0x47,0x54,0x72,0xA1,0x0E,0x6E,0x19,0x51,0x8E,0xCE,0xDE,0xBC,0x65,0x24,0xD9,0x27,0x9B,0x79,0x1B,0x95,0x16,0x11,0xA2,0xA6,0x8E,0xFF,0x1F};
//const uint8_t spMODERATE[] PROGMEM = {0x22,0xB3,0x2C,0x72,0xC2,0x1C,0x8B,0x4D,0xAA,0xAC,0x21,0x6B,0xE2,0xD6,0x20,0xA4,0x46,0x24,0x59,0x58,0x92,0xE0,0x1C,0xB1,0xB8,0x63,0x8E,0x66,0x5B,0x9D,0x5B,0xAF,0x31,0xE9,0x6B,0x4E,0x6B,0xB3,0xFA,0x2C,0xAF,0x25,0xAD,0xF5,0x6A,0xB3,0xFE,0xB0,0xF2,0x55,0xAB,0x4A,0x6E,0x2C,0xCD,0x57,0x29,0xC0,0x05,0xEB,0x50,0xD7,0xAC,0x12,0xAA,0x4A,0x4A,0x91,0x1B,0xA7,0x78,0xAA,0x4B,0x45,0xAC,0x54,0x6A,0xA9,0xBB,0x15,0xA9,0x52,0x9A,0x99,0xAF,0x55,0xE4,0xCA,0x61,0xEA,0xBD,0x56,0x5E,0x8A,0x73,0x4A,0xB6,0x5A,0x79,0x49,0xCE,0x4E,0xDD,0x98,0x55,0x5C,0x95,0x77,0x64,0x42,0x04,0x4E,0x51,0xAA,0x42,0x35,0x00,0x14,0x30,0x85,0xBA,0x02,0x9E,0xAF,0x10,0xC0,0x8D,0x99,0xFF,0x0F};
//const uint8_t spGREENWICH[] PROGMEM = {0x04,0x88,0x2D,0xA2,0x34,0xC5,0x87,0x9B,0x89,0x95,0x56,0xE7,0x2A,0x6E,0xA6,0xF1,0x56,0x9D,0x9B,0x84,0xBB,0xB6,0x5F,0x45,0xC9,0xAE,0x91,0xB2,0x75,0x15,0xC5,0x96,0xC4,0xD8,0xEB,0x55,0x35,0x17,0x12,0x61,0xB7,0x47,0x53,0x2C,0x55,0xAA,0xD9,0x6D,0x4B,0xB1,0x58,0x61,0xEE,0x7A,0xAD,0x5D,0x97,0x68,0xF9,0xA3,0xB1,0x0D,0xD5,0xC2,0xED,0xAF,0xD2,0xDE,0x74,0xB1,0x4C,0xBC,0x0C,0x47,0xB7,0x45,0x1A,0xFE,0x0A,0x81,0x53,0x94,0xAA,0x50,0x0D,0x40,0xC0,0x74,0xE2,0x0A,0xD8,0x29,0xDC,0x01,0xBB,0x64,0x38,0xE0,0xE4,0x6A,0x07,0xCC,0xF2,0xE1,0x80,0xD9,0xC6,0x19,0xD0,0x67,0xD8,0xFF,0x03};
//const uint8_t spMEAN[] PROGMEM = {0x66,0x0A,0x5C,0xE3,0x24,0x9C,0x84,0x3D,0x08,0xCE,0xE5,0x48,0x9B,0xE6,0xAC,0x30,0x5B,0x3C,0xCD,0x2A,0x66,0x31,0x82,0x88,0x35,0xAB,0x98,0xCD,0x11,0x33,0x17,0xAF,0x6A,0x36,0x43,0x8C,0x5C,0xBC,0xAA,0xD9,0x14,0x29,0x6B,0xD6,0xA8,0x67,0x15,0xE4,0xEA,0x49,0x63,0x98,0x4D,0x90,0xAB,0x46,0xB5,0x79,0x66,0x42,0xED,0x1E,0xDD,0x96,0xE1,0x89,0x62,0x2A,0x48,0x59,0x9B,0x26,0xCE,0xF1,0x30,0x69,0x6F,0x1A,0xDB,0xD2,0xEC,0x84,0xAB,0x2A,0x6C,0x2B,0x4D,0xE5,0x9E,0x24,0x28,0x23,0xCA,0x89,0xF9,0x8A,0xC2,0xB2,0xD1,0xD4,0xE1,0xAB,0x1A,0xD3,0xCB,0x3D,0x87,0xAF,0x19,0x4C,0xCB,0x70,0x9D,0xBE,0xE6,0x5C,0xCC,0x7D,0xD6,0xFF,0x03};
//const uint8_t spMIST[] PROGMEM = {0xAC,0x75,0x2C,0x7C,0x4A,0x93,0x98,0x43,0x4B,0x8F,0x49,0x4B,0x6C,0x56,0xA9,0x3C,0x36,0xB4,0x8E,0x99,0xB5,0xB2,0x98,0xB0,0xC4,0x61,0x0C,0x52,0x6D,0x42,0xEA,0xA4,0x31,0x71,0xD5,0x6A,0xAE,0xBB,0xBA,0xE6,0x8D,0xCD,0xFD,0xF6,0xAA,0xBA,0x0F,0x56,0xF7,0xC7,0xAB,0x6C,0xC1,0xC5,0xAD,0x67,0xAF,0xB6,0xBA,0xE0,0xF0,0x99,0xBD,0xA6,0x6A,0x9B,0x2C,0x6A,0x76,0x5B,0x8B,0x6B,0x32,0xAF,0x5B,0xE9,0x79,0x62,0x46,0x41,0x94,0x1A,0xE0,0x19,0x57,0x05,0xFC,0x94,0x62,0x80,0xDF,0x4A,0x2D,0x10,0x80,0xDF,0x52,0x1D,0xF0,0x4B,0x99,0x01,0x7E,0x2E,0x43,0xE0,0x14,0xA5,0x2A,0x54,0x03,0x00,0x14,0x30,0x85,0xBA,0x00,0x9E,0xAF,0x20,0xC0,0x8D,0x99,0xFF,0x0F};
//const uint8_t spESTIMATED[] PROGMEM = {0xE3,0xEE,0xD1,0xD8,0xBD,0x17,0xAF,0xB1,0x7A,0xD5,0xF2,0x9D,0xBD,0xDA,0xEA,0x4C,0xCB,0x67,0xF6,0xAA,0x8A,0x0B,0x0D,0xEF,0x45,0x2B,0x2F,0xD6,0x3C,0xB4,0x17,0xAF,0xE2,0x99,0x30,0x15,0x77,0x52,0x80,0x67,0xB6,0x1C,0x70,0x53,0x0F,0x03,0x4E,0x72,0x0E,0xC0,0x35,0x16,0xCB,0x6F,0x3A,0x4C,0x4D,0x56,0x97,0x22,0xC8,0x70,0x4D,0xDD,0x5C,0x8A,0x28,0xCC,0xAA,0xA4,0xCE,0xCA,0x8B,0x4B,0xD3,0xD0,0xD5,0x2B,0x6F,0x36,0xC4,0xD2,0x16,0xAD,0xA2,0xBB,0x60,0x8F,0x58,0xB4,0xCA,0xE6,0x8D,0xDD,0x72,0xB1,0xEB,0x13,0x33,0xB3,0xF4,0xC6,0xA3,0x1B,0xB6,0x95,0x8D,0x3A,0xAD,0xBA,0x06,0x15,0x93,0x9E,0xBD,0x9A,0xE2,0x45,0xCD,0x7A,0xCA,0x68,0xAB,0x75,0x11,0xF5,0x55,0x6A,0x30,0xBC,0xC2,0x33,0x62,0x88,0x51,0x8B,0x8C,0x8C,0xB4,0xF9,0xFF};
//const uint8_t spDECREASING[] PROGMEM = {0x0C,0x28,0x30,0xAC,0x8C,0xCB,0xA6,0xAB,0x45,0xEC,0x55,0x0D,0x65,0x24,0x19,0x77,0x56,0xD5,0xB5,0xA2,0x76,0x3E,0xDE,0x55,0xA9,0x87,0x55,0xB0,0x89,0xD7,0x6A,0x88,0x42,0xB4,0xCB,0x43,0x22,0x70,0x8A,0x52,0x15,0xAA,0x01,0x0C,0x08,0x57,0x95,0x01,0xA1,0x69,0x28,0xA0,0xD4,0xF4,0x95,0xF5,0xE8,0xC4,0xA9,0x5B,0x56,0x3E,0x42,0x20,0x95,0xAD,0xD9,0xF9,0x28,0x46,0x30,0xE4,0xB4,0xD7,0xAD,0x7A,0xAE,0xDB,0x81,0xDC,0x1A,0xE0,0x77,0x73,0x05,0xFC,0x69,0xAE,0x80,0xDF,0x35,0x34,0xB0,0x8A,0xA6,0x43,0x25,0xEC,0xF1,0x9A,0xAA,0x75,0x91,0x8E,0xC7,0x6B,0xAD,0xDA,0xD5,0x2F,0x16,0x95,0xA3,0x1A,0x95,0x3C,0x1B,0x19,0xCE,0x6C,0x39,0xC7,0x25,0xAC,0xB9,0xB3,0xA1,0x31,0x33,0xDB,0xEE,0x2E,0x8E,0x5B,0xC2,0x1D,0x9A,0x27,0x1B,0xC9,0x54,0x8B,0xED,0xDE,0x6C,0xC5,0x53,0xAD,0x72,0xF8,0x5A,0x54,0x8E,0xF4,0xD1,0xE1,0xEB,0x4D,0xD5,0x24,0x46,0xFD,0x3F};
//const uint8_t spMOVING[] PROGMEM = {0x6A,0x91,0xB2,0x23,0xC5,0x93,0x98,0xD9,0x2A,0xED,0x14,0x4F,0x12,0xA6,0xA4,0xB8,0x8A,0xD5,0x59,0x99,0xB2,0xA2,0x09,0x66,0x27,0xA5,0x0B,0x26,0x33,0x84,0x9E,0xB4,0x36,0xF1,0x4A,0x77,0xF8,0x5C,0x9A,0x28,0x2B,0x5D,0xE1,0x75,0x69,0x82,0xCE,0x0C,0xA6,0xC5,0xA1,0x8F,0x2A,0xDC,0x55,0x63,0xBB,0xA1,0x33,0x57,0x71,0x8B,0x5D,0x9A,0xA4,0xCC,0xC2,0x2A,0xD5,0xAA,0x9B,0x13,0xB5,0xF0,0x59,0xAB,0xE9,0x41,0xD8,0x2A,0x26,0x8D,0xB6,0x6B,0xE1,0x5A,0xB1,0x5A,0xDA,0xAA,0xA8,0x53,0xC4,0x69,0x69,0xAB,0xA2,0x71,0x51,0x27,0xA9,0xAF,0x92,0xF5,0x13,0xE3,0xFD,0x3F};
//const uint8_t spPRESSURE[] PROGMEM = {0x08,0x88,0x44,0xC5,0x00,0xC5,0xB9,0x1A,0xA0,0x64,0xB3,0xD1,0xA5,0x2C,0xA5,0xC5,0x6B,0x56,0x97,0xB3,0xBA,0xA7,0x6E,0x59,0x63,0xC9,0xAE,0x11,0xBA,0x65,0x2D,0x25,0x99,0x5A,0xDA,0xEA,0xB6,0x36,0xEB,0x2A,0xE1,0x29,0x13,0xB0,0xAC,0x6B,0x02,0x66,0xD9,0x4C,0xC0,0xCC,0xDB,0x0E,0x68,0x41,0xA9,0x4D,0xC5,0x27,0x49,0x7B,0xB6,0xB2,0xD6,0x34,0x8C,0xAD,0xFE,0xCB,0x51,0x8E,0xB3,0x15,0x75,0x2D,0x57,0x1E,0x4A,0xBE,0xDC,0x25,0xDD,0xB9,0x09,0xC5,0x4A,0x96,0xF0,0xE4,0xC3,0x9C,0x25,0x5D,0xDC,0x53,0x9E,0x72,0x25,0xA7,0x71,0x6F,0x79,0xA9,0x69,0xAC,0xF4,0xFF,0x01};
//const uint8_t spALTERNATE[] PROGMEM = {0xAA,0xB0,0xAF,0x4D,0xA5,0x6B,0x95,0xC9,0xCE,0x4D,0xE5,0x6C,0x32,0x46,0x57,0xB7,0x8C,0xBC,0xCD,0xE8,0x82,0xB9,0x4E,0x91,0xAC,0xAB,0x8E,0xE2,0xA7,0x8C,0xB3,0x8E,0x2C,0xEA,0x9C,0x52,0xF1,0x56,0xB2,0x6C,0x64,0x52,0xC4,0x2D,0x02,0x1C,0xE7,0x24,0x40,0x31,0xEA,0x01,0x18,0xBE,0x6D,0x78,0x4D,0x87,0x8A,0xB9,0x9B,0x95,0x94,0x90,0x4C,0xC3,0xDD,0x56,0x56,0xAA,0xAA,0x85,0xB4,0x6B,0x79,0xB2,0x62,0x11,0x51,0xAF,0x65,0x49,0x89,0x77,0x68,0xDC,0x95,0x36,0x1D,0x12,0x61,0x8B,0x46,0x56,0x45,0x89,0xB7,0x2F,0x5C,0x59,0x13,0x25,0x9E,0xBE,0xA8,0x64,0x45,0x04,0xA7,0xE6,0x46,0x04,0x4E,0x51,0xAA,0x42,0x35,0x00,0x0C,0x30,0xA4,0x9B,0x02,0x36,0x57,0x43,0xE0,0x14,0xA5,0x2A,0x54,0xE3,0xFF,0x01};
//const uint8_t spCLEAR[] PROGMEM = {0x0C,0xC8,0xA3,0x39,0x00,0xC5,0x96,0x3B,0xA0,0x73,0x4F,0x03,0x4C,0xAD,0xD5,0xB2,0xCC,0x6C,0x42,0xB8,0xCB,0xCA,0x1A,0xE7,0xAC,0xE4,0xB6,0x2B,0x9F,0x46,0xC2,0x82,0xB6,0xAD,0x62,0x5A,0x37,0x0A,0xDE,0xB6,0x8A,0x19,0xDA,0xC1,0x69,0xDB,0x2A,0xA6,0x2B,0x85,0x90,0xAD,0xAB,0x9C,0xAE,0x04,0x53,0xB6,0xAC,0x72,0xD8,0x12,0x2C,0xD9,0x32,0xAA,0xE6,0x9A,0xB8,0x65,0xCB,0xA8,0xAA,0x6D,0xD4,0x95,0x2E,0xA5,0x2A,0xB6,0x51,0x4F,0xB2,0xA5,0xAA,0xA4,0x45,0x59,0xF1,0xFA,0xFF};
//const uint8_t spCURRENT[] PROGMEM = {0x0A,0xC8,0xB3,0xC0,0x01,0xB9,0x34,0x8F,0x3C,0x37,0xB1,0x28,0x4E,0xBB,0xEA,0x34,0xC4,0xB3,0xB8,0xED,0xAA,0x53,0xE7,0xB0,0x32,0xF7,0xAB,0xCE,0x83,0xD3,0x2D,0xDD,0xAF,0x3A,0x17,0xB5,0xD0,0xEC,0xB6,0xAA,0x62,0x52,0x46,0xF3,0x4A,0xAB,0xAA,0x71,0x69,0x9C,0xCA,0xAE,0x4A,0x82,0xBB,0xD8,0x52,0x23,0x70,0x8A,0x52,0x15,0xAA,0x01,0xA0,0x80,0x21,0xDD,0x18,0xB0,0xB9,0xDA,0xFF,0x03};
//const uint8_t spBLOWING[] PROGMEM = {0x08,0x28,0xA5,0xD4,0xEC,0xC8,0x8C,0xB9,0xA7,0x9D,0xB4,0x27,0x23,0x3E,0x69,0x4A,0xD2,0x90,0x84,0xAE,0x29,0xAD,0x5B,0x7D,0xA1,0x36,0xA9,0xD4,0x76,0xB5,0x59,0xF4,0xB8,0xC8,0x9E,0x55,0x27,0xB9,0xAD,0xAA,0x5D,0x5A,0x15,0xE5,0xB5,0x98,0xF6,0x6D,0x75,0x30,0x97,0x6E,0xD4,0xA7,0xB5,0x21,0xAE,0xBB,0xC9,0xE6,0x36,0xC4,0x5C,0x92,0x1E,0xAB,0xDA,0x9A,0x83,0x6B,0x46,0xBC,0x6A,0x47,0xF3,0xC1,0x3A,0xDE,0xB9,0x1D,0x3D,0x24,0xCB,0xFA,0xAA,0xF2,0xF6,0xA4,0x6C,0x6B,0x15,0xCB,0x57,0x35,0x47,0x15,0xC5,0x49,0x6F,0x35,0x6C,0x95,0xE2,0x38,0x3D,0xCD,0x53,0x86,0x4B,0x1C,0xF7,0x54,0x4B,0x95,0xAA,0x71,0xDC,0xD3,0x12,0x87,0x5B,0x85,0xF9,0x7F};
//const uint8_t spAT[] PROGMEM = {0xA9,0xAC,0x36,0xB9,0x32,0x1F,0xAD,0xB5,0xBA,0x94,0x4C,0x9F,0xBD,0xA6,0xE6,0x4A,0x23,0xED,0xF1,0x1A,0xBB,0x19,0xD3,0xB4,0xCD,0x6B,0xEC,0x6A,0xCC,0xD2,0x36,0xAF,0xB1,0xCB,0x91,0x70,0x7B,0x8D,0xC0,0x29,0x4A,0x55,0xA8,0x06,0x80,0x00,0xA6,0x54,0x37,0xC0,0x55,0x2A,0x04,0x58,0x9C,0xF5,0xFF,0x01};
//const uint8_t spTURBULANCE[] PROGMEM = {0x01,0x18,0xCE,0x22,0x01,0xDB,0x55,0x04,0xA0,0x85,0xB6,0x11,0xA7,0x10,0x2C,0xE3,0xDE,0x56,0x9E,0xBB,0x8A,0x17,0x65,0x1B,0x59,0xAA,0xC6,0xDE,0x94,0xA7,0xE4,0xD1,0x07,0xC7,0x90,0x37,0xD6,0x10,0x9F,0x3E,0x69,0x6A,0xCC,0x94,0x84,0x5A,0x44,0xA6,0x6E,0x7D,0x35,0xCE,0x5C,0xD9,0x75,0x0D,0x4D,0x05,0x73,0x66,0xD7,0x35,0x74,0x19,0xCA,0x19,0x5D,0xD6,0x58,0x55,0x9A,0xBB,0x6E,0x5D,0x73,0x47,0x56,0x9E,0xEA,0xB5,0x2D,0x0B,0x73,0x55,0x98,0xF2,0xB5,0x74,0x5A,0x69,0x2E,0x5D,0xD6,0xD4,0xC4,0xB8,0xB8,0x76,0x5E,0x63,0x67,0xED,0x1A,0xB6,0x69,0x0C,0x4D,0x9A,0x94,0x6A,0xEB,0xD0,0x15,0x89,0xDD,0x1C,0x6E,0xC4,0x9A,0xA9,0x45,0xB1,0x39,0x32,0xC0,0x33,0xAE,0x0A,0xF8,0x29,0xC5,0x00,0xBF,0x95,0x5A,0xC0,0x00,0xBF,0xA5,0x1A,0xE0,0x97,0xB2,0xFF,0x07};
//const uint8_t spTHINLY[] PROGMEM = {0x08,0x38,0x2C,0x14,0x01,0x4D,0x84,0x0A,0xA0,0xC9,0xF0,0x14,0x37,0x13,0xEA,0x62,0xAD,0x57,0x56,0xAD,0x99,0xAA,0xBD,0x59,0x79,0x73,0xAE,0xEA,0xFE,0x78,0x15,0x4D,0x87,0x5A,0xE8,0xA3,0x51,0x76,0x87,0x56,0x61,0x76,0x47,0xD5,0x0C,0xD9,0xB8,0xDB,0x1B,0xCD,0xA0,0xAE,0x59,0x98,0x64,0x74,0x1B,0xC9,0xB8,0x89,0xDB,0xD5,0x56,0x39,0xAA,0xAE,0x9B,0x4F,0xDB,0x65,0xB1,0x87,0xBD,0x5E,0x7D,0x77,0x89,0x6E,0xF1,0x68,0x0D,0xDD,0x39,0x84,0xE7,0xA2,0x32,0xF4,0x88,0x12,0xDE,0xB5,0xFF,0x1F};
//const uint8_t spINCREASING[] PROGMEM = {0xA3,0x69,0x2A,0x58,0x3D,0x1E,0x8D,0x66,0x89,0x54,0x4A,0x5B,0xBD,0xBA,0xC5,0x43,0xA4,0x74,0x55,0xE9,0x9B,0x22,0x59,0xD7,0x68,0x6D,0x68,0x9A,0x64,0x5D,0xAD,0x85,0x21,0x2B,0xCC,0x55,0x93,0x8B,0xC0,0x29,0x4A,0x55,0xA8,0x06,0x10,0x20,0xCD,0x14,0x06,0xC4,0xD6,0x6C,0x80,0x9C,0x32,0x5B,0x96,0xA3,0xA9,0x98,0xB9,0x59,0x79,0x49,0x6C,0xE6,0xD6,0x75,0x14,0xD5,0x28,0xD9,0xD8,0xEA,0x96,0xB5,0xA0,0x28,0xE5,0xAF,0x4B,0x79,0x5D,0xB7,0x00,0xB9,0x35,0xC0,0xF3,0x1E,0x0E,0xF8,0xC9,0x23,0x01,0x3F,0x89,0x8D,0xA4,0xAB,0x60,0xF5,0x58,0xBC,0xDA,0xA1,0x42,0x24,0xFD,0xF5,0x1A,0x96,0x4E,0xA1,0xF2,0x55,0x6B,0x5C,0xCA,0x99,0xCF,0x2B,0xB6,0x71,0x18,0xE1,0x6A,0x89,0xD6,0xC6,0x6E,0xC8,0xCB,0xCD,0x6E,0x1B,0x9A,0x21,0x6F,0x37,0xA7,0x65,0xAC,0x9A,0xCB,0xD4,0x14,0x95,0xA1,0x5A,0xD2,0x50,0x2F,0xFC,0xFF};
//const uint8_t spMORE_THAN[] PROGMEM = {0x62,0x4E,0x9C,0x62,0xCC,0x9C,0xBA,0x3D,0x09,0x8E,0x52,0x4F,0x9C,0xE6,0xA2,0xA5,0x82,0x55,0x55,0x99,0xAA,0xA2,0x0C,0x53,0xC5,0x6D,0xEC,0x9A,0xBD,0x43,0xA4,0x8C,0x3E,0xC8,0x9A,0x4D,0x72,0x3A,0xDA,0x28,0x7B,0x26,0xD1,0xE9,0xAA,0x83,0xED,0x1E,0xC3,0x34,0x2B,0x0F,0xFE,0x2C,0x55,0x72,0x8F,0x2C,0xD4,0xD4,0x32,0xD9,0xB5,0xD2,0x98,0xCD,0x3A,0xB4,0xE3,0xC8,0xB2,0x69,0x4A,0x8F,0x45,0xA6,0x76,0x26,0x24,0x35,0x6B,0xA9,0x2E,0x73,0x35,0xF1,0x4A,0x5D,0xBA,0x2E,0x53,0x54,0xAD,0xCD,0xAA,0xAA,0x33,0x35,0xCD,0x55,0xAB,0xEA,0xAA,0x58,0x33,0x5E,0xAD,0xBA,0xC9,0x66,0xCF,0x7C,0xBD,0x9A,0x66,0x9A,0x23,0x73,0xD1,0x6E,0x56,0xDB,0x74,0x73,0x66,0x2C,0xDA,0xED,0x6A,0x9B,0x6A,0xCE,0x88,0x47,0xAB,0x6B,0x56,0x74,0x38,0x9D,0xB4,0xB6,0x1A,0x8A,0x94,0x74,0xD5,0x9A,0x66,0xA9,0xDC,0x42,0x63,0xA9,0xAB,0x46,0x5F,0x4E,0xCD,0xA9,0x2E,0x42,0xE8,0xB2,0x2C,0xFD,0x3F};
//const uint8_t spLESS_THAN[] PROGMEM = {0x69,0x5D,0x40,0x2B,0x54,0x92,0xA4,0xE5,0x20,0xEC,0x51,0x71,0x9A,0xC6,0x83,0x70,0x46,0x34,0xDE,0x18,0x16,0xE4,0x09,0x33,0xA7,0xAB,0x2E,0x74,0x32,0x42,0x36,0xAF,0xAA,0x88,0xB6,0x0A,0xFF,0xBC,0xAA,0x12,0x5C,0x53,0xFA,0xF1,0x28,0x6B,0x32,0x0D,0x9C,0x59,0x01,0xF8,0x86,0xC4,0x01,0x7F,0x86,0x1A,0xE0,0xCF,0x52,0x03,0xFC,0x60,0x89,0xC0,0x29,0x4A,0x55,0xA8,0x06,0x8C,0xAC,0x88,0x12,0x37,0x7B,0xB4,0xAA,0x2A,0x5A,0xBC,0xFC,0xF6,0x6A,0x9B,0x6B,0x76,0xF7,0xC7,0xAB,0xAB,0x36,0xB9,0x32,0x1E,0xAD,0xAE,0xBA,0x90,0x8A,0x9C,0xB5,0xBA,0x62,0x52,0xDA,0x72,0xD6,0xE8,0x8B,0x48,0x1D,0xF5,0xB9,0xAD,0xAB,0x86,0xBC,0x25,0x1D,0xB7,0xBE,0x19,0xF2,0x91,0x50,0x3A,0x86,0xA2,0xCB,0x4C,0xB2,0xD3,0xFF,0x03};
//const uint8_t spFREEZING[] PROGMEM = {0x04,0x18,0xB6,0x82,0x00,0xD3,0x57,0x08,0x60,0xBA,0x74,0x05,0x34,0x5B,0xD6,0x8A,0x6A,0xD2,0x43,0x4D,0xCE,0x28,0x52,0xA5,0xA6,0xD4,0x2C,0xAB,0x2E,0x89,0x5D,0x5D,0xDA,0xAD,0xAA,0x67,0x25,0x09,0x7B,0xB3,0x8A,0x11,0x1D,0x29,0xED,0xF5,0x28,0x9A,0x27,0xF4,0x8C,0xDB,0xAD,0xA8,0x4A,0x28,0xDD,0x5F,0xB5,0xAA,0x31,0x67,0x33,0xDD,0x35,0xDA,0x8D,0x4D,0xCD,0x2D,0xEF,0x18,0x7E,0x16,0x74,0x57,0x2F,0xAD,0xF9,0x95,0x31,0xCC,0xD3,0x8E,0xB6,0x93,0x64,0x8B,0xDC,0xB8,0xEA,0x1E,0x8C,0x45,0xE3,0xCE,0x6A,0xBA,0x17,0xCA,0xF2,0xC2,0xA3,0x6D,0x06,0xDB,0x43,0x9C,0x8C,0xB6,0x19,0x2C,0x0B,0x76,0xD3,0xDA,0xA2,0xB0,0xCD,0xC5,0x75,0x69,0x93,0xE4,0x31,0x35,0xD7,0xAA,0x77,0x52,0x73,0x25,0x52,0xFD,0x3F};
//const uint8_t spAIR[] PROGMEM = {0xAD,0x6F,0x5E,0x38,0xBB,0x1A,0xAE,0xBE,0x67,0x65,0xCF,0x5C,0xB9,0x9A,0x5E,0x83,0xD4,0x7D,0xF3,0xAA,0x5A,0x31,0x2C,0xCF,0xC5,0xA3,0xAC,0xA5,0x20,0x83,0x5F,0x8F,0xB2,0xE6,0x01,0x1F,0xFA,0x34,0xCA,0x52,0x13,0x72,0xE8,0xD5,0x28,0xF2,0x10,0x9E,0xE0,0x57,0xA3,0xCC,0x93,0xB4,0xD5,0x7B,0x95,0xAA,0x6C,0x0C,0x93,0xCE,0xF4,0xFF};
//const uint8_t spBELOW[] PROGMEM = {0x0C,0x50,0xD6,0x6C,0x24,0xD5,0x39,0x73,0x58,0xEB,0x55,0x75,0x9F,0x8C,0x65,0x6B,0x56,0xD3,0x9C,0x92,0x94,0x3F,0x19,0x6D,0xD3,0xC6,0x9C,0xB6,0x66,0x74,0x8B,0x89,0x6B,0x52,0xB7,0xD1,0x2D,0xC6,0x11,0xC1,0xE9,0x5B,0xB7,0x04,0x65,0x3A,0x66,0x1F,0xDD,0x16,0x54,0xA5,0xD8,0x6D,0xD5,0x8D,0x66,0xBB,0xF2,0xD6,0x55,0x15,0x9E,0xED,0x2A,0x5B,0x56,0x95,0x79,0x4F,0xA8,0x74,0x19,0x65,0x14,0xD3,0x21,0xD2,0xB9,0x15,0x51,0xCE,0x18,0x6B,0xE7,0x52,0x78,0xBD,0xAD,0xA4,0x9D,0x53,0xE9,0xE5,0xB6,0x91,0x74,0x49,0x55,0x90,0xD3,0xC2,0xBA,0x25,0xD4,0x91,0x74,0xAB,0x69,0x1B,0x57,0x47,0x31,0xEA,0xAA,0x75,0x44,0x23,0x45,0xBB,0x9B,0xCD,0xF9,0x7F};
//const uint8_t spAND[] PROGMEM = {0x6B,0xA8,0x2E,0x79,0xAC,0x37,0xAE,0xA5,0xBA,0xE4,0xCE,0x5C,0xB8,0xA6,0xE6,0x92,0xB3,0x62,0xD1,0x9A,0xAA,0x2B,0x8E,0x8A,0x45,0x6B,0xAA,0xA6,0x38,0x33,0x66,0x97,0xA9,0x39,0xCC,0xD0,0xF0,0x9C,0xA6,0x66,0xB1,0x5C,0xD2,0xB3,0x99,0x93,0xA4,0x0E,0x19,0x17,0x64,0xE3,0xBA,0x34,0xB3,0x6D,0x96,0xA7,0x69,0x53,0x57,0xDD,0xD2,0x96,0x6A,0x8A,0x45,0xA2,0xF5,0xFF,0x03};
//const uint8_t spFOR[] PROGMEM = {0x08,0xA8,0x56,0x98,0x00,0xD5,0x97,0x13,0x60,0xD8,0x50,0x51,0x58,0x77,0xA5,0x81,0x59,0x62,0x57,0xBA,0x20,0x6E,0x25,0x58,0x5B,0xEB,0x83,0xB9,0xE2,0x14,0xEF,0xA3,0x0F,0x7E,0x2D,0x8A,0xBD,0x8D,0x3E,0x86,0x11,0x4F,0xF3,0x37,0x86,0x64,0x53,0xCB,0x2D,0x77,0x18,0x33,0x2F,0x09,0x97,0x45,0xFF,0x0F};
//const uint8_t spHAZE[] PROGMEM = {0x08,0x28,0x5A,0x1C,0x01,0x45,0x7B,0xB4,0xA6,0x39,0x92,0x8E,0x2A,0xBD,0xCA,0x1E,0x8D,0x22,0x63,0xCE,0xAA,0xBA,0x73,0xD2,0xF1,0xDB,0xAB,0xEA,0xCE,0x48,0xC7,0x27,0xAF,0x6A,0x78,0x47,0x9D,0x98,0xBD,0x9A,0xEE,0x14,0x6D,0x73,0xF6,0x18,0x87,0x75,0x94,0xC9,0xC7,0x6D,0x19,0xD6,0x40,0xB6,0x6E,0xB5,0x7D,0x78,0x43,0xDE,0x5A,0x5C,0xF6,0x11,0x14,0x79,0x72,0x71,0x3A,0xBB,0x63,0xB2,0xCE,0xD7,0xE1,0xAC,0x8E,0x54,0x63,0x6A,0xBB,0x2B,0x18,0xF1,0xAE,0xAE,0x15,0xEE,0xCC,0x5D,0x22,0x72,0x55,0x7A,0x3A,0x09,0x27,0xCD,0xBE,0xE5,0x59,0x58,0xDD,0xD4,0xB3,0x86,0xF7,0x05,0xB5,0x61,0x72,0xA2,0x80,0xDF,0x4A,0x15,0xF0,0xAB,0xBB,0x00,0x7E,0x4A,0xFF,0x7F,0x08};
//const uint8_t spHIGH[] PROGMEM = {0x28,0x5A,0x1C,0x01,0x45,0x7B,0x94,0x32,0x87,0xB0,0x32,0x8E,0xB2,0xF2,0xE4,0xC6,0x33,0x65,0xF6,0xCA,0x53,0x68,0x8F,0xD4,0xC5,0xAB,0x48,0xA9,0x22,0xDD,0x17,0xAD,0x32,0xD5,0xF4,0x74,0x5F,0xBC,0xBA,0x1C,0xCB,0x32,0x74,0xF1,0x1A,0x8A,0x6F,0x8B,0xD4,0xC5,0x6B,0xAD,0xAE,0xCD,0x4B,0x17,0xAF,0xA3,0xBA,0x56,0x2F,0x7D,0x34,0xEE,0xEA,0x5A,0xAC,0x6D,0x51,0x7B,0x9A,0x6D,0xF1,0xD2,0x47,0xFD,0x2D,0x6F,0xD1,0x21,0x33,0xF9,0x30,0x7D,0x2D,0x88,0x74,0xD4,0xE4,0xF4,0x57,0xAF,0x34,0xD5,0x93,0xD2,0xDF,0x82,0x61,0x76,0xCF,0xFE,0x7F};
//const uint8_t spSCATTERED[] PROGMEM = {0x06,0x78,0xC6,0x55,0x01,0x3F,0xA5,0x18,0xE0,0xB7,0x52,0x0B,0x04,0xE0,0xB7,0x54,0x04,0x4E,0x51,0xAA,0x42,0x35,0xC0,0x00,0x3D,0x15,0xAD,0xA0,0x15,0x65,0xCB,0xB8,0xBD,0xB2,0xEA,0x4D,0xB2,0xE2,0xD1,0x2A,0x4A,0x30,0xAD,0x8A,0xDB,0xAB,0xAA,0xC5,0x35,0x23,0xEF,0xAC,0xA6,0x64,0xB5,0xD2,0x2D,0x6D,0xFA,0x49,0xCD,0xD2,0xCB,0x91,0x00,0xBA,0x55,0x6D,0x5D,0x6D,0xC2,0xE1,0xB6,0xA8,0x4C,0x65,0x32,0xB5,0xEB,0xAB,0xB2,0x96,0x65,0x90,0x45,0xBB,0xCB,0x5E,0x5B,0x82,0x0C,0x6F,0x2E,0x67,0xAD,0x45,0xDC,0xBC,0x27,0x9D,0x75,0x88,0xA8,0x44,0x5B,0x75,0x65,0x43,0x56,0x96,0x35,0xD9,0x15,0xA5,0x68,0x79,0x34,0x64,0x40,0x81,0x61,0xE5,0x1E,0xCE,0x4D,0xCC,0x3B,0xFF,0x3F};
//const uint8_t spINCREASING_TO[] PROGMEM = {0x6E,0x1D,0x59,0xD1,0x2C,0x9B,0xB4,0x75,0x58,0x03,0x9F,0x9A,0x35,0xBA,0x1E,0x04,0xB3,0x7A,0xF6,0x6A,0x7B,0x52,0xB2,0xA8,0x39,0xAB,0xED,0x3E,0xC8,0x32,0x67,0x9F,0xBE,0x8B,0x62,0xAD,0x58,0xD4,0xFA,0x6E,0x48,0xC7,0xDC,0x69,0x1B,0xBA,0x41,0x6B,0x0B,0xA7,0xA5,0xAF,0x1A,0x63,0xD4,0xED,0xBA,0x21,0x4A,0xCA,0x35,0x8B,0x23,0x66,0xCB,0xCA,0x32,0xAD,0x12,0x02,0xA7,0x28,0x55,0xA1,0x1A,0x60,0x80,0x94,0xBC,0x0C,0x90,0x72,0xB8,0x01,0x72,0x2C,0x1F,0x49,0xC9,0x62,0x92,0xD2,0xF9,0x64,0x2D,0x1A,0x49,0xEA,0x96,0x95,0xF5,0xAC,0x20,0x69,0x8F,0x5B,0xD6,0x3C,0xB1,0x47,0x3D,0x4A,0xC0,0x44,0xAA,0x01,0xF8,0xDE,0x33,0x00,0xBF,0x85,0x27,0xE0,0x3B,0x8F,0x95,0x76,0xED,0xAC,0xEA,0xAB,0x57,0x3E,0x8C,0x13,0x67,0x3C,0x1E,0xC5,0xB0,0x8A,0x32,0x51,0xB9,0x15,0x55,0xB1,0x4D,0x49,0xDC,0x56,0x54,0x49,0xE5,0x66,0xAE,0x5B,0x5E,0x15,0x95,0x9B,0xA9,0x2E,0x59,0x91,0x58,0x25,0xAE,0xC6,0x65,0x51,0xD0,0xA4,0xA4,0x66,0x04,0x4E,0x51,0xAA,0x42,0x35,0xC0,0x00,0x4D,0x8B,0x27,0x60,0xBB,0xEA,0x00,0xF4,0x70,0x5D,0xB2,0xAA,0x55,0xCD,0x74,0x75,0x69,0xB3,0x64,0xCB,0x92,0x37,0xA5,0x8B,0x42,0xA2,0x52,0xDF,0xA4,0x2E,0x4A,0xCE,0x0E,0xDD,0xFC,0xFF};
//const uint8_t spIN[] PROGMEM = {0x65,0xED,0xD6,0xD1,0x2A,0x3F,0xB5,0x65,0x98,0x40,0xED,0xDA,0x3C,0xE6,0xA1,0x13,0x79,0x72,0xF5,0x1A,0x87,0x09,0x94,0x8E,0xC7,0x63,0x6C,0xDE,0xD1,0x2A,0x2F,0xB7,0xB1,0x7A,0xE7,0x88,0xBC,0x9C,0xA6,0xE6,0x30,0x53,0xCD,0x49,0x99,0x9A,0xA5,0x70,0x73,0xC7,0x65,0x6A,0x86,0x22,0xD5,0x9D,0xA4,0xB9,0x19,0x8C,0xD0,0x70,0x1D,0xE6,0xAA,0x31,0x4B,0xDD,0x8D,0x5B,0xB2,0xC4,0x31,0xCD,0x44,0xFF,0x0F};
//const uint8_t spLOW[] PROGMEM = {0x65,0xDF,0x98,0xA3,0x4A,0xB4,0xE5,0x65,0x4E,0xAB,0x9F,0xD4,0xA2,0x92,0xBC,0x9E,0xB6,0xF2,0xC8,0x71,0xEA,0x7B,0x9B,0xD5,0x24,0x5E,0x3D,0xCC,0x79,0x77,0x3B,0xFB,0xB9,0xF4,0xBD,0xEE,0xF5,0x0C,0x97,0x37,0x5D,0x0B,0x92,0xC7,0xDF,0xFE,0xFD,0x7F,0xA1,0x4A,0x36,0xBD,0xDD,0x3B,0x97,0x2D,0xE6,0xB2,0xD4,0x6C,0x35,0xA6,0x18,0x2A,0x4A,0x6D,0xD3,0x1A,0xB3,0xDA,0x08,0x97,0xDE,0x6B,0x88,0x66,0x3D,0x5D,0x7B,0x8F,0x21,0xA9,0xF6,0x08,0xF1,0x1C,0xE6,0x2C,0xC3,0xD2,0x28,0xB5,0x5B,0x32,0x77,0x0D,0x53,0x27,0x69,0xEB,0xD2,0xD9,0x55,0x1C,0x97,0x65,0x4B,0x33,0xD5,0x70,0x12,0xF6,0x29,0x5A,0x45,0x45,0xC9,0xFF,0x03,0x08,0x9C,0xA2,0x54,0x85,0x6A,0xC0,0xFF,0x03};
//const uint8_t spTHUNDERSTORM[] PROGMEM = {0x04,0xE8,0xA6,0x94,0x02,0x14,0x38,0x79,0x15,0x15,0x16,0xB2,0xF9,0xE4,0x4D,0x76,0x7A,0xD2,0x96,0x93,0x37,0xD9,0x61,0x41,0x9B,0x5B,0x5E,0x0D,0x66,0xAB,0x39,0x2B,0x45,0xD6,0xD8,0xA1,0xE1,0xA6,0x54,0xC5,0x50,0xB0,0x5B,0x9B,0xD5,0x35,0x93,0x4A,0x1E,0x69,0x4F,0x53,0x43,0xA1,0x94,0x79,0x5B,0x6D,0x8D,0x09,0x5A,0x96,0x6D,0x0C,0xA5,0x30,0x85,0x47,0xE6,0x00,0x2C,0xC3,0x16,0x80,0x9B,0xC3,0x1C,0xF0,0x4F,0xAB,0x02,0xEE,0x49,0x45,0x40,0x17,0xA0,0xAD,0xDE,0xC6,0x42,0xD8,0xDD,0xAC,0x3E,0xF3,0x0E,0x4A,0xCF,0x36,0x86,0xA8,0xCF,0xB9,0x38,0x5B,0x99,0x43,0x3D,0xB7,0xC2,0xAC,0x6D,0x09,0x6D,0x2C,0x9D,0xEB,0xB6,0x35,0xD6,0x91,0x74,0x49,0x5A,0x8E,0x58,0x5A,0x32,0x24,0x6D,0xD9,0x52,0x4E,0xEE,0xE2,0xB6,0xE5,0xCF,0xC5,0x79,0x8A,0x7B,0xA7,0x3F,0x77,0xB6,0x76,0xEF,0x9D,0xFE,0xDC,0x9C,0xD3,0xCC,0x8B,0xFB,0xB3,0x56,0x35,0x59,0x2B,0xE6,0x8F,0xD6,0xC4,0xAD,0x23,0xAB,0x3F,0x19,0x35,0xA7,0xAE,0x6C,0xFE,0xAC,0xD8,0xD2,0x3D,0x77,0xF9,0x5F,0x71,0x2D,0x65,0xA7,0x04,0xF8,0xCD,0x99,0x00,0x7F,0xB4,0xFC,0x3F};
//const uint8_t spOVERCAST[] PROGMEM = {0xAA,0xF1,0xE6,0xC2,0xCC,0x3A,0x97,0x26,0x8A,0x6D,0x31,0xEE,0x36,0x8A,0x4C,0xBB,0xD5,0xD9,0xDB,0xC8,0x22,0xEF,0xB6,0xC0,0x7C,0x2D,0x8D,0x62,0xDA,0x12,0xFD,0xA7,0xCC,0x9B,0x72,0x4F,0x4E,0x2C,0x6A,0x43,0xAA,0x53,0xCD,0x71,0x18,0xBA,0x76,0x73,0x55,0xDB,0xAD,0x8E,0xB1,0x38,0x1A,0xF3,0x8E,0x2E,0xC5,0x44,0x5F,0xEC,0x3D,0xFA,0x52,0x12,0x6C,0xA9,0x4F,0x1B,0x6A,0x5A,0xC4,0xD5,0x2C,0x69,0x6E,0x79,0x80,0x47,0xDB,0x20,0x70,0x8A,0x52,0x15,0xAA,0x01,0x01,0xE8,0x56,0xC8,0x01,0x55,0x29,0xAF,0xB2,0x26,0xE5,0x94,0x9A,0xBD,0xC6,0xE6,0x8B,0xAD,0xEC,0xF5,0x5A,0x9A,0x69,0xD1,0xB1,0xD7,0x6B,0xED,0x7A,0x54,0xC7,0x5E,0xAF,0xB5,0xEB,0x56,0x6B,0xFD,0xBC,0xB6,0x66,0x47,0xB5,0x6C,0xF5,0x38,0x9B,0x6A,0xF5,0xB6,0xCF,0xE3,0xAE,0x21,0xB5,0x2C,0x16,0xB7,0xA7,0xBA,0xD2,0xD6,0x5C,0xDC,0x9E,0x12,0xDD,0x8B,0xA7,0x76,0xBA,0x73,0xB4,0x48,0xDE,0xD8,0x06,0x78,0xC6,0x55,0x01,0x3F,0xA5,0x18,0xE0,0xB7,0x52,0x0B,0x04,0xE0,0xB7,0x54,0x07,0xFC,0x52,0x66,0x80,0x9F,0xCB,0x10,0x38,0x45,0xA9,0x0A,0xD5,0x00,0x50,0xC0,0x90,0x6E,0x0C,0xD8,0x5C,0xED,0xFF,0x01};
//const uint8_t spUNLIMITED[] PROGMEM = {0x65,0x4D,0xEE,0xCC,0x33,0x56,0x8D,0x26,0xEB,0x0B,0x2B,0x5F,0xB5,0xAA,0xA2,0xC7,0x3D,0x65,0xF1,0x2A,0x53,0x0A,0x77,0xAB,0xCA,0xA5,0xCC,0x8A,0xDB,0x38,0xDC,0x94,0x32,0x2B,0x1E,0x63,0x77,0x13,0xCA,0xA0,0xB5,0x95,0x3C,0x6D,0xAA,0xA2,0xB1,0x94,0x10,0xB7,0xA5,0x8A,0xA2,0xD3,0x54,0x5A,0xB7,0xAA,0x90,0x98,0x50,0x6A,0xD3,0xAA,0x4A,0xAC,0xC3,0xB1,0xCD,0x2A,0x8A,0xCA,0xE0,0xB0,0x25,0xAB,0xE8,0x22,0x92,0x53,0xD7,0xAC,0x72,0xA8,0x48,0x49,0x5E,0x33,0xAA,0xAA,0xD9,0x32,0xC9,0x4E,0x69,0x8A,0x62,0xCB,0xA2,0xA4,0xA3,0xCF,0x26,0x5D,0x43,0x16,0x8F,0x39,0xBB,0x54,0x4D,0x7F,0xD4,0x96,0xAC,0x2C,0xD2,0x62,0x31,0x02,0xA7,0x28,0x55,0xA1,0x1A,0xE0,0x80,0x26,0x53,0x1D,0xB0,0x09,0x59,0x9B,0xB3,0x13,0x33,0xAF,0xC5,0x63,0x6D,0xDA,0x55,0x53,0xB7,0x94,0xBD,0x58,0x17,0x8D,0xF8,0x53,0x8E,0xAA,0x42,0x25,0x6C,0x4B,0x38,0x87,0x74,0xA3,0xE0,0xAE,0xE4,0x72,0x24,0x7D,0x32,0x52,0xD1,0xBB,0x3C,0xDD,0x19,0xB9,0xD8,0x96,0xFF,0x07};
//const uint8_t spLOW2[] PROGMEM = {0x61,0xA9,0xC0,0x3A,0x4C,0xD3,0xA5,0xA5,0x43,0xEE,0x74,0x49,0x97,0x96,0x45,0xA8,0x4A,0x25,0xDB,0x18,0x06,0xD1,0x72,0xA3,0xAC,0xAB,0x6E,0x34,0xDB,0x94,0xFB,0xAE,0xBA,0xD2,0x6A,0x33,0xE9,0xB2,0xAA,0xCC,0xA6,0xCD,0xB4,0xCF,0xAA,0x13,0xDF,0x36,0x95,0xBE,0xA3,0x0D,0x6A,0x2B,0x54,0xFA,0x94,0x21,0x98,0x2B,0x51,0xEF,0x9D,0x16,0x17,0xB7,0x58,0x7C,0x57,0xDA,0x5D,0xD8,0x34,0xD2,0xCE,0xE9,0xD0,0xB3,0x5D,0xB8,0x56,0x87,0x53,0x8F,0x51,0xE5,0x68,0x1C,0x4E,0x95,0xDF,0x44,0x65,0x75,0xB8,0x64,0x3B,0x17,0xF1,0xAE,0xEE,0x56,0xA3,0x43,0xC9,0x5B,0xBB,0x5B,0xF6,0x35,0x15,0x6B,0xE3,0x1E,0x13,0xCF,0x4D,0xB4,0xCF,0xFF,0x03};
//const uint8_t spPERCENT[] PROGMEM = {0x02,0xC8,0xD9,0x5C,0x03,0x2D,0x8A,0xB1,0x30,0x46,0x52,0xAF,0xBA,0x86,0x26,0x1A,0xF6,0x77,0x9B,0xD3,0xD5,0x18,0x68,0x69,0x59,0x63,0xEF,0x80,0x5F,0x5A,0x2D,0x60,0x01,0x0B,0x68,0xC0,0x03,0xAB,0x6E,0xDE,0x25,0x2D,0x17,0xDF,0xFA,0x36,0xBB,0x1D,0x53,0xB1,0x6E,0x23,0x5D,0xA7,0x5D,0x23,0x92,0xB9,0xA7,0x62,0x7F,0x20,0x50,0x84,0x72,0x17,0x91,0x0D,0x00,0xA0,0x80,0xA5,0x33,0x0C,0xF0,0xB3,0x27,0x02,0x5A,0x4A,0xFD,0x7F};
//const uint8_t spOVER[] PROGMEM = {0x63,0x6F,0xC4,0x7A,0x1D,0xB5,0xED,0x61,0x37,0xBB,0x6E,0x75,0x62,0xD9,0x2D,0xEC,0xBF,0x56,0xAD,0x09,0xBA,0x32,0x8C,0x13,0xC7,0xD6,0xED,0x4D,0x85,0x86,0x99,0xE3,0x3E,0xB7,0x29,0x86,0x90,0x2C,0x76,0xDB,0xE6,0x98,0x95,0xBB,0x38,0x4F,0x5B,0x72,0x29,0xB4,0x51,0x6F,0x7D,0xAF,0x47,0xB9,0x73,0x71,0x8C,0x31,0x3F,0xE1,0xC9,0xA9,0x50,0xD6,0xFD,0xBA,0x27,0x57,0xC5,0x6E,0xCD,0xFD,0xFF};
// ROM VM61004
//const uint8_t spALPHA[] PROGMEM = {0x63,0xA9,0x21,0xB4,0x3C,0x16,0xAF,0xB6,0x84,0xD2,0x0A,0x5F,0xB3,0xAA,0xE2,0xDA,0x32,0xF4,0xCD,0x2A,0x93,0xDF,0x28,0xD7,0x27,0xAB,0xC8,0xE2,0x5B,0x93,0x57,0xAF,0xB2,0xD0,0x1B,0x0B,0xEE,0xB2,0xCA,0x24,0xAE,0xC3,0x28,0x4B,0xA9,0x0B,0xAF,0x0E,0x13,0x47,0x02,0xA8,0xA6,0x4C,0x00,0x4D,0x57,0x08,0xA0,0x99,0x0C,0x01,0x74,0xED,0xB1,0xEA,0x22,0xBA,0xD4,0xA9,0xCD,0xAA,0x2B,0xEF,0xD6,0xE0,0xBD,0x6B,0x69,0xAC,0x5A,0x83,0xF7,0xAE,0xB3,0xB1,0x6A,0x0B,0xDE,0x32,0xF6,0xA2,0x3A,0xC2,0x79,0x73,0xBD,0xF2,0xFD,0xFF};
//const uint8_t spBRAVO[] PROGMEM = {0x02,0x10,0x2C,0x34,0xB4,0x46,0xAF,0xC8,0x8A,0xBD,0xD4,0x84,0xA9,0xE6,0x2D,0xFC,0x46,0x1D,0x7B,0x48,0x87,0x2A,0x5F,0x55,0x76,0x13,0xE9,0xBA,0x7A,0x97,0xBB,0x9C,0x55,0x69,0xA3,0xAB,0x48,0xD7,0xD5,0xB1,0x0F,0x63,0xF7,0xA1,0xE6,0x2A,0x3B,0x8E,0x65,0x0C,0xA9,0x52,0x55,0x56,0x8D,0xB6,0x92,0x6A,0x77,0xF1,0xBB,0xC6,0x86,0xB2,0x3A,0x44,0xFD,0x9C,0xDB,0x52,0x48,0xD7,0x38,0xB9,0xEF,0x7B,0xDD,0xC3,0xEE,0x7D,0x67,0xB0,0xF4,0x89,0x67,0xBC,0xFE,0x1F};
//const uint8_t spCHARLIE[] PROGMEM = {0x06,0xD8,0x2D,0x2C,0x01,0x33,0xB7,0x67,0xA0,0xC5,0xC5,0x8D,0xC8,0xB2,0xB7,0x96,0x17,0xBF,0x26,0x87,0xF9,0x5A,0x91,0xF3,0xB0,0x1F,0x75,0x19,0x45,0xCE,0xCD,0x71,0xD4,0x65,0x54,0x39,0x8E,0xDA,0x71,0xB6,0xD1,0xC5,0x30,0xE9,0x6E,0x69,0xCB,0x5C,0x51,0x8F,0x15,0x66,0x49,0xFB,0x80,0x31,0xA2,0xE6,0x7D,0x9D,0x55,0xB6,0x59,0xD8,0xEA,0x71,0x0F,0xDE,0xCA,0xE5,0x9B,0xC7,0xD3,0x65,0x92,0x55,0x6C,0x2E,0xEF,0x30,0x49,0x92,0xB1,0x3A,0xBD,0xC3,0x04,0x72,0xE7,0xE6,0xF0,0x75,0xEB,0xA8,0x93,0xAB,0xFF,0x1F};
//const uint8_t spDELTA[] PROGMEM = {0x0A,0x28,0x30,0x6C,0xAD,0xC3,0xA7,0xAA,0x70,0xD7,0xD5,0x76,0x5D,0x22,0xEE,0x5B,0x57,0xD9,0xF9,0xB8,0xA6,0x6D,0x59,0x65,0x16,0x9B,0xA1,0xDE,0x7B,0xD5,0x99,0x6D,0xA5,0x58,0xDE,0xD5,0x64,0x11,0x5D,0xC2,0x69,0xCA,0x30,0x25,0x5B,0x85,0x32,0x21,0x40,0x96,0x26,0x0E,0x58,0x4A,0x33,0x00,0x4B,0xB5,0xAD,0xAE,0x9A,0xF0,0x30,0xDF,0xB2,0xC7,0x31,0x35,0x55,0xE9,0x21,0x5D,0xFB,0x34,0xF6,0xAA,0xC6,0x3C,0xA5,0x73,0x3F,0xFE,0x1F};
//const uint8_t spECHO[] PROGMEM = {0x2B,0x6F,0xB1,0xD9,0xD3,0x36,0xDF,0xF6,0x36,0xB7,0x26,0x85,0x08,0xE5,0x2E,0x22,0x1B,0x20,0x00,0x25,0xAC,0x2A,0x20,0xCF,0xD3,0x52,0x45,0x53,0x6A,0xA9,0x9E,0x4F,0x9B,0x54,0x47,0xB9,0xE4,0xDF,0xC3,0x1C,0xC6,0x98,0x45,0x65,0xBB,0x78,0x9F,0xCB,0x5C,0xD2,0xEA,0x43,0x67,0xB0,0xE5,0xCD,0x7B,0x38,0x9D,0xAD,0x2C,0x15,0x37,0xF1,0xFC,0x7F};
//const uint8_t spFOXTROT[] PROGMEM = {0x04,0x18,0xB6,0x82,0x00,0xD3,0x57,0x08,0x60,0xBA,0xF4,0x91,0xC6,0x58,0x15,0xCA,0x8B,0x47,0x9A,0xFC,0x64,0x1A,0xAF,0x19,0x59,0x4A,0x9D,0xA1,0xFA,0x64,0x64,0xA9,0x65,0x86,0xE4,0xE2,0x91,0xA7,0xEE,0x99,0x92,0xAB,0x04,0xE0,0xA2,0x93,0x04,0x08,0x90,0x9D,0x33,0x03,0x9E,0x71,0x65,0xC0,0x4F,0x29,0x0A,0xF8,0xAD,0xD4,0x02,0x08,0x9C,0xA2,0x54,0x85,0x6A,0x80,0x00,0x86,0x21,0x57,0xC0,0x48,0x53,0x01,0x18,0x36,0xBC,0x65,0xA9,0x4B,0xAA,0x4B,0x9B,0xD6,0xC4,0xEE,0x11,0x41,0x6B,0xDB,0x94,0xEC,0x94,0x36,0xED,0x6D,0x4B,0x76,0x93,0x9E,0xFC,0xA5,0xED,0xD9,0x4D,0x58,0xEA,0x9A,0xBE,0xB7,0x2B,0xC5,0x76,0x4F,0x7F,0x14,0xFE,0xD8,0xCD,0x2B,0x7A,0xB2,0xFA,0x9B,0xF2,0x88,0xF0,0xAE,0x08,0x14,0xA1,0xDC,0x45,0x64,0x03,0x80,0x00,0x8E,0xE0,0x30,0xC0,0xB2,0x53,0xFF,0x0F};
//const uint8_t spGOLF[] PROGMEM = {0x0A,0x88,0xA1,0x71,0x15,0x85,0x76,0x45,0x8A,0xFF,0x9B,0xDF,0x6C,0x65,0x99,0x5C,0xB7,0x72,0xDE,0x9D,0xED,0x72,0x77,0x73,0x6C,0x4B,0x54,0x35,0x63,0xE4,0xA6,0xEE,0xF9,0x34,0x57,0x94,0x39,0x63,0xE4,0x86,0x5F,0x04,0x98,0x34,0xDD,0x02,0x0E,0x98,0x32,0x5D,0x03,0x12,0xE0,0xC0,0xFF,0x03};
//const uint8_t spHOTEL[] PROGMEM = {0x08,0xC8,0x4A,0x0C,0x01,0xC5,0x74,0x11,0xA0,0xCA,0xEA,0xD1,0x36,0x5A,0xDD,0x46,0xDE,0x56,0x55,0x49,0x76,0x07,0x79,0xDB,0xC5,0x28,0x0A,0xEE,0x6E,0x61,0xFF,0xBD,0xAC,0x0D,0x02,0x45,0x70,0x17,0x11,0xD9,0x00,0x02,0xE8,0x54,0x2D,0x00,0xD5,0x84,0x05,0x60,0x2A,0xB3,0x93,0x35,0x67,0x66,0x9C,0x6B,0x4E,0x56,0xBD,0x9B,0x6A,0xDD,0x39,0x59,0xF1,0xAE,0x6E,0xBD,0xF8,0x14,0xC5,0xA7,0x85,0xE5,0xE2,0x53,0x15,0xD5,0x9E,0x2E,0x9F,0xCF,0x50,0xE4,0xA6,0x07,0xBF,0x59,0x6B,0xC5,0x33,0x19,0xD8,0xA5,0x1C,0x89,0xCE,0x94,0x61,0x9B,0x74,0x7A,0xDD,0x13,0xC4,0x4B,0xFC,0xE9,0x4E,0xA7,0xAE,0x0A,0xA5,0xCD,0xFF,0x03};
//const uint8_t spINDIA[] PROGMEM = {0xA3,0x9D,0xD6,0x99,0x32,0x17,0x8F,0x66,0x86,0x16,0x74,0x5F,0xB3,0x9A,0xE1,0x4A,0xC4,0xF4,0xCE,0xAE,0x46,0xD1,0x1D,0x5A,0x46,0x3A,0x99,0x45,0x2B,0xAA,0x82,0xAC,0x08,0x27,0xBE,0x5A,0xDD,0x0C,0x25,0x42,0xBC,0x7B,0xF5,0xD3,0x17,0x61,0xF8,0x96,0xDD,0xEF,0x61,0x2C,0xCD,0x8A,0x44,0xC6,0xE3,0xB1,0x57,0x1B,0x62,0x69,0xAF,0xC7,0x99,0x9C,0x7B,0x66,0x2C,0x6E,0x77,0xF6,0x69,0x11,0xF6,0xAA,0xBC,0x29,0xA4,0x87,0xDB,0xE7,0xF4,0xE5,0x14,0x1E,0x1A,0xAB,0xDD,0x9F,0x62,0x7A,0x68,0xAC,0xFA,0x7F};
//const uint8_t spJULIET[] PROGMEM = {0x61,0x5D,0x96,0x49,0x34,0xD2,0x06,0x60,0xC7,0x90,0x0C,0x8C,0x66,0xF6,0x15,0x22,0x4D,0x37,0xAA,0x6A,0xC8,0x2C,0x6D,0xCD,0x28,0xB2,0x15,0x8B,0xE4,0x35,0xB3,0x68,0x79,0x51,0xE6,0xDA,0x9C,0xBE,0x15,0x43,0x89,0xF0,0xA2,0xDB,0x95,0x77,0xA7,0xA6,0x66,0x49,0x77,0xB1,0x9A,0x9E,0x0A,0xD5,0x75,0xEB,0xEE,0xF6,0xB0,0xC6,0xE6,0x83,0xD2,0xE3,0xEB,0x5E,0xD7,0xDA,0x5C,0x48,0x87,0x6D,0x9E,0x7B,0xDF,0xF3,0x89,0x40,0x11,0xCA,0x5D,0x44,0x36,0x00,0x38,0x60,0xEA,0x8C,0x00,0x2C,0xB3,0x6D,0x01,0x01,0x14,0x5F,0x8E,0x81,0xFF,0x07};
//const uint8_t spKILO[] PROGMEM = {0x06,0xE8,0x12,0xD9,0x02,0x12,0x68,0xE1,0x8C,0x86,0xD4,0xF5,0x76,0xC6,0x33,0x1A,0xD1,0x74,0x4A,0x54,0x1E,0x6F,0x26,0x2B,0x5B,0xDC,0x42,0x93,0xB2,0xED,0x71,0x4D,0x95,0x7B,0x8E,0x53,0xDF,0xBD,0xAE,0xB5,0xB0,0xCC,0x2A,0xEE,0xBB,0xF7,0x76,0x26,0x53,0xD9,0x4A,0x7D,0xFB,0x59,0x6E,0x1F,0x2B,0x1B,0x75,0x4D,0xBC,0xE3,0x13,0xDE,0xA0,0xA6,0x32,0xC8,0xAF,0xFB,0x93,0x18,0xAF,0x20,0x7D,0xFF,0x0F};
//const uint8_t spLIMA[] PROGMEM = {0x61,0x5A,0x90,0xBA,0xC0,0xD7,0xA6,0x69,0x00,0x19,0x85,0x6A,0xDA,0x9A,0xCD,0x24,0xD9,0xCC,0xCB,0x2A,0x46,0x76,0x66,0xF5,0x37,0x3B,0x9B,0xC9,0x48,0x7B,0x50,0xD4,0x8E,0xD9,0xBD,0xA8,0x75,0x6B,0xB3,0x62,0xEE,0xF4,0xB8,0xB5,0xAD,0xFD,0xE8,0x1B,0xAF,0xCC,0xA2,0xCE,0x7B,0xD8,0xFB,0x38,0xB3,0xDA,0xC8,0xD0,0x55,0xFD,0xA9,0x6F,0x7D,0xFF,0x1F};
//const uint8_t spMIKE[] PROGMEM = {0x66,0x31,0x3C,0x7C,0x52,0xE3,0xC4,0x69,0xF5,0x85,0x57,0x86,0x51,0xAA,0xD3,0x56,0x75,0xA1,0x69,0x9D,0x6F,0x7D,0xCA,0x6A,0x57,0x23,0x6D,0xF5,0xCD,0x57,0xD1,0x4B,0x50,0x78,0x2C,0xDA,0x75,0x69,0x46,0x77,0xB4,0xCE,0xDB,0xB1,0x45,0xAD,0x08,0xE5,0x2E,0x22,0x1B,0x00,0x18,0xD0,0x3C,0x91,0x03,0x5A,0x09,0xB1,0x80,0x00,0xB2,0x13,0xFE,0x7F};
//const uint8_t spNOVEMBER[] PROGMEM = {0x66,0x2D,0x02,0x62,0x4B,0xE3,0x8E,0xA5,0xEB,0x10,0x77,0x6E,0xB3,0xAA,0x2A,0x2A,0x39,0x74,0xCB,0x2A,0x0B,0xCB,0xB2,0xE4,0xAE,0xAB,0x4C,0xBC,0xDB,0x9C,0xFA,0xB6,0x2A,0x8A,0x29,0x33,0xEE,0x93,0xEA,0xA0,0xA6,0xC4,0xB9,0x55,0xE8,0x92,0xA8,0x54,0xA7,0xC4,0x6E,0x18,0x32,0xCC,0x54,0x2D,0xB7,0xB5,0xA9,0x72,0x53,0x51,0xBC,0xAA,0xE2,0x53,0x2C,0xB4,0xF5,0x2A,0x8A,0x2B,0xB5,0xD2,0xD5,0xAB,0x28,0xA6,0xD4,0xDA,0x5A,0xAF,0x22,0xFB,0x32,0x2B,0x4B,0xD3,0x8A,0x14,0xDC,0xDA,0xC8,0x4E,0xA9,0x52,0x24,0x6B,0x53,0xB9,0x6A,0xF0,0x51,0xB5,0x42,0xE9,0x31,0xC0,0x9B,0xB0,0x34,0xA7,0xA6,0xD4,0x85,0x6F,0xCA,0x5A,0xC2,0x0A,0x2E,0xE6,0x6B,0x67,0x89,0xC3,0xB4,0xD8,0x2F,0x5D,0x25,0x0D,0xD3,0x52,0xDF,0xF4,0x14,0xDF,0x44,0x47,0xFB,0xD2,0x53,0x72,0xA2,0x1E,0x75,0x09,0x4F,0x89,0x8D,0x7C,0xB4,0xE7,0xFF,0x01};
//const uint8_t spOSCAR[] PROGMEM = {0x6B,0xC8,0xE2,0xB2,0x42,0x3A,0xDF,0xFA,0x16,0x27,0x4F,0xAE,0x7D,0xC4,0x17,0xB7,0x2C,0x45,0xAF,0xA4,0xB6,0x6D,0x80,0x03,0xD8,0x0C,0xF0,0xA7,0x9B,0x07,0x3C,0xE0,0x80,0xEB,0xB5,0x11,0x38,0x45,0xA9,0x0A,0xD5,0x00,0x02,0x34,0x75,0x65,0xB6,0xA6,0xAE,0xA2,0x34,0x6E,0xEA,0x8B,0x9B,0x24,0x13,0xA5,0xAD,0xCD,0xA9,0xC8,0x86,0xF3,0xCE,0x7E,0x8E,0x6D,0xC9,0xCD,0xB0,0x5A,0x7A,0xCF,0xAD,0xEE,0xF5,0x4C,0x77,0x89,0x83,0x3A,0xA9,0x37,0x7F,0xE1,0x2F,0xAD,0x48,0x87,0xB3,0xFC,0x3F};
//const uint8_t spPAPA[] PROGMEM = {0x0A,0x28,0x56,0xB9,0xA5,0x45,0x55,0x84,0x49,0xCC,0x93,0x66,0xD7,0x19,0x26,0x4B,0x4E,0x96,0xDD,0x44,0xBA,0xAE,0xBE,0xD9,0xCC,0x10,0x28,0x42,0xB9,0x8B,0xC8,0x06,0x60,0x80,0xF1,0xE9,0xAB,0xCA,0xA6,0x23,0xD4,0x36,0xDF,0xE1,0x8C,0x55,0x74,0x86,0x6B,0x9F,0xB1,0x67,0xBD,0xE1,0xE6,0xBB,0xDB,0x97,0x53,0x45,0x88,0xCF,0xAE,0xDF,0xFF,0x03};
//const uint8_t spQUEBEC[] PROGMEM = {0x0C,0x88,0x7E,0x8C,0x02,0xA5,0x0A,0x31,0xDD,0x5C,0xB2,0xAC,0x26,0x5B,0xCF,0x4C,0xEE,0xBB,0xBB,0xDE,0xA7,0xCD,0xA8,0xB4,0x75,0x4D,0x1C,0xB7,0xD1,0xD5,0x28,0xEE,0xE6,0x5B,0x76,0x7B,0x9A,0x1A,0xC4,0x33,0xF3,0xF1,0x6D,0x76,0x3F,0xE7,0xB6,0xB6,0xEC,0x12,0x91,0x9B,0xF2,0x8E,0x40,0x11,0xCA,0x5D,0x44,0x36,0x80,0x00,0x7A,0x2F,0x53,0x40,0x2D,0x24,0x14,0xF8,0x7F};
//const uint8_t spROMEO[] PROGMEM = {0xA2,0xD5,0x39,0x38,0xCA,0xEC,0xDB,0xA5,0x4C,0xA1,0x98,0x5A,0xB9,0xF2,0xD3,0x47,0x6F,0xE9,0x69,0xCA,0x4E,0xDD,0x89,0x57,0x0E,0x69,0x3F,0x45,0x61,0xD9,0x95,0x98,0x65,0x67,0x25,0x6B,0x86,0x64,0x4C,0xAC,0xF5,0xE2,0x54,0xCD,0x86,0x7A,0xD0,0xE6,0x35,0x4C,0xD7,0x02,0xA5,0x7B,0xF6,0xB0,0xA7,0xBD,0xAC,0xB5,0xAA,0x54,0x1D,0xDB,0xB2,0xF6,0xEC,0xC3,0xD3,0x64,0x73,0xD9,0x63,0xC8,0x2C,0xD5,0xDF,0xE9,0x0C,0xA1,0x33,0xD8,0xF2,0xE6,0x33,0x5E,0xEE,0x09,0xB6,0xB2,0x54,0xDC,0xF8,0xE7,0xFF,0x01};
//const uint8_t spSIERRA[] PROGMEM = {0x0C,0xF8,0xAD,0x54,0x03,0x06,0xF8,0x2D,0xD5,0x01,0xBF,0x94,0x39,0xE0,0xE7,0x32,0x0B,0xB4,0xAC,0x3B,0x25,0x75,0x5F,0xBD,0x8A,0x11,0x0D,0x39,0x63,0xF5,0x28,0x47,0x34,0xE0,0xEA,0x4D,0xA3,0x1A,0x49,0x91,0xBB,0x56,0x8D,0x7A,0x78,0x45,0xD9,0x7C,0xB2,0x9A,0xE1,0x9C,0x78,0xE2,0xF1,0x69,0x86,0x09,0x92,0xB1,0xD7,0xA7,0x6E,0x2E,0xD9,0xC7,0x5E,0x9F,0xBA,0x84,0xE4,0x1C,0x79,0xBD,0xAA,0xD4,0xC4,0xB2,0x79,0xCD,0xA8,0x53,0x97,0xF0,0xA6,0x3C,0xA3,0x4B,0x53,0xC3,0x9A,0xF2,0x8C,0x31,0x55,0x0B,0x1D,0xEA,0xB3,0xF6,0x14,0x3D,0x2D,0x35,0xCF,0xD9,0xB3,0x1B,0xF3,0xD0,0x3E,0xEB,0x2C,0x7A,0xDC,0x53,0x36,0x8F,0x2B,0xC5,0xD6,0x70,0x7F,0xD5,0x9E,0x14,0xDB,0xC2,0x7C,0x55,0xF9,0x72,0x4C,0x2F,0xF1,0x97,0xE9,0xCF,0x6A,0xB5,0xC2,0x76,0x96,0x3F,0x87,0xD2,0xD2,0x58,0xF9,0xFF};
//const uint8_t spTANGO[] PROGMEM = {0x0E,0xD8,0x5C,0xCD,0x03,0x2B,0x2A,0xD9,0xD4,0x23,0x2B,0xAD,0xB4,0x26,0x57,0x8F,0x58,0xB2,0xB2,0x56,0x5C,0x2D,0x63,0xF6,0xCA,0x5A,0x36,0xF5,0xCC,0x59,0x2B,0x6B,0x91,0xB5,0xDB,0x42,0xB7,0xBC,0x5A,0xEA,0x34,0x57,0x5D,0xCA,0x62,0x68,0x5C,0x55,0xB5,0xAB,0xA3,0xA2,0x09,0x13,0xA7,0x65,0xA8,0x2A,0x98,0x53,0x56,0x8F,0xA9,0xB2,0x30,0x19,0xDD,0xB3,0xA6,0x22,0xCB,0xA4,0xB4,0xEB,0x18,0xB3,0xEA,0x90,0x92,0x2E,0x6D,0x0D,0xBE,0xC3,0x52,0x3A,0xA7,0x23,0xC4,0x0A,0x4B,0xD9,0x5B,0xAE,0x50,0x32,0x3C,0xA4,0x73,0xF8,0x42,0x0B,0x37,0x93,0xD5,0xE6,0xF3,0x35,0xDD,0x95,0x7F,0xAB,0xCF,0x87,0xF2,0x34,0xDE,0xF7,0xFF};
//const uint8_t spUNIFORM[] PROGMEM = {0x61,0x3D,0x56,0x98,0xD4,0xB6,0xE6,0xA5,0x8D,0xC7,0xA8,0x01,0xC5,0xDA,0x33,0x2C,0x97,0x06,0x12,0xD9,0x4F,0xD9,0x6D,0x30,0xA6,0x65,0xDF,0x79,0x4B,0x8B,0x11,0xCF,0xE0,0xAE,0x29,0xCD,0x4E,0x5D,0x38,0xEA,0xF5,0xF4,0x64,0x45,0x47,0x84,0xCA,0xE6,0x5D,0xF5,0x96,0x01,0xCD,0x97,0x6A,0x40,0x03,0x1A,0x28,0x5D,0xD0,0xDB,0x61,0xEC,0x7D,0xF7,0x7B,0x3C,0x53,0x16,0xDB,0x9A,0xEA,0xF5,0x2E,0x6B,0x2D,0x6A,0x43,0x46,0xBC,0xCD,0xB3,0x3D,0xD9,0xB5,0xDA,0x70,0xDF,0x72,0xE7,0x94,0xEA,0xCD,0x9D,0xDD,0x9D,0xBC,0x73,0xA9,0x28,0x35,0x4F,0x12,0x41,0xE1,0x96,0xD4,0x3D,0x4D,0x24,0xA7,0x8A,0x94,0xF8,0xFA,0x37,0x7C,0xCD,0x76,0x78,0x50,0xEA,0xF8,0xFD,0x3F};
//const uint8_t spVICTOR[] PROGMEM = {0x6E,0x6E,0x52,0x55,0xCD,0xDD,0xA8,0xAD,0x72,0x55,0x95,0x70,0xE3,0xB6,0xE9,0xDD,0xD4,0x84,0x4E,0xD9,0xA6,0x4B,0x0B,0x65,0xA5,0x2B,0x6D,0x2E,0x4D,0x42,0xB6,0xAC,0xAC,0xDB,0x12,0x49,0x5D,0xBD,0xF2,0x1E,0x02,0x2D,0x6C,0x35,0x30,0xA0,0x72,0x46,0x04,0x4E,0x51,0xAA,0x42,0x35,0x00,0x40,0x01,0x33,0x49,0x3A,0x60,0x5A,0xF1,0x32,0x96,0x6C,0x2C,0x2D,0x5D,0xDA,0x9C,0x63,0x21,0x9F,0xE6,0x2F,0x5B,0x29,0x4D,0xBC,0x94,0xAF,0xED,0xA5,0x34,0xF1,0x72,0xB6,0x74,0x94,0xBA,0x82,0xC3,0xFE,0xCB,0x59,0x46,0x93,0x34,0xE5,0x2B,0x57,0xE9,0x85,0x5A,0xE2,0xC7,0xDD,0xE5,0x0A,0xA7,0x4B,0xA7,0xFF,0x07};
//const uint8_t spWHISKEY[] PROGMEM = {0x04,0x88,0xAE,0x8C,0x03,0x12,0x08,0x51,0x74,0x65,0xE9,0xEC,0x68,0x24,0x59,0x46,0x78,0x41,0xD7,0x13,0x37,0x6D,0x62,0xC3,0x5B,0x6F,0xDC,0xD2,0xEA,0x54,0xD2,0xE3,0x89,0x01,0x7E,0x2B,0xF7,0x80,0x07,0x14,0xD0,0xE5,0x15,0x38,0x60,0x8C,0x70,0x03,0x04,0x29,0x36,0xBA,0x5E,0x14,0x34,0x72,0xF6,0xE8,0xA7,0x6F,0x82,0xF4,0x2D,0x73,0xEA,0x47,0x3A,0x67,0x6A,0xC0,0xF0,0x2F,0xF1,0x4E,0xCF,0xA8,0x8A,0x1C,0xB9,0xD8,0xFF,0xEE,0x1F,0xBB,0x59,0xD0,0xD6,0xFE,0x3F};
//const uint8_t spXRAY[] PROGMEM = {0xAB,0xAA,0xDE,0xB4,0x62,0x66,0x9F,0xA2,0x75,0x73,0xD3,0x6E,0x72,0xB2,0x56,0x54,0xCB,0xBA,0xB6,0x01,0x92,0xC7,0x26,0x40,0x4B,0x43,0x0C,0xC8,0x29,0xC5,0x01,0xCF,0xB8,0x1A,0xE0,0xA7,0x14,0x07,0xFC,0x56,0xEA,0x01,0x05,0x98,0x60,0x5A,0xEA,0xD4,0x29,0xB5,0xB8,0xEB,0x68,0x53,0x17,0xB3,0x96,0x6E,0xA3,0x2F,0x29,0x54,0x5B,0xF6,0x8D,0xB5,0xA9,0x32,0x5E,0xDB,0x37,0xB6,0xA1,0xDB,0xB1,0x74,0xCB,0x58,0xBA,0x49,0x91,0xF6,0xCD,0xE3,0x1A,0x3A,0x85,0x3A,0x56,0xB7,0x6B,0x98,0x62,0xEA,0xF8,0xDC,0xBE,0x9E,0x83,0xD4,0xE3,0x49,0xF8,0x7B,0x71,0x54,0xAF,0xD9,0xE1,0xEF,0x53,0x55,0xB8,0xE7,0xFE,0x3F};
//const uint8_t spZULU[] PROGMEM = {0x6D,0xFE,0xDE,0xC4,0xC4,0xE8,0x29,0x60,0x00,0x2E,0x0F,0x9C,0x6C,0x29,0x71,0x2A,0x4E,0x77,0x93,0x15,0x77,0x2A,0xAE,0xC3,0xCE,0x76,0x3C,0x92,0xA5,0x44,0x78,0xD1,0x6D,0xCF,0x47,0x3B,0xB8,0xBB,0x07,0xF6,0x5B,0x43,0x91,0x6E,0xA9,0xF2,0x65,0x4C,0xC9,0x98,0x97,0x69,0x9F,0xBA,0xE5,0x33,0x9C,0xC1,0x9A,0x8F,0xCA,0xDE,0x70,0x07,0x9D,0xEE,0xC9,0x79,0xE2,0xED,0xFF,0xFF,0x07};
//const uint8_t spAFFIRMATIVE[] PROGMEM = {0xA5,0x4F,0x7A,0xD3,0x3C,0x5A,0x8F,0xAE,0xC8,0xA9,0x70,0xED,0xBD,0xBA,0x2A,0x3B,0xC3,0xD9,0x8F,0x00,0x6C,0x4A,0x21,0x40,0xD3,0xCA,0x08,0x18,0xC2,0x04,0x01,0xC3,0x86,0x11,0x60,0xDA,0x4C,0x05,0x54,0x53,0xDA,0x9C,0x58,0x16,0xED,0xC8,0xEB,0x88,0xE2,0x4C,0xEC,0xC1,0x36,0x23,0xC8,0x65,0xD1,0x17,0xBA,0xB4,0x20,0xE5,0xE4,0x6A,0x8A,0x53,0xA2,0xAC,0x0B,0x73,0x38,0xC9,0xC8,0xB2,0x68,0xCE,0x92,0x24,0x33,0x5B,0x45,0xB1,0xA9,0x11,0xB6,0x6A,0x75,0x4D,0x96,0x98,0xC7,0xAA,0xD6,0x37,0x91,0xEC,0x12,0xAF,0xC8,0xD1,0xB1,0x88,0x97,0x25,0x76,0xC0,0x96,0x22,0x01,0xF8,0x2E,0x2C,0x01,0x53,0x99,0xAD,0xA1,0x7A,0x13,0xF5,0x7A,0xBD,0xE6,0xAE,0x43,0xD4,0x7D,0xCF,0xBA,0xBA,0x0E,0x51,0xF7,0xDD,0xED,0x6A,0xB6,0x94,0xDC,0xF7,0xB4,0xB7,0x5A,0x57,0x09,0xDF,0x9D,0xBE,0x62,0xDC,0xD4,0x75,0xB7,0xFB,0xAA,0x55,0x33,0xE7,0x3E,0xE2,0x2B,0xDC,0x5D,0x35,0xFC,0x98,0xAF,0x79,0x0F,0x0F,0x56,0x6D,0xBE,0xE1,0xA6,0xAA,0x42,0xCE,0xFF,0x03};
//const uint8_t spNEGATIVE[] PROGMEM = {0x66,0x88,0x82,0x3A,0xDD,0xE3,0x84,0x31,0x4B,0x6C,0x0F,0x4F,0x9C,0x86,0xAA,0xA0,0x3D,0xB5,0xF1,0xEA,0xBA,0x33,0x71,0xB5,0x59,0xAB,0x1A,0x36,0x55,0x43,0x57,0xAF,0x72,0xF8,0x52,0x4D,0xDD,0xB2,0xF2,0x91,0x92,0x34,0x64,0x75,0xA9,0x9B,0x31,0x8A,0x94,0x4A,0xA3,0x1E,0x3E,0x41,0x4A,0x56,0xAF,0xB6,0x59,0xC3,0x08,0x5F,0xBD,0xBA,0x6A,0x9C,0xD3,0x7C,0x95,0x9A,0x9D,0xF2,0x28,0x8F,0x06,0x68,0x19,0x4C,0xD8,0xCC,0x6C,0x39,0x60,0x28,0x93,0x00,0x5C,0x19,0xD6,0xCA,0x6A,0x9D,0x5C,0x6B,0xD1,0x18,0x8A,0x31,0xC9,0xA8,0x45,0x63,0xCB,0x3A,0x38,0x2B,0x17,0x95,0xA7,0x04,0x95,0xD0,0x99,0x5D,0x9E,0xE2,0x55,0x43,0xE7,0x75,0x79,0xB3,0x35,0x0D,0xCF,0x55,0xEE,0xCB,0x5E,0x2D,0x38,0x36,0x89,0x3F,0x07,0x33,0x63,0xE9,0x82,0x80,0x60,0x35,0x08,0x50,0x5D,0x2A,0x02,0xAA,0x4D,0xFB,0x7F};
//const uint8_t spMAYDAY[] PROGMEM = {0x66,0xB7,0x52,0x7A,0xCC,0x9D,0x84,0xDD,0x4B,0xA9,0x36,0x77,0x12,0x96,0xC8,0x54,0x27,0x2C,0x5E,0x1A,0x8A,0x10,0xEE,0xB4,0x78,0xAB,0xE9,0xD1,0x4C,0x43,0x57,0xAF,0xA2,0x27,0x57,0xF1,0x58,0xB5,0xD2,0x91,0x82,0xCC,0x73,0xF1,0x4A,0x46,0x76,0xB4,0xA8,0x25,0x2B,0x1E,0xCD,0x50,0xBD,0x66,0xAF,0x78,0x24,0x26,0xF5,0x6E,0xBC,0x63,0x02,0x14,0x18,0xD6,0xFA,0x63,0xD3,0xD4,0x39,0xE6,0xAA,0xBB,0x57,0x36,0xA9,0xC5,0xA7,0x6D,0x5E,0xD9,0xAD,0x97,0x9C,0xA1,0xB9,0x60,0x8B,0x58,0x7D,0xC6,0xEE,0x92,0x2D,0x7C,0xCB,0x99,0xBB,0x29,0xD6,0xF2,0xCD,0x77,0x19,0xEB,0xD4,0x25,0x5C,0xB6,0x79,0x6C,0x3D,0x26,0x69,0xF8,0xAA,0xB4,0x57,0x63,0x14,0x93,0x0B,0xD3,0xD9,0x93,0x92,0x45,0xAE,0x49,0xF7,0xB0,0x81,0x32,0xB9,0x38,0xDD,0xCD,0x28,0xE6,0xD4,0xA2,0xF4,0x34,0x69,0xD8,0x5B,0x8B,0xC2,0xDB,0xAB,0x90,0x7B,0xAD,0x36,0x6F,0xEF,0x22,0xA6,0xD5,0xF8,0xFF,0x01};
//const uint8_t spWARNING[] PROGMEM = {0x6A,0x15,0x71,0x5C,0xDC,0x23,0x89,0x8D,0xD5,0x36,0xB5,0x8C,0x2D,0x36,0xDA,0xC6,0xCC,0xDD,0x91,0x5A,0xB9,0xBF,0x51,0xC7,0xCC,0x69,0x76,0x6A,0xA6,0x12,0xD2,0xB6,0xCE,0xDB,0x6B,0x0F,0xCC,0xBA,0xAA,0x10,0x2E,0xBC,0x29,0xED,0x2A,0xA2,0x5B,0xF3,0xA5,0x2C,0x2B,0x4F,0xA9,0x25,0x9A,0xBC,0xAE,0xBC,0x74,0xD3,0xF0,0x70,0xD6,0x8A,0xE4,0xC4,0x8A,0x3D,0xEE,0x6A,0x9B,0x57,0x35,0x8F,0xD4,0x6B,0xE8,0x3E,0xD8,0x22,0x16,0xAE,0x71,0xF8,0x20,0x4D,0x5F,0xB4,0xE6,0xE1,0x83,0xB4,0x7C,0xD6,0x58,0x46,0x0A,0x94,0xF1,0x99,0x73,0x09,0x47,0xAF,0x28,0x9D,0x16,0x34,0x1C,0xD5,0x61,0xA5,0xAA,0x13,0x73,0x65,0x43,0x15,0xE2,0x71,0xD2,0x95,0x0D,0x67,0x72,0xD8,0x4E,0x77,0xB1,0x5C,0xCE,0xEE,0xA4,0x3C,0x2D,0xBA,0xA4,0x5A,0xE5,0xF2,0x74,0x57,0x6C,0xA9,0xAB,0xFE,0x1F};
//const uint8_t spICING[] PROGMEM = {0x69,0xCA,0x66,0xDD,0xD3,0x16,0xEF,0x71,0x0D,0xC5,0xAC,0x66,0xDB,0xA3,0xD5,0x57,0x57,0xDC,0x6D,0xB7,0x56,0xDB,0xA2,0x63,0x87,0x5F,0x5E,0x55,0xCB,0x4C,0x69,0x35,0xBB,0xD5,0x87,0x17,0xB3,0x66,0x57,0x03,0x3C,0xE3,0x6A,0x80,0x9F,0x52,0x1C,0xF0,0x5B,0xA9,0x07,0x02,0xF0,0x5B,0xEA,0x9A,0xBB,0x0A,0xD1,0xB4,0xC7,0x6B,0xEE,0x2E,0x44,0xCB,0x17,0x97,0xBD,0x67,0x63,0x2F,0x9F,0x94,0x8E,0x16,0x29,0xDA,0x2D,0x4E,0x3A,0xAB,0xE1,0xF2,0xD0,0xD8,0xE9,0x6A,0x86,0x33,0xCC,0x9C,0xA4,0xBB,0x19,0xCE,0x54,0xB5,0xE3,0x9E,0x6A,0x35,0x52,0x2D,0xB6,0x7A,0xBB,0x53,0x2D,0x09,0xBB,0xFF,0x0F};
//const uint8_t spDANGER[] PROGMEM = {0x0A,0x28,0x30,0x6C,0xD4,0xC7,0x54,0x19,0xAA,0x9B,0xD5,0x34,0x6B,0xCA,0xEE,0x6B,0x56,0xDD,0xBD,0xA9,0x44,0xAC,0x59,0xD5,0x08,0xC1,0x9C,0xB1,0x7A,0x65,0x33,0x24,0x72,0xE7,0xAC,0x95,0x8C,0x64,0xE0,0x13,0x95,0x57,0xD4,0xBD,0x50,0x8D,0x45,0x19,0x51,0xB3,0x98,0x61,0xAE,0x64,0xA4,0xCD,0x60,0x94,0x85,0xD2,0x90,0x47,0x41,0x35,0xEA,0xEA,0x5A,0x73,0x4A,0x99,0xA0,0x38,0x09,0xC0,0x76,0x42,0xA3,0x9C,0xDA,0x94,0x35,0xF2,0x8C,0xB1,0x66,0x25,0x0D,0xDB,0x3C,0x86,0x9A,0x4B,0xA0,0x35,0xFB,0x98,0x4B,0x72,0xE2,0xB3,0x6C,0x6D,0xCB,0x43,0xC8,0x47,0xF2,0xA5,0x23,0x6F,0x21,0x6F,0xCE,0x16,0x8E,0xBC,0x89,0x2B,0xB5,0x6F,0x38,0xCB,0x32,0xD2,0x96,0x6C,0xEE,0x2C,0xDB,0x48,0x5B,0xF2,0xB9,0xAB,0x2C,0x11,0x2F,0xEE,0x1D,0xEE,0x52,0x07,0x25,0x43,0xFB,0xFF,0x03};
//const uint8_t spEMERGENCY[] PROGMEM = {0xA3,0x5B,0xCE,0x18,0x23,0x9F,0xAC,0x76,0x79,0x13,0x88,0x7C,0xB2,0xAA,0x19,0x8C,0x21,0x72,0xF5,0xAA,0x5A,0x50,0xD2,0xB0,0xD5,0xA9,0x76,0x52,0xB2,0x53,0xAD,0x95,0x26,0x72,0xD5,0x1A,0x8D,0xD6,0xDA,0x24,0xC5,0x22,0xC2,0x5E,0xAB,0x93,0xD6,0xB0,0x54,0xA5,0xAB,0x88,0x31,0xCD,0x93,0x92,0xAD,0x3C,0xDB,0x56,0x59,0xF6,0xB6,0x92,0x5C,0x83,0x6C,0x30,0xEB,0x0A,0x4A,0x5D,0xC6,0x45,0xAF,0x23,0xA8,0x53,0xC8,0xC2,0xF2,0xAA,0x24,0x3B,0x12,0xD3,0x6E,0xED,0xF2,0xB3,0x0C,0x99,0xDD,0x4B,0x00,0xB6,0x13,0x3A,0xE5,0xD4,0xA6,0xAC,0x91,0xE7,0x54,0xC3,0xA4,0xA1,0xE9,0xB6,0xD3,0x4E,0x19,0x46,0xA1,0xFD,0x46,0x3B,0xB9,0x8A,0x8E,0xB4,0x29,0x43,0x15,0xC2,0x93,0x1C,0xBD,0x8C,0x45,0xB0,0x8D,0x71,0xBD,0x36,0x6D,0xA6,0xA6,0xA2,0x69,0x0D,0xF0,0x8C,0xAB,0x02,0x7E,0x4A,0x31,0xC0,0x6F,0xA5,0x16,0x18,0x55,0x37,0x2E,0xEA,0xFE,0x65,0x0C,0x43,0xBB,0x50,0xFA,0x96,0x36,0x4E,0x93,0x82,0xE5,0x7B,0xDB,0x32,0x94,0x33,0x6E,0xFC,0x19,0xDB,0x74,0xC1,0x58,0xB1,0xA6,0xEC,0xCB,0x17,0x43,0xFA,0x9A,0x70,0x0C,0x6F,0x60,0x55,0xAB,0xFF,0x1F};
//const uint8_t spROGER[] PROGMEM = {0x62,0x11,0xBD,0xD8,0x32,0x95,0xAA,0x99,0xD7,0x26,0x8F,0xB0,0xAB,0x26,0x3E,0x9C,0x2B,0x4D,0x9D,0x1A,0xD5,0x74,0xCA,0x30,0x65,0x61,0x74,0x4D,0x25,0x32,0x98,0xB7,0x36,0x0C,0x71,0x4B,0xD3,0xBE,0xEA,0x98,0x3A,0xCC,0xAD,0xCF,0x2A,0x92,0x1F,0x6F,0xB1,0x2D,0x2B,0x4F,0x7E,0xAC,0xDC,0x36,0xAD,0x38,0xE7,0xD4,0x70,0xDF,0xB4,0xE2,0x52,0x2C,0x54,0x3D,0x53,0x28,0xB2,0xA4,0xF0,0x72,0x57,0xA5,0x5E,0xAD,0x83,0xD9,0x64,0x23,0x60,0x7B,0x93,0x08,0x8C,0x7E,0x44,0x17,0x72,0xF3,0xDB,0x86,0x92,0x85,0xAD,0x7D,0x57,0x1B,0x6B,0x1E,0xA6,0x0C,0xFD,0xE5,0x2C,0x53,0x31,0x5A,0xF3,0xA6,0x3B,0x37,0xA1,0x6C,0xCD,0xE2,0xEE,0x9C,0x8D,0xDD,0x37,0xE9,0xFF,0x03};
//const uint8_t spHERTZ[] PROGMEM = {0x08,0x28,0xA6,0x4B,0x00,0x55,0x56,0x23,0xA0,0x9A,0x99,0x12,0xE7,0x12,0x18,0xC3,0x5D,0x56,0x52,0xED,0x29,0xAC,0xE9,0xDF,0xD9,0xAE,0xE7,0x18,0xD6,0x5A,0x12,0xAC,0x34,0x1F,0x02,0xA7,0x28,0x55,0xA1,0x1A,0x00,0x08,0xD8,0x26,0x94,0x01,0xBF,0x95,0x71,0xC0,0x02,0x16,0xD0,0x80,0x07,0x34,0xC0,0x01,0x0E,0xFC,0x3F,0x08,0x9C,0xA2,0x54,0x85,0x6A,0xC0,0xFF,0x03};
//const uint8_t spSECURITY[] PROGMEM = {0x02,0xF8,0x59,0xC8,0x00,0xBF,0xB7,0x18,0xE0,0x97,0xB4,0x00,0xFC,0x1E,0xD6,0xA2,0x1F,0xCB,0x44,0x9D,0xDD,0xAA,0xA7,0x0C,0xE1,0xD4,0x2D,0xAB,0x1E,0xB6,0x10,0xCB,0xB6,0x20,0x70,0x8A,0x52,0x15,0xAA,0x01,0x06,0x98,0x36,0xC2,0x01,0xD3,0x09,0x07,0x60,0x96,0xB6,0x91,0xF4,0x98,0x84,0xA9,0x5D,0x46,0x51,0x6D,0x11,0xB7,0xF4,0x1D,0x79,0xD1,0x2D,0x3C,0xDC,0x77,0xE4,0x39,0x34,0xCB,0x88,0xDF,0x51,0xE4,0x98,0x64,0xAD,0x7E,0x47,0x5D,0x42,0xB2,0x45,0xFA,0x29,0x43,0x0D,0xEE,0x8A,0xE1,0xD5,0x01,0x83,0xAB,0x39,0x20,0x03,0xF7,0x35,0x34,0xAF,0x64,0x9A,0xAF,0xC6,0x38,0x8C,0xA3,0x54,0xAC,0x2E,0xCB,0xF0,0x8E,0x14,0xB9,0xB9,0x2E,0x7E,0xFD,0x7F};
//const uint8_t spTARGET[] PROGMEM = {0x0A,0xD8,0x5C,0x4D,0x03,0x25,0x8D,0xA9,0x24,0x5A,0x52,0xB6,0x22,0x85,0x31,0x1F,0xDC,0xD2,0xF2,0xB4,0x4C,0xDB,0xE5,0xCA,0xC8,0x52,0x0B,0xEE,0xA6,0xC7,0x2D,0xCF,0x53,0x69,0x43,0x6E,0xA5,0xBA,0x94,0x80,0x2A,0xAA,0x65,0xFA,0x1C,0x88,0x36,0x23,0x51,0x1B,0xEB,0x30,0xF4,0xB0,0x36,0x6B,0xA8,0x51,0x24,0x3D,0xD6,0xAC,0xA1,0x84,0x44,0x4F,0x7F,0xD4,0xE6,0x41,0x46,0x70,0x62,0x23,0x02,0xA7,0x28,0x55,0xA1,0x1A,0x00,0xA0,0x80,0x21,0xDD,0x18,0xB0,0xB9,0xDA,0xFF,0x03};
//const uint8_t spVECTORS[] PROGMEM = {0x6A,0x4B,0x3C,0xC5,0x34,0xD2,0x98,0xBD,0x50,0x77,0x91,0x4C,0xAA,0xF6,0x42,0x2C,0xD8,0xD2,0x8D,0x39,0x2A,0x33,0x13,0x75,0x35,0xEE,0xEC,0xDC,0x44,0x45,0x1D,0x8F,0x2C,0xDB,0x10,0xF3,0xC8,0xB4,0xDA,0x6A,0xC3,0x34,0xBD,0xCF,0x6A,0x6A,0x48,0xF1,0xF0,0xCD,0xBB,0x41,0xE0,0x14,0xA5,0x2A,0x54,0x03,0x18,0x50,0x39,0x23,0x02,0xA7,0x28,0x55,0xA1,0x1A,0x90,0x80,0x65,0xD5,0x57,0xD1,0x4C,0x2A,0x66,0x64,0x1D,0x65,0xC9,0x49,0xDC,0x9A,0xAF,0x95,0xA5,0x18,0x5A,0x49,0xDF,0x56,0xD4,0xA2,0xE8,0x61,0xDD,0x5A,0xD1,0x82,0x93,0x6A,0x64,0x55,0xC0,0x53,0x00,0x0A,0x78,0x04,0x38,0x00,0x9B,0xA2,0x30,0xA0,0x60,0xB1,0xFF,0x07};
//const uint8_t spLIGHT[] PROGMEM = {0x69,0x18,0x44,0xD2,0x83,0xB2,0x95,0x69,0x63,0x1A,0x17,0x49,0xD7,0xA6,0x85,0x78,0x5D,0xD5,0xFB,0x1A,0x33,0xDF,0x76,0x97,0x2D,0x6B,0x68,0x6C,0x4A,0x53,0xF7,0xAC,0xA9,0x89,0x71,0x2D,0xDD,0x33,0xA6,0x26,0x9B,0xAD,0x6D,0x77,0x5B,0x7A,0x70,0xF4,0xC8,0x45,0xE1,0x69,0x8E,0xA9,0x6B,0x6E,0x89,0x62,0x78,0x45,0x8D,0x7C,0x8C,0xC0,0x29,0x4A,0x55,0xA8,0x06,0x06,0x01,0x0C,0x30,0xA4,0x9B,0x02,0x36,0x57,0x43,0xE0,0x14,0xA5,0x2A,0x54,0xE3,0xFF,0x01};
//const uint8_t spFRONT[] PROGMEM = {0x08,0x88,0xDC,0x95,0x01,0x55,0x86,0x2A,0xA0,0x85,0x76,0x05,0xD4,0x90,0x4E,0x00,0x33,0xA9,0x47,0x19,0xBB,0xB4,0x9B,0x7B,0x5B,0x55,0xC8,0xDE,0xE6,0x91,0x65,0x55,0x29,0xB4,0xA5,0xD9,0xE2,0x55,0xE7,0xD0,0x1A,0xEE,0xB3,0x57,0x97,0x53,0x6A,0x78,0xCE,0x69,0x53,0x8A,0x1E,0x1A,0xD5,0x28,0x1C,0x59,0x89,0x27,0x87,0x6D,0x77,0x17,0x25,0x1E,0x62,0x99,0x11,0x38,0x45,0xA9,0x0A,0xD5,0x00,0x50,0xC0,0x90,0x6E,0x0C,0xD8,0x5C,0x0D,0x81,0x53,0x94,0xAA,0x50,0x8D,0xFF,0x07};
//const uint8_t spWAY[] PROGMEM = {0xAC,0xE7,0x7E,0xC2,0xD4,0x1C,0xAB,0x8D,0xC7,0x31,0xB5,0xB0,0xAD,0x76,0x91,0xD6,0x8D,0x2D,0x71,0x58,0x4D,0x59,0x67,0x91,0xB5,0x6B,0xC8,0xB2,0x3D,0x9C,0xB6,0xAD,0xA1,0xE9,0xE4,0x48,0x7E,0xB3,0xDA,0x96,0x8D,0x2D,0x6D,0xF5,0xAA,0x7B,0x32,0xD2,0xCC,0xD5,0xAB,0xEE,0xC9,0x51,0x33,0x17,0xAF,0xBA,0x87,0x00,0x8B,0x5C,0x3C,0x9B,0xFF,0x07};
//const uint8_t spGLIDE[] PROGMEM = {0x08,0x28,0xBD,0x94,0x8D,0x52,0x45,0xAE,0x93,0x1B,0xB3,0x07,0x5F,0x66,0x66,0xAE,0xC6,0xDC,0xB1,0x8E,0xA9,0xA4,0x9B,0xF3,0x6A,0x1B,0x8E,0x0D,0xE6,0xB6,0xAB,0xAD,0xBC,0x3B,0x8C,0xFA,0xAE,0x36,0xCB,0x2D,0x35,0xD9,0xBC,0xBA,0x22,0x36,0x2D,0x64,0xF3,0xEA,0x8B,0x3C,0xD7,0xD2,0xCD,0x6B,0x2C,0xEA,0x4C,0xDB,0x57,0xAD,0x35,0xDB,0x15,0x2F,0x5B,0xB4,0xB6,0x62,0x46,0xB2,0x6C,0xD1,0xD8,0xB3,0x69,0xA9,0xB6,0x95,0xE3,0x2A,0xC1,0xB4,0x23,0x67,0xB7,0x2B,0x5B,0xD7,0xAD,0xBC,0x59,0xAE,0x92,0x28,0x22,0xA7,0x72,0xBA,0x8A,0x17,0xAE,0xEA,0x49,0xEA,0xF2,0x3C,0xAD,0x22,0x2D,0x93,0xD3,0x93,0x88,0x2E,0x57,0xC2,0xCE,0x46,0x94,0x5D,0x33,0x49,0xAA,0xBA,0x35,0x76,0xF3,0x4D,0xFF,0x0F};
//const uint8_t spOPEN[] PROGMEM = {0xA9,0x28,0xC4,0x77,0x84,0xB2,0xB4,0xB2,0x11,0x99,0x35,0xCC,0xDA,0xAA,0x4E,0x78,0xD6,0x31,0x4B,0xAB,0x0B,0xB6,0x2D,0xC5,0xCE,0xAE,0xCD,0xC2,0x5D,0xC3,0x1D,0x23,0x70,0x8A,0x52,0x15,0xAA,0x01,0x08,0x10,0xC3,0x6C,0x0D,0xD9,0xA4,0x5B,0xC8,0xD6,0xB5,0x66,0x13,0xE6,0xE9,0x6B,0xC6,0x5E,0x95,0x5B,0x84,0xAD,0x29,0x67,0x53,0xAC,0x15,0x62,0x37,0x3D,0x5D,0x29,0x67,0x49,0xD4,0xF4,0x0C,0xAB,0x94,0x21,0x56,0xD3,0x3B,0x8C,0x48,0x98,0xC5,0x4D,0x5F,0xE7,0x26,0xE1,0x16,0xC7,0x7D,0x4D,0x73,0x84,0xBA,0x9D,0xFF,0x07};
//const uint8_t spLIGHTS[] PROGMEM = {0x69,0x18,0x44,0xD2,0x83,0xB2,0x95,0x69,0x63,0x1A,0x17,0x49,0xD7,0xA6,0x85,0x78,0x5D,0xD5,0xFB,0x1A,0x33,0xDF,0x76,0x97,0x2D,0x6B,0x68,0x6C,0x4A,0x53,0xF7,0xAC,0xA9,0x89,0x71,0x2D,0xDD,0x33,0xA6,0x26,0x9B,0xAD,0x6D,0x77,0x5B,0x7A,0x70,0xF4,0xC8,0x45,0xE1,0x69,0x8E,0xA9,0x6B,0x6E,0x89,0x62,0x78,0x45,0x8D,0x7C,0x8C,0xC0,0x29,0x4A,0x55,0xA8,0x06,0x00,0x03,0xBE,0x13,0x54,0xC0,0x2F,0x61,0x06,0xF8,0xD9,0xCD,0x00,0xCF,0xB8,0x2A,0xE0,0xA7,0x14,0x06,0xFC,0x56,0xCA,0x81,0xFF,0x07};
//const uint8_t spON[] PROGMEM = {0x69,0x0C,0x69,0xAB,0x44,0x92,0x96,0x36,0x86,0xED,0x52,0x8D,0xD7,0xDA,0x10,0xB7,0x53,0x35,0x5E,0x6B,0x43,0xB9,0x4A,0xD5,0x78,0xAD,0x0D,0xE9,0x32,0xD4,0x9A,0xB5,0x21,0xBA,0x4B,0x37,0x4B,0xDA,0xE6,0x68,0x2E,0xDD,0x2D,0x6D,0xDB,0x62,0x58,0x37,0xF7,0x34,0xED,0x48,0xAE,0x3D,0xDC,0x53,0xA5,0x33,0xE5,0x54,0xF3,0x6C,0x9D,0xCE,0xE4,0xCA,0x42,0x2A,0x73,0xB8,0x8A,0xE6,0x72,0x4D,0x55,0xE9,0x2A,0x46,0x22,0x24,0x6C,0xA7,0xBB,0x3B,0x0E,0x57,0x57,0x12,0xEE,0x6A,0xC4,0x93,0xCD,0x8E,0x79,0x6A,0xD4,0x60,0x49,0xC7,0xFF,0x0F};
//const uint8_t spGUNDISH[] PROGMEM = {0x0E,0xA8,0xB9,0xA5,0x55,0x55,0x85,0x68,0x5B,0xA7,0x55,0x55,0x5D,0x66,0xA1,0x5B,0x56,0x55,0xCC,0x88,0x96,0x6F,0x5E,0x65,0xB6,0x25,0x11,0x7E,0x7B,0x64,0x45,0x97,0x86,0xC4,0x9C,0x96,0x16,0x25,0x19,0x9A,0x8E,0x4B,0x52,0x35,0x75,0x4A,0xA8,0xAE,0x09,0x02,0xA7,0x28,0x55,0xA1,0x1A,0xA0,0x80,0x02,0xC3,0x4A,0x3B,0x54,0x8A,0x8A,0x6F,0x1E,0x43,0xB5,0xCE,0xE6,0x35,0x7B,0x4D,0x4D,0x25,0x6B,0xE4,0xAA,0x31,0x77,0x1E,0x62,0x95,0xAB,0xDA,0x36,0x74,0xB1,0x58,0xEC,0x2E,0xE7,0x88,0x25,0xC2,0xDE,0x5B,0x01,0x3B,0x4E,0x1B,0x60,0xA5,0x6D,0x03,0xEC,0x38,0xAD,0x80,0x15,0xB6,0x05,0xB0,0xCA,0xB6,0x00,0x66,0xBE,0x14,0xC0,0x8C,0xD7,0x0C,0x18,0x6D,0x92,0x00,0xBD,0x97,0xFD,0x3F};
//const uint8_t spR_NAV[] PROGMEM = {0x29,0x89,0x7E,0x53,0x5D,0x53,0x8F,0x21,0xAB,0x2F,0x75,0xEB,0xB2,0x86,0x4A,0x77,0xB4,0x34,0xEB,0x1A,0x8A,0xB8,0xE6,0xD6,0xAE,0xAB,0x2B,0xEA,0x5D,0x96,0x3B,0xAF,0xBA,0xF8,0x13,0x5D,0xDA,0xB4,0xEA,0x92,0x9B,0x7C,0x24,0xCF,0x6A,0x4A,0x67,0x4F,0xF7,0xCC,0xBB,0xD9,0x0D,0x80,0x69,0x92,0x95,0x6C,0x76,0x27,0xAD,0x2B,0x96,0x33,0x39,0x1D,0x97,0xBE,0x1A,0x6C,0xD7,0x70,0xBC,0x86,0x1A,0xD4,0xCC,0x7B,0xD1,0x1A,0xAB,0x37,0x8D,0xA8,0xD9,0x6B,0x6A,0x26,0xC5,0x2B,0x9E,0xAC,0xA5,0xEB,0x56,0x29,0x5B,0xBD,0xD6,0xAE,0x5B,0xB5,0x6C,0xCD,0x5E,0xD7,0xDA,0xF4,0xA8,0xB4,0xBF,0x5E,0x7B,0x53,0x6D,0xDA,0xBE,0x7A,0xEF,0xEB,0xAC,0xBA,0xD5,0xDB,0x57,0xB5,0xAB,0xD8,0x32,0x2F,0xBF,0x5D,0xEE,0xA2,0xC6,0x7C,0xFC,0x61,0xB9,0xB3,0x69,0xF3,0xF2,0x99,0xE9,0x4E,0xAE,0xD5,0xDB,0x1F,0x85,0x3B,0xC7,0x34,0x37,0x5D,0xC5,0xA6,0xA8,0xC2,0x5D,0x35,0x36,0x9F,0xF8,0x84,0x80,0x60,0x35,0x08,0x50,0x5D,0xEA,0xFF,0x03};
//const uint8_t spSELECT[] PROGMEM = {0x0C,0x78,0xC6,0x95,0x01,0x3F,0xA5,0x28,0xE0,0xB7,0x52,0x0B,0x04,0xE0,0xB7,0x54,0x07,0xFC,0x52,0x66,0x80,0x9F,0xCB,0x46,0xB7,0x44,0xAA,0xA9,0xE4,0x59,0x5D,0x53,0x15,0x6C,0xBA,0x65,0xF5,0x85,0x55,0xB8,0xF3,0xE6,0x35,0x2C,0xA8,0x6B,0xAC,0xC9,0xD6,0xB0,0x90,0xAE,0xB1,0xA5,0x5D,0x5D,0xE5,0x9B,0x1A,0xF6,0x7A,0xB5,0x55,0x8E,0x5B,0xF8,0xE6,0xD5,0x36,0x37,0x9C,0x9A,0xAB,0x46,0xD3,0x63,0x62,0x71,0x4C,0x44,0xE0,0x14,0xA5,0x2A,0x54,0x03,0x00,0x40,0x01,0x43,0xBA,0x09,0x60,0x73,0x35,0x04,0x4E,0x51,0xAA,0x42,0x35,0xFE,0x1F};
//const uint8_t spFILED[] PROGMEM = {0x04,0x18,0xB6,0x82,0x00,0xD3,0x57,0x08,0x60,0xBA,0x74,0x05,0x34,0x5B,0xB6,0xCA,0x18,0x27,0xDC,0xA4,0xD5,0xEA,0x52,0xEA,0x08,0xD1,0x4D,0xAB,0x4F,0x69,0x3C,0xD4,0x36,0xAD,0x21,0xBB,0x33,0x2B,0x5B,0xBD,0xC6,0xAA,0xCE,0x65,0x74,0xF5,0x5A,0x9A,0x5C,0xE7,0x91,0xCD,0x6B,0x1D,0xA2,0x8D,0x57,0xBB,0xAC,0xBD,0x89,0x56,0x39,0xDD,0x3C,0xEE,0x6A,0x4B,0x74,0xAC,0x73,0xBB,0x8B,0x1D,0xB1,0xB1,0xDD,0xE5,0x89,0x7E,0x22,0x4C,0x36,0xA5,0x27,0xDA,0xCD,0x50,0xE9,0x12,0x9E,0xA8,0x67,0xDC,0xB8,0x8B,0x7B,0x82,0x9D,0x56,0xE5,0xAE,0xEE,0x8D,0xDE,0x5B,0x49,0xBB,0xAA,0x37,0x7B,0x6B,0x07,0xCE,0x4A,0x5E,0x47,0xD2,0x27,0x23,0x15,0x03,0x0A,0x0C,0x4B,0x7F,0x8F,0x29,0x22,0xB6,0xE5,0xFF,0x01};
//const uint8_t spMIG[] PROGMEM = {0x2A,0x95,0xCA,0x3B,0xD3,0xD5,0xB8,0x59,0x6B,0xAD,0x0A,0x75,0x13,0xA6,0xA8,0x28,0xAA,0xCC,0xE9,0x18,0xB3,0x52,0x73,0x97,0xB4,0xAB,0x1F,0x36,0x95,0x52,0xDF,0xAC,0x6A,0xD8,0x60,0x6E,0x7F,0xBC,0xCA,0xEE,0x9C,0xB4,0xE3,0xF6,0x2A,0xBA,0x35,0xF2,0x8E,0xCB,0xA3,0xE9,0xDA,0xD1,0xC6,0x1F,0xA5,0x6E,0x58,0x07,0x1D,0x5D,0x28,0x76,0xCF,0x55,0x6F,0xCC,0x12,0x3B,0x84,0xCC,0xB8,0x50,0xC5,0xE2,0xB0,0x34,0x63,0xCA,0x64,0xA7,0xAB,0xAB,0x44,0xB6,0x48,0x92,0x9E,0x29,0x13,0x71,0x7D,0xB5,0xDB,0x9B,0x08,0x92,0x8B,0x55,0x6E,0x6B,0x51,0x44,0x2D,0x66,0xFD,0x3F};
//const uint8_t spALERT[] PROGMEM = {0xAD,0xCD,0xBE,0x45,0x2D,0x5B,0x8F,0xB6,0xC8,0x72,0x57,0xDB,0xD4,0xEA,0x0E,0xBC,0x8D,0xAC,0x6B,0xA9,0x27,0x90,0x49,0x56,0x77,0xA5,0x19,0x50,0xC7,0x58,0xD2,0xAD,0xA6,0x88,0x2C,0x53,0xDE,0xB2,0xAA,0xA2,0x2A,0x2C,0xB8,0xCB,0xA8,0x73,0x68,0xB6,0x96,0xBC,0x63,0x48,0xA9,0x30,0x5B,0xF2,0x94,0x35,0x97,0x80,0x2E,0xDE,0x53,0x8E,0x1A,0x06,0x65,0x24,0x4F,0x7A,0x6A,0x6E,0x94,0xE1,0x3E,0xE9,0x6F,0x3E,0x89,0x2B,0xF2,0x23,0x70,0x8A,0x52,0x15,0xAA,0x01,0x00,0x0A,0x18,0xD2,0x8D,0x01,0x9B,0xAB,0x21,0x70,0x8A,0x52,0x15,0xAA,0xF1,0xFF};
//const uint8_t spZONE[] PROGMEM = {0x69,0x79,0x9C,0x4C,0xDC,0xB2,0x96,0xE5,0x39,0x4D,0x43,0xF6,0x6A,0x80,0x09,0x28,0x1C,0xB0,0x09,0x8A,0x01,0x1E,0x46,0x1D,0x53,0xD1,0x16,0x66,0xFE,0x66,0x4C,0xD9,0x44,0xA4,0xE9,0x9B,0xB1,0x24,0xDB,0x19,0x26,0x5B,0xDA,0x12,0xE3,0x84,0x99,0xBE,0x69,0x67,0x34,0x93,0xE1,0xB2,0xA6,0x9D,0xA1,0x54,0x18,0xC7,0xDC,0x76,0x85,0x54,0x69,0x12,0x4D,0xCB,0x15,0x4B,0xA5,0xB1,0x35,0x2D,0x77,0x08,0x59,0x2E,0xD1,0x38,0xDD,0x49,0x79,0xB5,0x6A,0x9D,0x74,0x57,0x2B,0x91,0x66,0x76,0xD3,0xD3,0xBC,0x58,0xAA,0xD9,0x49,0x4F,0x56,0x66,0xA5,0x16,0x27,0xBD,0xCD,0x8A,0x95,0x6A,0x9C,0xF4,0x56,0xCB,0x5E,0xA2,0x51,0xD2,0x9B,0x5D,0xB1,0x5B,0x2C,0x4E,0x5F,0x49,0x16,0xA6,0x55,0xFB,0xFF,0x01};
//const uint8_t spTERMINAL[] PROGMEM = {0x0E,0xD8,0x2E,0x35,0x00,0xCB,0x75,0x78,0x60,0x04,0xA9,0x18,0x65,0xF1,0xEA,0x95,0xE4,0x6E,0x9C,0x4B,0x79,0x56,0x9E,0xAA,0x73,0x1C,0x75,0x19,0x65,0xCC,0xA1,0xB5,0xB8,0xA6,0xD5,0xD9,0x9B,0x64,0x52,0xD4,0xD6,0x67,0x6B,0x92,0xCD,0x71,0xD7,0x90,0x4C,0x9B,0x8C,0xAD,0x19,0x53,0x56,0x6D,0xDA,0xF6,0xBA,0xAC,0x49,0x4B,0xB6,0x4A,0x9C,0xB1,0x66,0x6F,0x96,0x21,0xCD,0xC6,0x9E,0x79,0xA7,0x95,0x76,0x19,0x67,0x12,0x53,0x1E,0xDC,0xB5,0x9C,0x51,0x5E,0xAB,0x6B,0xD7,0xF4,0x07,0x7D,0xA5,0x6A,0xAD,0xC3,0x1F,0xCC,0xB7,0x88,0xB7,0x71,0x7F,0x10,0xB7,0x6A,0x9A,0x36,0xFC,0x89,0xF6,0xBA,0x4B,0x5A,0xF7,0x47,0x39,0x13,0xC1,0x79,0xCC,0x57,0x54,0x67,0x8A,0xB8,0xF9,0x7F,0x0E,0x98,0xA1,0xC4,0x01,0xDD,0x28,0x8F,0x74,0x84,0x64,0x73,0xAF,0x75,0xEA,0x1A,0x9D,0x2A,0x73,0xF1,0x69,0x9A,0x2F,0xB6,0xB2,0xC7,0xA7,0xAE,0xBA,0x38,0xDB,0x6F,0x9F,0x2A,0xD9,0x92,0x8E,0x9A,0xDA,0xCA,0x66,0x29,0x5B,0x4A,0x95,0x6B,0x12,0x97,0x68,0xD1,0x5A,0x06,0x78,0xC6,0x55,0x01,0x3F,0xA5,0x18,0xE0,0xB7,0xD2,0x51,0x26,0x35,0x1E,0xAA,0x8B,0x67,0x39,0xAA,0xCC,0xAF,0x44,0xB5,0xCB,0xA8,0x0B,0x99,0x09,0x96,0x2C,0xAD,0xC9,0x64,0x26,0x99,0xBB,0xB4,0x36,0x91,0x9E,0x22,0xCE,0x9A,0xBA,0xC4,0xAA,0x1B,0x2C,0x4B,0xEA,0x0B,0x8D,0x0C,0x23,0xB7,0xFF,0x0F};
//const uint8_t spRADIOS[] PROGMEM = {0xA1,0x77,0x8D,0xAD,0x43,0xEC,0xC5,0x3E,0x75,0xA1,0x53,0xA4,0x9B,0xFD,0x55,0x56,0x1F,0xAC,0x2D,0x5B,0x56,0xD9,0x42,0x90,0xB6,0x2D,0x5E,0x65,0x8F,0x8E,0x52,0xFE,0x78,0x54,0x2D,0x08,0x6B,0xE4,0x66,0x33,0x5A,0xE9,0x9E,0xE9,0x31,0xDA,0xB2,0x4D,0x32,0x7A,0xB4,0x19,0x63,0xB7,0x8A,0xDA,0xBD,0xB8,0x8D,0xDD,0x13,0x59,0xD7,0xEC,0x31,0xF7,0x20,0xA8,0x9D,0x8F,0xC7,0xDA,0x9C,0x90,0x8D,0xBF,0x1A,0x67,0xD3,0xA1,0xD4,0xB2,0xA5,0x9D,0xC5,0xA5,0x6A,0xF2,0xEF,0xF6,0x66,0xD5,0xC1,0xC3,0x6B,0xD2,0x97,0x54,0xA7,0x0E,0xEF,0x49,0x5F,0xB4,0x15,0x99,0xB4,0x3B,0xFC,0x31,0xA7,0xBB,0xCA,0x6A,0xF7,0xC7,0x1C,0x69,0x62,0xAB,0xCD,0x9F,0x52,0x84,0x8A,0xAE,0x36,0x7F,0xF2,0xE6,0xAA,0xBE,0xD9,0xFC,0x31,0x06,0x7A,0xC4,0xD2,0xF0,0x17,0x55,0xC6,0x6A,0x59,0xD3,0xF7,0x9B,0xA5,0xA9,0x49,0x0D,0xFB,0xF7,0x11,0x26,0xCC,0x4C,0x01,0xDF,0x23,0xFD,0x3F};
//const uint8_t spSPEED[] PROGMEM = {0x0C,0x78,0xC6,0x95,0x01,0x3F,0xA5,0x28,0xE0,0xB7,0x52,0x0B,0x04,0xE0,0xB7,0x54,0x04,0x4E,0x51,0xAA,0x42,0x35,0x00,0x0C,0x50,0x94,0x73,0x4B,0x7B,0x30,0xA6,0x90,0x35,0x23,0x9B,0xC9,0x09,0xD3,0xD6,0x8C,0x72,0x78,0x45,0xDE,0x5A,0xDC,0xDA,0x11,0x04,0x74,0xFA,0x51,0xEB,0x67,0x30,0xC0,0xA9,0xC5,0x6D,0x99,0xDE,0x80,0xA6,0x16,0xB7,0x6D,0x6A,0x41,0xD9,0x9C,0x54,0xF6,0x26,0x84,0x7C,0x73,0x91,0x3A,0x22,0xF1,0xA8,0xB2,0x48,0xEC,0xF4,0x34,0x22,0x32,0x6D,0x89,0x2B,0x92,0xB4,0x0C,0xAF,0x55,0xAE,0x69,0xDA,0x48,0x25,0x2D,0x03,0x0A,0x0C,0x4B,0x4F,0xCF,0x6C,0x2A,0xB9,0xFA,0xFF,0x01};
//const uint8_t spKNOTS[] PROGMEM = {0x6E,0x4A,0x92,0xBA,0x45,0x1D,0xA7,0x39,0x4B,0xEA,0x52,0x4D,0x92,0xA6,0xAA,0xB1,0xDD,0xCC,0xC9,0x98,0xAA,0x95,0x52,0xB5,0xA6,0x6B,0xCC,0x7A,0x9C,0xDB,0x17,0xAF,0xA1,0xF2,0x6D,0x6E,0x6B,0xB3,0xA6,0x22,0xB7,0x68,0xAC,0xCD,0x9A,0xB3,0xDE,0x94,0xB6,0x25,0xEB,0x28,0x62,0x8B,0xDB,0x36,0x8F,0xB3,0x98,0x75,0x6D,0x5D,0xDD,0xAE,0x12,0x56,0x3C,0xEC,0x95,0xBB,0xCB,0x8C,0x30,0xCE,0xC6,0x08,0x9C,0xA2,0x54,0x85,0x6A,0x00,0x10,0x60,0x50,0x31,0x06,0xFC,0xA0,0x68,0x80,0x67,0x5C,0x15,0xF0,0x53,0x0A,0x03,0x7E,0x2B,0xE5,0xC0,0xFF,0x03};
//const uint8_t spEXPECT[] PROGMEM = {0x6B,0xE8,0xAA,0xD5,0x53,0x36,0xAF,0xA1,0xAB,0x16,0x6B,0x5D,0xB5,0xFA,0x66,0x0A,0x73,0x7D,0x25,0x03,0x72,0x00,0x45,0x40,0x96,0x4E,0x06,0x78,0xC6,0x55,0x01,0x3F,0xA5,0x18,0xE0,0xB7,0x52,0x0B,0x20,0x70,0x8A,0x52,0x15,0xAA,0x01,0x0E,0xC8,0x26,0x65,0xE5,0xC5,0x87,0x5A,0xD8,0xEA,0x95,0x57,0x17,0xE2,0xE1,0x4F,0x56,0x56,0x5D,0x4A,0x64,0x2C,0x5E,0x59,0x0D,0x2A,0xE3,0x35,0x6B,0x64,0xAD,0x08,0x8D,0x55,0xA5,0x54,0x74,0x13,0xA4,0x11,0xAE,0x11,0x38,0x45,0xA9,0x0A,0xD5,0x00,0x00,0x50,0xC0,0x90,0x6E,0x02,0xD8,0x5C,0x0D,0x81,0x53,0x94,0xAA,0x50,0x8D,0xFF,0x07};
//const uint8_t spACTION[] PROGMEM = {0x63,0x6C,0x39,0x25,0xC3,0xE7,0x8C,0xAE,0xD5,0xF0,0x30,0x9F,0xB3,0x9A,0x5A,0x2C,0xC2,0x63,0xEA,0xAA,0x5B,0x49,0x8B,0xD0,0x39,0xAB,0xAA,0x55,0xB5,0x3C,0xA6,0x08,0x20,0x18,0x61,0x04,0x4E,0x51,0xAA,0x42,0x35,0xC0,0x00,0x2D,0x44,0x24,0x60,0x97,0x9E,0x02,0xCC,0x34,0x5B,0x80,0x95,0xA6,0x46,0x3E,0x92,0x33,0xBB,0x74,0x5E,0x79,0x77,0x26,0x9C,0xBA,0x65,0x55,0x4D,0xA9,0x5A,0xF9,0xAA,0x56,0x36,0x0B,0x15,0x6E,0x71,0x47,0xD1,0x2D,0x46,0xBA,0xDA,0x1D,0x45,0xB3,0x58,0xEE,0xE6,0x66,0x54,0x55,0x9A,0x65,0xC4,0xAC,0xFF,0x07};
//const uint8_t spRADIAL[] PROGMEM = {0x6A,0x66,0x69,0xCC,0x3C,0xED,0x84,0xD9,0x36,0xCA,0x4C,0xF1,0x3A,0xC6,0xD4,0x29,0x34,0x2C,0xDB,0x6A,0x4B,0x09,0x53,0x97,0xAE,0xAB,0xEA,0xAE,0x85,0x93,0xD7,0xAC,0xA2,0x97,0x64,0x51,0x7D,0x32,0xB2,0x9E,0x84,0xD5,0xEC,0x71,0xA8,0x32,0x65,0xB3,0xAA,0x44,0xAB,0x98,0xCE,0x91,0x23,0x96,0xAC,0x6A,0x04,0x47,0xAE,0x5C,0xB2,0xEA,0x11,0x1D,0xA9,0x62,0xCD,0x6A,0x7A,0x54,0x94,0xF2,0x35,0xAB,0xAD,0x32,0x54,0xCA,0xBB,0xAC,0x3E,0xC9,0x32,0x4F,0xDE,0xBC,0xC6,0x24,0xD7,0xCD,0xB9,0xCF,0x1E,0xDB,0x10,0xC5,0x86,0x07,0xE5,0x09,0x83,0x73,0xEB,0xAE,0xB4,0xE9,0xFF,0x01};
//const uint8_t spPOWER[] PROGMEM = {0x0A,0x88,0x22,0xDC,0x00,0x45,0x57,0x8C,0xAA,0xE9,0x88,0x4A,0x4A,0xB4,0x8A,0xEC,0x3A,0xD3,0x79,0xF1,0xCA,0x93,0x5F,0xF7,0xD4,0xC7,0x2B,0x4B,0x6E,0x33,0x82,0x17,0xAF,0x2C,0xA4,0x8D,0x70,0x5A,0xDD,0x32,0x5F,0xD7,0x3D,0x70,0xF3,0x28,0x42,0x3A,0xB7,0xC6,0xDE,0xA3,0x0A,0x61,0x55,0x97,0xFA,0xAC,0x31,0x86,0xA2,0x6C,0xF1,0xB2,0x8E,0x14,0x86,0x7D,0xD8,0x6F,0x3B,0x73,0x69,0xB4,0xE5,0xDC,0xF5,0x29,0x6F,0xF1,0x83,0x74,0xEE,0x37,0xBC,0x35,0x2E,0xCA,0xBA,0xEE,0xF8,0xFD,0x3F};
//const uint8_t spGAS[] PROGMEM = {0x01,0x28,0xD6,0xC4,0x00,0x39,0x08,0x8D,0xAA,0x44,0x97,0xD2,0x98,0xBC,0xBA,0x12,0x43,0x22,0x7D,0xF6,0x9A,0xAA,0x2D,0xD3,0xB6,0xC5,0x6B,0xAD,0xAE,0xCC,0xCA,0x56,0xAF,0xAD,0xDA,0x32,0x2F,0x7B,0xBD,0x8E,0xEA,0xCB,0xAC,0x6C,0xF1,0x38,0xAA,0x2F,0x8D,0xF4,0xC7,0xED,0xAE,0x3E,0xAD,0xD4,0x67,0xF7,0x3B,0xBD,0xB5,0x58,0x99,0x74,0x13,0xF3,0x95,0x6D,0x21,0x92,0xB1,0x19,0x50,0x85,0x0B,0x03,0x9A,0x4F,0x21,0x40,0x2B,0x6D,0x02,0x68,0x3A,0xED,0xFF,0x01};
//const uint8_t spINFORMATION[] PROGMEM = {0xAE,0xE8,0x39,0x98,0xBC,0xD6,0x8C,0xA2,0x19,0xE5,0x98,0x98,0xB4,0x8A,0x6E,0x55,0xBC,0xA3,0xD6,0x2A,0x9B,0x36,0xF5,0xF2,0x59,0xAB,0x6C,0x96,0x2A,0x5C,0xED,0x8C,0x2A,0x2B,0xAD,0x10,0x8E,0x93,0xAA,0x6C,0xC5,0x95,0xB2,0xA1,0xEB,0x96,0x49,0x33,0x33,0xC7,0xA9,0x9F,0x2E,0x33,0x42,0x14,0x3B,0xA0,0xB9,0xF6,0x51,0x26,0x57,0x6A,0x4D,0x59,0x46,0x97,0x5C,0xA9,0x37,0x6C,0x49,0x7D,0xB0,0xEA,0x15,0x54,0xB7,0xF4,0xC9,0x4A,0x94,0x52,0xBD,0xD5,0x14,0x9D,0xA6,0xAD,0xAB,0x57,0xDD,0x54,0xA8,0x8D,0x6F,0x5E,0x55,0x77,0xCE,0xD6,0xBE,0x6A,0x15,0x3D,0x28,0x5B,0xE5,0xC2,0x56,0x8E,0xAA,0xCC,0xE6,0xAD,0x13,0x30,0x72,0x5B,0x02,0x66,0xE9,0x4E,0xC0,0x4A,0x1B,0x09,0xE8,0xA5,0x7D,0x15,0x2D,0xAA,0x72,0xD8,0xE6,0x55,0xB7,0xA0,0x26,0xE1,0xAB,0x5B,0x53,0x0D,0x76,0xAA,0xC4,0x29,0x75,0x35,0x38,0x66,0xE2,0x64,0xD4,0x55,0x73,0xA6,0x48,0x9C,0x51,0x17,0x6D,0x6E,0x1E,0x8D,0xFE,0x1F};
//const uint8_t spTRUE[] PROGMEM = {0x06,0xE8,0x36,0xB4,0x00,0x53,0xB7,0x25,0xA0,0xDB,0xF5,0x00,0x94,0x54,0xDE,0x8A,0x58,0x54,0x43,0x2C,0x6B,0x2B,0x63,0x94,0x32,0x95,0xE6,0xAD,0x4C,0xC6,0xC2,0x82,0xDA,0xB7,0xA2,0x10,0x2F,0x69,0xCE,0x9E,0x8A,0x4C,0xA2,0xA4,0xB0,0x6B,0xCA,0x13,0x89,0xB2,0x86,0x2E,0x21,0x0F,0x2C,0xCB,0x13,0xB6,0x84,0xCC,0xAB,0x0A,0x75,0x7E,0x12,0x32,0xAF,0xD2,0x2C,0xBC,0xCD,0xFF,0x03};
//const uint8_t spPRESSURE[] PROGMEM = {0x08,0x88,0x44,0xC5,0x00,0xC5,0xB9,0x1A,0xA0,0x64,0xB3,0xD1,0xA5,0x2C,0xA5,0xC5,0x6B,0x56,0x97,0xB3,0xBA,0xA7,0x6E,0x59,0x63,0xC9,0xAE,0x11,0xBA,0x65,0x2D,0x25,0x99,0x5A,0xDA,0xEA,0xB6,0x36,0xEB,0x2A,0xE1,0x29,0x13,0xB0,0xAC,0x6B,0x02,0x66,0xD9,0x4C,0xC0,0xCC,0xDB,0x0E,0x68,0x41,0xA9,0x4D,0xC5,0x27,0x49,0x7B,0xB6,0xB2,0xD6,0x34,0x8C,0xAD,0xFE,0xCB,0x51,0x8E,0xB3,0x15,0x75,0x2D,0x57,0x1E,0x4A,0xBE,0xDC,0x25,0xDD,0xB9,0x09,0xC5,0x4A,0x96,0xF0,0xE4,0xC3,0x9C,0x25,0x5D,0xDC,0x53,0x9E,0x72,0x25,0xA7,0x71,0x6F,0x79,0xA9,0x69,0xAC,0xF4,0xFF,0x01};
//const uint8_t spCHECK[] PROGMEM = {0x0C,0xD8,0x39,0xC4,0x01,0xBB,0xA6,0x04,0x60,0xB6,0x90,0x04,0x8C,0x54,0xBE,0x8A,0x9A,0x5D,0x3D,0x7D,0xCD,0x2E,0x56,0xD1,0x7C,0x49,0x94,0xAF,0x5E,0x79,0x2B,0xC5,0xA1,0xB6,0x18,0x81,0x53,0x94,0xAA,0x50,0x0D,0x00,0x06,0xD4,0x39,0xC4,0x80,0xBA,0x8C,0x11,0x10,0x1D,0xF1,0xFF,0x03};
//const uint8_t spDECREASE[] PROGMEM = {0x0C,0x28,0x30,0x6C,0x0D,0x5B,0x97,0xB2,0x88,0xBF,0xD3,0x4D,0x93,0x4C,0x6E,0x5B,0x56,0x3F,0x42,0x21,0xA6,0x6F,0x6E,0xFD,0xC8,0x09,0x9C,0xB6,0x19,0x81,0x53,0x94,0xAA,0x50,0x0D,0x50,0x40,0x6A,0x2D,0x0A,0xC8,0xB1,0x42,0x01,0xA9,0x96,0x8F,0x22,0x17,0x4E,0x33,0x4D,0xB7,0xCA,0x9A,0xC4,0xCC,0xA5,0xEB,0x28,0x9A,0x73,0xD2,0xD2,0xAD,0x2D,0x1D,0x29,0x80,0xD3,0x1E,0xB7,0xB4,0x19,0xC6,0xE8,0x5A,0xDC,0xD2,0x2A,0x85,0x32,0x6A,0x95,0x02,0x9E,0x71,0x55,0xC0,0x4F,0x29,0x06,0xF8,0xAD,0xD4,0x02,0x0C,0xF8,0x2D,0x95,0x01,0xBF,0x94,0x31,0xE0,0xE7,0xB2,0xFF,0x07};
//const uint8_t spADVISE[] PROGMEM = {0x63,0xEC,0xBA,0x55,0xCB,0xD7,0xAC,0xB1,0x9B,0x56,0x75,0x5B,0xB3,0xC6,0x66,0x43,0xC2,0x6D,0xB5,0x98,0xBC,0x55,0x71,0xEF,0x99,0x6A,0xD6,0x22,0x23,0xC3,0x6A,0xAA,0x25,0x90,0x34,0x4F,0x6B,0x2C,0x16,0xCB,0xD3,0x35,0x3D,0x49,0x38,0xBA,0x0A,0x53,0x51,0xDB,0xAB,0x4F,0x66,0xC2,0x9C,0x37,0xAD,0xAE,0x88,0x6D,0x0B,0xE9,0xB3,0xBA,0x22,0xB6,0x3C,0x64,0xCB,0xEA,0x2A,0xDF,0xD2,0xB4,0x2D,0xAB,0x6D,0x62,0xD3,0x52,0xB7,0xAC,0xA6,0xF3,0x75,0x2F,0xD9,0xBC,0x9A,0x21,0xD6,0xBC,0x64,0xF5,0xAA,0xBB,0x1D,0x0E,0xB7,0xD7,0xAB,0x6A,0xA6,0xA8,0x3C,0x5F,0xAD,0xAA,0xCB,0xC2,0xB2,0x9A,0xDD,0x9A,0x2A,0x12,0x93,0x67,0x72,0xEB,0xBE,0x62,0x37,0x8A,0x2C,0x0A,0x78,0xC6,0x55,0x01,0x3F,0xA5,0x18,0xE0,0xB7,0xD2,0xFF,0x07};
//const uint8_t spYOU[] PROGMEM = {0xA9,0x2A,0x42,0x38,0xBA,0x63,0xA6,0xAE,0x0B,0x21,0x8D,0x69,0x98,0xFA,0x29,0x15,0x25,0x6A,0x56,0xE9,0xBB,0x53,0xE4,0xCA,0xC5,0xA3,0xED,0xCA,0x99,0x5A,0xDB,0xB6,0xB6,0x50,0x77,0x2D,0xEE,0x1A,0xBA,0x84,0xA2,0x24,0xA9,0xAB,0xEB,0x03,0xED,0xD4,0xA4,0xD5,0x6E,0x12,0xAA,0xB2,0x9C,0x13,0xFD,0x3F};
//const uint8_t spHAVE[] PROGMEM = {0x08,0x48,0xCC,0x0C,0x03,0x2B,0x6B,0xD9,0x34,0x34,0xA7,0xAC,0xAA,0x25,0xD7,0xB0,0x98,0xB3,0xAA,0x96,0x5C,0x23,0x7C,0xCE,0xAA,0x6A,0x72,0x4D,0x8B,0x39,0xAB,0xAD,0xD1,0xB5,0x34,0xA7,0xAC,0xBE,0xC6,0xD4,0xD2,0x98,0xBC,0xA6,0x1A,0x53,0x53,0x62,0xF2,0x58,0x4B,0x74,0x2B,0x8D,0xC9,0xE3,0x28,0xD1,0x2D,0xCC,0x66,0x8F,0xB3,0xE8,0xD2,0x28,0x5B,0x34,0xCE,0x62,0x53,0x23,0x65,0x31,0x02,0x82,0xD5,0x20,0x40,0x75,0xA9,0x08,0xA8,0x36,0xED,0xFF,0x01};
//const uint8_t spERROR2[] PROGMEM = {0x6D,0x6C,0x6E,0x89,0x5B,0x36,0x8F,0xA9,0x9B,0x11,0x5A,0xE9,0x33,0xA7,0x31,0x17,0xB7,0x4A,0x47,0xFD,0xC6,0x92,0x9A,0x8B,0x2F,0x65,0x4B,0x6B,0x1C,0xE4,0xD5,0xD8,0x2D,0xAF,0x65,0x8D,0x83,0xAD,0x9A,0xB2,0x95,0x23,0x76,0x93,0x58,0xCA,0xD7,0xCE,0xEC,0x57,0xF8,0xD8,0x5B,0x3A,0x8B,0x3D,0xC5,0xE7,0x7C,0xE9,0xCD,0xBD,0x30,0x86,0xDA,0x86,0x2F,0x97,0x82,0x38,0xEC,0x13,0xFE,0xE4,0x07,0xED,0x35,0x4B,0xF8,0x73,0x4E,0xEC,0xD2,0x3C,0xEE,0x2F,0xCB,0xB9,0x9D,0x3B,0xFF,0x3F};
//const uint8_t spALL[] PROGMEM = {0x0A,0x48,0x71,0xA9,0xE4,0x45,0x9F,0x9B,0x99,0xEB,0x56,0x04,0x3F,0x6E,0xA6,0xBD,0x5A,0x15,0x7D,0x97,0x1B,0x6F,0x69,0x55,0xB4,0xD3,0xEE,0xB4,0xA7,0x55,0xD1,0x5C,0x8B,0xCB,0xDE,0x56,0x06,0x77,0x2D,0xA6,0x7B,0x5A,0x19,0xED,0x97,0x98,0x6D,0x69,0x45,0xB4,0x57,0xA6,0xB6,0xB9,0x15,0x51,0x7D,0x9B,0x68,0x97,0x52,0x04,0xDF,0x63,0xE8,0x5D,0x4B,0x11,0xF5,0x76,0x83,0xA6,0x2D,0x55,0x14,0x5F,0xCE,0xD6,0x39,0xD5,0xC1,0x7D,0x38,0x67,0xA7,0xFF,0x07};
//const uint8_t spLONG[] PROGMEM = {0x6C,0xB1,0xAE,0x5D,0x4D,0x93,0x9A,0xCB,0xB9,0x14,0x4F,0xB7,0x2D,0x4E,0x5B,0x4C,0x22,0x9D,0xAD,0xDB,0x5C,0xA3,0x28,0x57,0x77,0x6D,0xF5,0xC9,0xD3,0x42,0xD2,0xAE,0x29,0x98,0xA9,0x08,0xCA,0x72,0x86,0x68,0xB7,0x23,0xA8,0xCB,0xE9,0xA2,0xBD,0x36,0x97,0x2C,0xAB,0x0E,0xE1,0x52,0x43,0x5B,0xAF,0x22,0xD4,0x31,0x8B,0x58,0xB4,0xB2,0x58,0xDB,0xDC,0xB2,0xF1,0x48,0xB3,0x6C,0x5F,0x0A,0x25,0x2D,0x2D,0x5A,0xAB,0xD9,0x54,0x8F,0xAC,0x28,0xCE,0x92,0x54,0x34,0xF2,0xEA,0xC4,0x9B,0xCB,0xF2,0xFF,0x03};
//const uint8_t spNO[] PROGMEM = {0x62,0xF2,0x5C,0x72,0x4A,0x62,0x9B,0x35,0x70,0xCE,0x49,0xA9,0xE5,0xD6,0xC8,0x39,0x27,0x65,0x76,0x58,0x8A,0x20,0xEF,0xE4,0x39,0x63,0xAE,0x4A,0xD4,0x43,0x66,0xAF,0x3E,0x07,0x77,0xF1,0x78,0xB3,0xDA,0x6C,0x23,0x52,0xFC,0xCD,0xAA,0xB2,0xA9,0x28,0xA1,0x2F,0xAB,0x88,0x62,0xB2,0x9C,0xBA,0x8C,0x2C,0xE8,0xF7,0x60,0xEA,0xD2,0x52,0x6B,0xCF,0x93,0xA5,0x53,0x49,0x5C,0x98,0x48,0x90,0x4D,0x29,0x31,0x7E,0x23,0x48,0x36,0x85,0xCC,0x9A,0x89,0x24,0xEE,0xFC,0xFF};
//const uint8_t spIMMEDIATELY[] PROGMEM = {0xAE,0xEC,0x81,0xD9,0xA2,0x6A,0xB7,0xBE,0x2B,0x25,0xEB,0x9C,0xBD,0xBA,0xA6,0x95,0xB5,0x7D,0x71,0xE9,0x92,0x64,0xEF,0x92,0x24,0xA5,0x2B,0x8A,0xAC,0x4B,0x93,0xB4,0xAE,0x1A,0xD2,0x4A,0x4D,0xD2,0xBA,0x22,0x59,0xAB,0xD4,0x4D,0x69,0x93,0x64,0xEF,0x10,0xB7,0xAB,0x1A,0x29,0x98,0x83,0x57,0xAF,0x72,0xA6,0x64,0x0C,0x5D,0xB3,0xF2,0x99,0x8A,0xD1,0x74,0x4D,0xC9,0x2B,0x15,0x89,0xF6,0xDA,0xA9,0x29,0xC2,0xD0,0x2A,0x1B,0x8F,0x6A,0x7A,0x07,0xCE,0x58,0xBC,0xEA,0xE9,0x1C,0xA8,0x73,0xF1,0x18,0x86,0x73,0xE0,0xC9,0x5B,0x6B,0x1C,0xDA,0x91,0x27,0x1E,0xAF,0xA5,0xAB,0x20,0x6D,0x7F,0x85,0xC0,0x29,0x4A,0x55,0xA8,0x06,0x10,0xE0,0x78,0x61,0x06,0x34,0xA6,0x52,0xD6,0x8D,0x79,0x93,0xB9,0xCB,0xD8,0x2F,0xC7,0x69,0xA6,0x36,0x6B,0x6F,0x34,0xD3,0x42,0xF3,0xAD,0x7D,0x89,0x0A,0x4A,0xEB,0xBA,0xAE,0x29,0xDB,0x30,0x6D,0xCF,0xB8,0x87,0x4D,0xE6,0xB4,0xCD,0xE5,0xEE,0xD1,0x51,0x32,0x5F,0xA7,0xA7,0x67,0x25,0xD5,0x6E,0x6C,0xDE,0xDE,0x84,0x4C,0x73,0xF6,0xFF,0x03};
//const uint8_t spFINAL[] PROGMEM = {0x08,0x48,0x4C,0x45,0x00,0x43,0x87,0x0A,0xA0,0xBB,0x0A,0x06,0x74,0x37,0xA9,0x80,0x21,0xC3,0x56,0x15,0x7D,0x67,0x38,0x2F,0x5E,0x55,0x56,0x93,0x9E,0xBC,0x79,0x55,0xC5,0xB4,0x47,0xE8,0xE6,0x55,0x16,0x97,0x9A,0x65,0xAB,0x56,0x51,0x7C,0x48,0x75,0x2C,0x5E,0x45,0xF1,0x66,0x65,0x9D,0xA8,0x15,0x59,0x9B,0xB7,0xA4,0xAA,0x95,0x27,0xDB,0x56,0x61,0x69,0x56,0x9E,0xCC,0x86,0x9B,0x74,0x1E,0x59,0xC1,0x33,0xA6,0x92,0x75,0x64,0x15,0xD5,0x84,0x72,0xDA,0x96,0x65,0x12,0xB5,0xCC,0x6D,0x4B,0xD1,0x40,0xB6,0xA9,0xB6,0x55,0x9D,0xB2,0x25,0x16,0x69,0xF7,0xFF,0x01};
//const uint8_t spPLEASE[] PROGMEM = {0x02,0x28,0x92,0xAD,0x95,0x45,0x6A,0xBB,0xA8,0xDB,0x51,0x15,0x16,0x5D,0x4C,0x6B,0x56,0xB5,0x84,0xB4,0x39,0x75,0x5D,0x45,0xD7,0x61,0xEC,0xBC,0x66,0x65,0xD3,0x85,0x60,0xE8,0x9A,0x95,0x2E,0xEB,0x0C,0x1D,0x4B,0x46,0x36,0x8C,0x22,0x77,0xBE,0x19,0x59,0x57,0x4A,0x1A,0xFE,0x66,0xE4,0x5D,0xA9,0xA8,0xE9,0xE6,0x51,0xFE,0x10,0x22,0x2C,0x4E,0x0D,0xF0,0x8C,0xAB,0x02,0x7E,0x4A,0xF9,0x7F};
//const uint8_t spSTART[] PROGMEM = {0x0C,0x78,0xC6,0x95,0x01,0x3F,0xA5,0x28,0xE0,0xB7,0x52,0x0B,0x04,0xE0,0xB7,0x54,0x04,0x4E,0x51,0xAA,0x42,0x35,0x40,0x01,0x43,0xBA,0x31,0x60,0x73,0xB5,0x55,0xE6,0x98,0xEA,0xA5,0x5B,0x46,0x9D,0x5D,0x6B,0x0E,0xF5,0x19,0x75,0xB1,0xC7,0xBE,0x94,0xBB,0x55,0xB9,0x1B,0x9F,0xD8,0xAD,0x5E,0xB5,0xB2,0x0C,0xA3,0x71,0xED,0x90,0x8A,0xBA,0xD8,0x55,0x22,0x09,0x02,0xA7,0x28,0x55,0xA1,0x1A,0x00,0x10,0x80,0x21,0xDD,0x14,0xB0,0xB9,0x1A,0x02,0xA7,0x28,0x55,0xA1,0x1A,0xFF,0x0F};
//const uint8_t spCOURSE[] PROGMEM = {0x02,0x08,0xCB,0x50,0x01,0xB1,0x17,0x95,0xDA,0xF7,0xF0,0x14,0xE9,0xD2,0x06,0x1F,0xD6,0x65,0xC8,0x4F,0x1B,0x43,0x38,0xE3,0x65,0xBF,0x65,0x89,0x6E,0xD9,0x0E,0x7B,0x97,0x35,0x85,0xC2,0x1A,0xD8,0x53,0xF6,0x5C,0x1D,0xB3,0xA4,0x6B,0x3A,0x72,0x11,0x0D,0xB3,0x2E,0x06,0x78,0xC6,0x55,0x01,0x3F,0xA5,0x28,0xE0,0xB7,0x52,0x0D,0x28,0xE0,0xB7,0x54,0x06,0xFC,0x52,0xC6,0x80,0x9F,0xCB,0xFE,0x1F};
//const uint8_t spRADAR[] PROGMEM = {0x22,0x0B,0x34,0xA2,0xC2,0x9C,0xB0,0x8C,0x77,0x97,0x08,0x77,0xE2,0x56,0xDD,0xD4,0xD2,0xDC,0x49,0x9A,0x43,0x27,0x0F,0x57,0x6F,0x6D,0xC8,0x9D,0x93,0x43,0xF3,0x8D,0xAA,0xFA,0x54,0x0B,0x5D,0xB3,0xAA,0xEE,0x9B,0xB9,0xE4,0xCD,0xC8,0xA6,0x6F,0xC2,0xD2,0x35,0x23,0x9D,0x71,0x08,0x5D,0xD6,0x8C,0xBC,0x67,0x61,0x31,0x5D,0x5D,0xDA,0x69,0x5C,0x48,0x2D,0xCD,0x68,0xAA,0x0B,0x76,0xF3,0x27,0xA3,0x2F,0xBA,0x24,0x4B,0xD6,0xB4,0x31,0x99,0x75,0x1F,0xDA,0xD3,0xC6,0xAC,0x2E,0x74,0xB1,0x4F,0x19,0x8B,0xB8,0xE0,0xA3,0x3E,0x65,0xCA,0x66,0x4D,0x8F,0xFA,0xA4,0x39,0xC7,0x96,0x58,0xCA,0x93,0x96,0x94,0x9A,0x63,0x39,0x5F,0x58,0x63,0x4F,0xCE,0xA5,0xBC,0xFF,0x0F};
//const uint8_t spPLAN[] PROGMEM = {0x02,0x48,0xC2,0x4B,0x01,0xC3,0xB3,0xA5,0xBA,0x09,0xCE,0x4C,0xB3,0x3D,0xEA,0x64,0xAA,0x42,0x78,0xED,0xAA,0xAB,0xE8,0xB0,0xE4,0xCF,0xAB,0x6B,0xBC,0xDC,0x46,0x57,0xAD,0xBE,0xAB,0x52,0x1B,0x9D,0xB5,0xA6,0xAE,0x4A,0x6C,0x6C,0xF6,0x5A,0x9B,0x2C,0xB1,0xB5,0x45,0x63,0xEB,0xA2,0x55,0xD7,0x16,0x8D,0xA3,0xEB,0x12,0x2F,0x5D,0xD4,0xAE,0x26,0x5B,0x6C,0x6C,0x51,0xBB,0x8A,0x29,0xC9,0xF0,0x59,0xE9,0x2A,0x56,0xCA,0xA9,0x1C,0xA7,0xBB,0x68,0xCE,0xA2,0x70,0x1A,0x9E,0x62,0x38,0x8B,0xDD,0x49,0x78,0x8A,0xD1,0x48,0x36,0x27,0xE1,0x6D,0x9E,0x43,0x2D,0x1C,0xFF,0x3F};
//const uint8_t spTARGET[] PROGMEM = {0x01,0xD8,0xD6,0x23,0x00,0xDD,0xB5,0x0B,0xC0,0x47,0xD6,0x51,0xA4,0x34,0x9C,0x8D,0x5D,0x56,0x9D,0xCA,0x48,0x0E,0x74,0x5E,0x6D,0xEE,0xC5,0x39,0xB4,0x79,0x75,0xA5,0x0E,0xDB,0xE2,0x96,0x35,0xD4,0x7C,0xC4,0x4B,0x7D,0xC2,0x58,0x6F,0x81,0x36,0xF5,0x62,0x6B,0x70,0x68,0x3F,0x6A,0xBB,0x1C,0xC3,0x24,0x8B,0xAB,0x92,0xB1,0x35,0x1F,0x60,0x6B,0xAB,0xC6,0x36,0x74,0x0B,0xB5,0x6E,0x6E,0x57,0x17,0xC5,0xD2,0xFE,0xCB,0xDD,0xC5,0x3A,0x45,0xD4,0x47,0x04,0x4E,0x51,0xAA,0x42,0x35,0x00,0x40,0x01,0x43,0xBA,0x31,0x60,0x73,0x35,0x04,0x4E,0x51,0xAA,0x42,0x35,0xFE,0x1F};
//const uint8_t spWINDOWS[] PROGMEM = {0x6A,0x50,0xC5,0xAC,0xDC,0x62,0x97,0xDE,0xDA,0x2A,0x77,0x4E,0xB3,0xAA,0x2C,0xD3,0x35,0x78,0xCB,0x2A,0xAB,0x76,0xF5,0xD0,0x27,0xAB,0xA8,0xC6,0xD5,0xCC,0x6E,0xB7,0xA2,0x19,0xC8,0x76,0x8B,0x3B,0x8A,0xAA,0x28,0xCA,0xCD,0x69,0xA9,0x8A,0xC4,0x6A,0x35,0xA7,0xA1,0xCE,0x02,0x27,0xCC,0x53,0x8D,0x61,0x38,0x73,0x16,0x4D,0xB3,0x86,0xAC,0x4A,0xCD,0xF3,0xD1,0x18,0xB3,0x69,0x31,0xF7,0x4F,0x63,0x49,0xBA,0x3C,0xDC,0x76,0x8D,0x2D,0x99,0x8C,0x32,0xD9,0xD4,0x8E,0xA8,0x3A,0xCA,0x64,0x4F,0x39,0x93,0xEE,0x08,0xE3,0xDE,0xE1,0x0E,0xB6,0xA2,0x45,0x76,0x87,0x37,0xC6,0x08,0x27,0x5F,0xE3,0xBE,0xE0,0x23,0xCC,0xB4,0x93,0xFB,0x83,0x09,0x2B,0xD3,0xD5,0xE6,0x8F,0x36,0x54,0xC3,0x57,0x87,0xEF,0x05,0xB5,0x61,0x72,0x92,0x7F,0x05,0xFC,0x56,0xAA,0x80,0x5F,0xDD,0x05,0xF0,0x53,0xFA,0xFF,0x03};
//const uint8_t spWATCH[] PROGMEM = {0x66,0xD5,0xEA,0x4B,0x5C,0x9C,0xA6,0xCD,0xEA,0x6F,0x72,0x73,0xDF,0xE6,0x60,0xBF,0xC8,0x23,0xFB,0x58,0xA2,0xBE,0x52,0x57,0x7F,0x6B,0x2D,0x72,0xCB,0x93,0xF3,0xAC,0xB3,0xA8,0x4D,0x0F,0xEE,0x83,0xC0,0x29,0x4A,0x55,0xA8,0x06,0x00,0x00,0x01,0xB6,0x17,0x33,0xC0,0xAE,0x13,0x16,0x70,0xC0,0xAA,0x17,0x01,0x98,0xB9,0xD5,0x00,0xB3,0xB4,0xFE,0x3F};
//const uint8_t spUSE[] PROGMEM = {0x69,0x1E,0x4C,0x44,0xBA,0x66,0x95,0x69,0x28,0x25,0xEE,0x5A,0xDC,0xC6,0x1E,0x04,0x25,0x73,0xF1,0x18,0x9A,0x13,0xB2,0xF4,0x55,0xA3,0xAB,0x5A,0x24,0x42,0x5F,0xB7,0xA6,0x08,0xD5,0x4C,0xFE,0x52,0xEA,0xC8,0xC3,0x3C,0xEC,0x73,0xAA,0xA2,0xD2,0x54,0xCB,0xCD,0x06,0x78,0xC6,0x55,0x01,0x3F,0xA5,0x18,0xE0,0xB7,0x52,0x0B,0x04,0xE0,0xB7,0x54,0x07,0xFC,0x52,0x66,0x80,0x9F,0xCB,0xFE,0x1F};
//const uint8_t spTURN[] PROGMEM = {0x09,0xD8,0x3E,0x2D,0x00,0x3D,0x8F,0x2B,0xA0,0x54,0xE3,0x56,0xA4,0xC1,0xD2,0xC5,0xAD,0x56,0x95,0xB7,0x51,0x15,0x75,0x19,0x55,0xDE,0x45,0x3E,0xD4,0x65,0x55,0x25,0x2F,0xF3,0x52,0x97,0x55,0xD5,0x38,0x2C,0xC3,0x59,0x57,0x55,0xB3,0x91,0x47,0x54,0x1B,0x65,0x51,0x62,0xA9,0x5A,0x75,0x94,0x55,0xB1,0x95,0x69,0xDC,0x5E,0xB6,0xB2,0x48,0x8E,0x52,0xB7,0xD3,0xAA,0xAA,0x55,0x32,0xD2,0xE6,0xFF,0x03};
//const uint8_t spTRAFFIC[] PROGMEM = {0x08,0x18,0x55,0xCD,0x01,0xD3,0xA9,0x05,0x60,0xE8,0x76,0x07,0x94,0x58,0xDE,0xB2,0x54,0xD5,0xAD,0xCC,0xCD,0xC8,0x73,0xD3,0xB0,0xE2,0x2D,0xA3,0xCA,0xD5,0xAD,0xDC,0x5E,0xAF,0xAA,0x9A,0x15,0x6F,0x59,0xBD,0xEA,0x12,0x52,0xCB,0x6D,0x36,0x02,0xAA,0x0C,0xE3,0x80,0x02,0xBA,0x09,0x2D,0x55,0xC9,0xEA,0x2E,0x55,0x65,0xCC,0x25,0x98,0x86,0xE5,0xEC,0xB1,0xD4,0xA0,0x92,0x56,0xAB,0xCA,0x56,0xA3,0x60,0x55,0xAE,0x44,0xE0,0x14,0xA5,0x2A,0x54,0x03,0x18,0xD0,0x52,0xB0,0x02,0x6A,0x08,0x52,0x40,0x0B,0x41,0x04,0x88,0xDA,0xF0,0xFF,0x01};
//const uint8_t spCHECK[] PROGMEM = {0x01,0xB8,0xD2,0xD4,0x03,0xAB,0xAE,0xD1,0xD5,0x2D,0x17,0xAF,0xA1,0xA9,0x12,0x6D,0x7B,0xBD,0xA6,0x6E,0x47,0xA5,0x6D,0xF5,0x9A,0xBB,0x6D,0xD5,0xB6,0x55,0x6B,0x1D,0xBA,0x55,0xDB,0x56,0x8D,0xAD,0xDB,0x16,0x1D,0x5B,0x34,0xAE,0xE6,0x82,0xA3,0x63,0x51,0xB8,0x6B,0x24,0x9B,0xEC,0xD2,0xE6,0xEE,0xC5,0xA0,0xDB,0x2B,0x22,0xB0,0xA8,0x52,0x15,0xAA,0x01,0xA0,0x80,0xDE,0x5C,0x19,0xD0,0xBC,0x08,0x03,0x5A,0x31,0x46,0x40,0x8D,0x2C,0xFF,0x0F};
//const uint8_t spSLOW[] PROGMEM = {0x0A,0xB8,0x9C,0xC4,0x00,0xBF,0x68,0x1A,0xE0,0x3F,0xF1,0x00,0xFC,0x24,0xE9,0x80,0x9F,0x2C,0x0D,0x70,0x84,0x47,0xA9,0x3A,0xD2,0x11,0x97,0x6C,0xA3,0xAA,0xC4,0xD6,0x8C,0xB3,0xAC,0x32,0xB3,0x1A,0x57,0xE9,0xB2,0xEA,0xCC,0x7B,0xC2,0xB8,0xEB,0xAA,0x93,0xE8,0x71,0x93,0x6E,0xAB,0x49,0xAA,0x3B,0x9D,0xFB,0xB5,0x36,0xA8,0xAD,0x50,0xE9,0xDB,0x86,0x60,0xA7,0x5C,0xB4,0x4B,0x1A,0x5D,0xAD,0x54,0xF6,0x5D,0xE9,0x36,0x3D,0x4A,0x28,0x17,0x87,0xCB,0xB4,0x0E,0x63,0xDD,0xED,0x6E,0x53,0x3A,0x5D,0xB8,0xB3,0x7B,0x6C,0x5A,0x77,0xE5,0x3E,0xEE,0xB3,0xAD,0xC5,0xD5,0xF6,0xFC,0x3F};
//const uint8_t spRELEASE[] PROGMEM = {0xA2,0x11,0xD5,0xAC,0x42,0xD5,0x99,0x45,0x16,0xB3,0x0A,0x75,0xEB,0x66,0x5F,0xC8,0xDB,0xDC,0x7E,0x19,0x4B,0xE6,0x42,0x2B,0x67,0xAB,0x6D,0x26,0x99,0xCA,0xBB,0xAC,0x66,0xB8,0x44,0x2A,0xDB,0x32,0xDA,0x16,0x0C,0xA4,0x6D,0xCD,0xE8,0x17,0xE5,0x50,0xF5,0x76,0xA3,0x5F,0x88,0x5B,0xA4,0x66,0xAF,0x7E,0x33,0x4D,0x66,0x4F,0xBB,0x9A,0xA6,0x43,0xD8,0xFD,0xF1,0xAA,0xBB,0x33,0x92,0xC8,0xD7,0x2B,0x9F,0xC1,0x91,0x22,0x17,0x8F,0xAC,0x3B,0x01,0x9F,0x9E,0x5D,0xD2,0x26,0x14,0xB3,0x72,0x71,0xC9,0x7F,0xAA,0x4C,0x44,0x25,0x0E,0xF8,0xC9,0xC2,0x01,0xBF,0xB8,0x3B,0xE0,0xA7,0x08,0x07,0xDC,0xEA,0xFE,0xFF};
//const uint8_t spKEY[] PROGMEM = {0x09,0xE8,0x4A,0x35,0x01,0x53,0x8B,0x04,0x60,0x15,0x97,0x92,0x76,0x47,0xAC,0x5D,0x93,0x47,0x36,0x93,0x22,0x65,0xAF,0x19,0xD9,0x2C,0x8A,0x14,0xBD,0x65,0xE5,0xB3,0x28,0x52,0xF5,0x92,0x95,0xCF,0xA8,0xC8,0xDD,0xB3,0x47,0xB1,0xB2,0x21,0x65,0x3F,0x6E,0xE5,0xCC,0x82,0x5C,0xF9,0x44,0x97,0xB9,0xFC,0x7F};
//const uint8_t spIGNITION[] PROGMEM = {0xAD,0x2F,0xDE,0x38,0xCB,0x7B,0x8F,0xA1,0xC5,0x04,0x6B,0xDB,0x3C,0x87,0x30,0x15,0xEE,0x90,0xCF,0x31,0xC3,0x14,0x0D,0xC5,0x5A,0x58,0x4E,0xCB,0x14,0xC2,0x96,0x95,0xD4,0x4D,0x4A,0xA6,0x7B,0x56,0xCC,0x30,0x25,0xA3,0xA3,0xE4,0xAA,0x5A,0xD7,0x0C,0x44,0x86,0xB9,0x59,0x75,0xB7,0x2E,0x1A,0x32,0x7B,0x15,0x43,0x85,0x4A,0xDB,0xA2,0x55,0x74,0x6F,0x62,0x1E,0xB3,0x5A,0x31,0xAC,0x31,0x9B,0x2D,0x1A,0xD5,0xCA,0xB3,0x9B,0x21,0x39,0x01,0x33,0x6D,0x27,0x60,0xA5,0xE9,0x00,0xF4,0xB6,0x39,0xDA,0x9A,0x58,0xCD,0x73,0xD5,0x68,0x6B,0x34,0x31,0x8F,0xCF,0xEB,0x18,0x26,0xD5,0x42,0xF7,0x8C,0xA3,0x7B,0xD6,0x74,0x89,0x9B,0xCE,0xEE,0x85,0x32,0x24,0x5A,0x3A,0xBB,0x15,0x29,0xD7,0x68,0xE1,0xE9,0x4E,0xB8,0x5C,0xA3,0x85,0xB7,0x5A,0xB1,0x64,0xAD,0xFB,0xFF};
//const uint8_t spDEGREE[] PROGMEM = {0x0C,0x28,0x30,0x2C,0x45,0x43,0x9A,0x72,0xD8,0xEB,0x9D,0xAD,0xBA,0x0B,0x67,0x6E,0x7F,0x3D,0x9A,0xA1,0x1D,0xB9,0xF5,0x0B,0x02,0xA7,0x28,0x55,0xA1,0x1A,0x10,0xD6,0x5C,0x3A,0x35,0x2C,0x66,0x1A,0xA2,0x75,0x73,0x33,0xA7,0xA9,0x0F,0x51,0xD2,0x54,0xDD,0xB6,0x3A,0x27,0x6A,0x4A,0xCB,0xB6,0xCA,0x92,0xC8,0x2C,0x6C,0xED,0x2A,0x7B,0x54,0xD4,0xF2,0xD7,0xA3,0x1A,0xDE,0x50,0x26,0x1E,0xB7,0x7A,0x04,0x05,0x99,0x7C,0xDC,0xEA,0x19,0x0D,0xA8,0xEB,0x76,0xAB,0x66,0x30,0xA0,0xAA,0x59,0xAD,0x1A,0x41,0x40,0xAA,0x67,0xA5,0xAA,0x79,0x14,0xAB,0x9E,0xFD,0xFF};
//const uint8_t spRAIN[] PROGMEM = {0xE1,0x48,0xA5,0xCB,0x42,0x6C,0xB7,0xB1,0xE6,0x60,0x33,0x57,0x32,0xDA,0x54,0x38,0x5C,0xC3,0xD9,0x68,0x72,0xE5,0x28,0xF3,0xE4,0xAB,0xCE,0x59,0x3D,0x23,0xBA,0x8E,0xAA,0x78,0xE7,0x6E,0x7F,0xBC,0xCA,0xEE,0x9D,0xA2,0xFD,0xD2,0x2A,0x86,0x33,0xCA,0xB5,0xD2,0xAB,0xE8,0x56,0xA9,0x56,0xAA,0x8C,0xB2,0x39,0x8C,0x8C,0x88,0x33,0xAA,0x6E,0x31,0x32,0xDC,0xC9,0x68,0xBA,0xC1,0x48,0x77,0x27,0xAD,0xED,0x4A,0x39,0xC3,0x6A,0xF7,0xE1,0xFF,0x01};
//const uint8_t spREPAIR[] PROGMEM = {0x62,0x14,0xCD,0xB8,0xBC,0xEC,0xBA,0xC9,0x35,0xB2,0xF4,0x54,0x96,0xA6,0x34,0xC9,0xC5,0xDB,0xDE,0x1A,0x6A,0x93,0x60,0xF1,0x6C,0x67,0xE8,0x3E,0x91,0xC3,0xB6,0x8C,0xA1,0x15,0x47,0x0E,0xDD,0x22,0x82,0xC0,0xDD,0x26,0xC5,0x09,0x02,0x12,0x33,0xC3,0x00,0x06,0x0C,0x50,0x9C,0x73,0xC9,0x6A,0x12,0x33,0xB5,0x59,0xAB,0x28,0x89,0x22,0xBC,0xAB,0x9C,0xA2,0xC5,0x62,0x0B,0xDD,0x72,0x8A,0x96,0x9A,0x35,0xE4,0xCB,0x29,0x5A,0x1E,0xD6,0x90,0x35,0xAB,0x6A,0xB9,0xD0,0x4A,0xBE,0x8C,0xA1,0xA5,0x42,0x1B,0xF9,0xD2,0xD6,0x1A,0x86,0x74,0x65,0xCB,0xD8,0x4B,0x5C,0x96,0xE5,0x2E,0xE3,0xA8,0x6E,0x85,0x8F,0xB6,0xB6,0xBB,0xA4,0x25,0x59,0xEE,0x52,0xEE,0xEA,0x8E,0xE9,0xB8,0xEB,0xFF,0x03};
//const uint8_t spCANCEL[] PROGMEM = {0x0E,0x98,0xC5,0x25,0x00,0xB3,0x94,0x38,0x60,0x64,0x96,0x93,0xB5,0x2A,0xEA,0xD6,0xB3,0x4F,0xD5,0xAA,0x6A,0x58,0x2D,0x39,0x75,0xCB,0x66,0x61,0xB5,0xF8,0x54,0xB5,0xA8,0xBB,0x6E,0xED,0x55,0xD5,0x90,0x5A,0xB4,0x71,0x5A,0xD5,0x0C,0x85,0x69,0x7A,0x2A,0x45,0xD5,0x98,0xA1,0xE9,0x3A,0x54,0x85,0x93,0x2D,0x45,0x93,0xD6,0x56,0xC9,0x6A,0xE2,0x76,0x0C,0xF0,0x6B,0xA9,0x07,0x02,0xF0,0x5B,0x4A,0x00,0x9E,0xF2,0x68,0x45,0x11,0xEE,0xA9,0xB2,0xA6,0xAD,0x51,0x4C,0x86,0xEA,0xE6,0x72,0x66,0xD6,0x9D,0xC6,0x59,0xD2,0x1F,0x65,0x77,0x2B,0x75,0x09,0xBF,0xD7,0xD3,0x21,0xD2,0x35,0xFC,0x51,0xD6,0xA4,0x71,0xD6,0xF0,0x47,0x99,0x93,0x86,0x6D,0xC2,0x9F,0x79,0x4D,0x3A,0x66,0x31,0x5F,0x51,0x5E,0xE9,0xDC,0xE4,0xFF,0x01};
//const uint8_t spVERIFY[] PROGMEM = {0xE6,0x68,0x52,0x8D,0x5D,0xDC,0x84,0x63,0xE4,0x09,0x57,0x51,0xD2,0xFA,0x6E,0x4D,0xC5,0xA5,0xCB,0x69,0x9B,0x77,0x55,0x97,0xCD,0xA7,0x6D,0xB6,0x54,0xC3,0xB6,0x9C,0xB6,0x04,0x37,0x77,0xCF,0x76,0xDA,0x5C,0xD5,0xDD,0x3D,0xDB,0xE8,0x52,0xE3,0x70,0x77,0x6F,0xAB,0xCF,0x55,0xD2,0x2C,0xBD,0x9D,0xA9,0xF8,0xD4,0x34,0xCB,0xBA,0xE6,0x12,0x5A,0xC2,0x65,0x73,0x1A,0x5B,0x2E,0x73,0xA5,0x25,0x0C,0x68,0xBA,0x94,0x01,0x43,0x97,0x09,0x60,0xB8,0x4A,0x03,0x14,0x2D,0x3E,0xDA,0x14,0xBC,0x82,0x7C,0xC9,0x5A,0x8A,0x9E,0x0C,0x97,0x2F,0x6B,0xED,0xAC,0xDB,0x52,0xB6,0xAC,0xBD,0xCA,0x4D,0x4F,0xD9,0xD2,0xAE,0xA2,0x36,0x3C,0xF5,0xF5,0x78,0xAA,0xEA,0xC8,0x94,0x35,0xED,0xEB,0xA2,0x3D,0x5A,0xD6,0x94,0xAF,0xE9,0xB6,0x0C,0xFE,0x52,0xFE,0x9A,0xD4,0xCA,0x7A,0x4A,0xFA,0x5B,0x74,0x4D,0xB7,0xC5,0xFF,0x0F};
//const uint8_t spREADY[] PROGMEM = {0x62,0x57,0x8D,0x2D,0xDD,0xD5,0xA5,0x3D,0x36,0x36,0x77,0x77,0x36,0x96,0xDC,0x38,0x25,0xCC,0xDB,0x19,0x4B,0xB0,0xD0,0xB0,0xAE,0xA7,0x6B,0xDE,0x35,0xCC,0xB6,0x9C,0xAA,0x05,0x57,0x67,0xDB,0x92,0xAA,0x6A,0xC8,0x82,0x7D,0x0B,0xEA,0x3C,0xB7,0xB0,0xAC,0x86,0x04,0xE8,0xC0,0xAD,0x8D,0x2D,0x88,0x98,0xF5,0x9D,0xB1,0x0C,0xEF,0x24,0xE1,0x6B,0xDA,0x3E,0x7D,0x12,0x86,0x7F,0x69,0xD7,0xF4,0x2D,0x10,0xB6,0xA5,0x5F,0xE5,0x99,0x21,0x11,0x2B,0x5E,0xD7,0xEF,0xFF,0x01};
//const uint8_t spUSE2[] PROGMEM = {0x6D,0x38,0x86,0x14,0x3C,0x57,0x8F,0x7E,0x07,0x53,0x60,0xDD,0x3A,0xAA,0xEE,0x84,0x28,0xF3,0xC9,0x28,0x5A,0x20,0x96,0xAC,0xC5,0x23,0xEB,0x59,0x51,0xCC,0xDE,0xAC,0xAC,0x7B,0x27,0x31,0xD9,0xB2,0x8A,0xA6,0x54,0x2C,0x64,0xCD,0x2E,0x4A,0x1D,0x99,0x7B,0x16,0x6D,0x4E,0x53,0x60,0xE9,0x55,0xD4,0x26,0xCC,0x5E,0x9B,0xA7,0xCA,0x96,0xB4,0x47,0x2D,0x99,0x6A,0x5B,0xD2,0x91,0x14,0x47,0xB8,0x6E,0x49,0x67,0x32,0x1C,0xAE,0xB5,0x24,0x5D,0x8D,0x9A,0x93,0x45,0xB7,0x74,0x3F,0x8B,0xA9,0x14,0x6B,0xCB,0xFD,0x14,0x87,0x88,0x7A,0x6B,0xD7,0xB7,0x9E,0xCA,0xA2,0xCE,0x00,0x1B,0x50,0x3A,0xE0,0x11,0x0E,0x03,0x3C,0x82,0xEA,0x80,0x2F,0x50,0xFE,0x1F};
//const uint8_t spOUT[] PROGMEM = {0x65,0x4A,0x6E,0xBC,0xD5,0x3B,0x8F,0xBE,0xA8,0xF5,0x72,0xED,0xBC,0x9A,0xAA,0x36,0x22,0x75,0xCB,0x6A,0x8B,0x9D,0x28,0xD3,0xCD,0xAB,0xCD,0x66,0xB2,0x5C,0x36,0xAF,0x3E,0xD9,0x8D,0x52,0xE9,0x3C,0xFA,0xE8,0x36,0x5A,0xB5,0xF7,0x68,0xA2,0x1D,0x4B,0xB5,0xDE,0xA6,0x4D,0xBC,0xD2,0x1D,0x3E,0x23,0x70,0x8A,0x52,0x15,0xAA,0x01,0x00,0x0E,0x98,0x42,0xDD,0x00,0xCF,0x57,0xFC,0x3F};
//const uint8_t spOTHER[] PROGMEM = {0x6D,0xCC,0xBE,0xB4,0xC2,0x57,0x8D,0xB1,0xD8,0xB1,0x74,0xDD,0xB4,0xBA,0x6C,0xC6,0xD3,0x6C,0xD5,0xAA,0xA3,0x1E,0x2F,0xF5,0xD9,0xAE,0x4A,0x32,0x35,0xC8,0x67,0x87,0xA1,0x88,0x94,0xE4,0x4C,0xDC,0x86,0xA2,0x43,0x52,0x7C,0xF6,0x18,0x72,0x34,0x71,0xF7,0x55,0x63,0x2C,0x31,0x30,0x4A,0xF6,0xB4,0xB5,0xA4,0x46,0x1D,0xEE,0x53,0xAE,0x9A,0x17,0x65,0xB0,0x6F,0xBA,0xCB,0x0C,0x88,0xA2,0x2E,0xE9,0x29,0xB3,0xD0,0x1A,0xFB,0xA4,0xA7,0xF4,0x01,0x6F,0xEA,0x13,0xDE,0x72,0x02,0x46,0x79,0x4F,0xF8,0xCA,0x52,0xAC,0xD2,0x76,0xFF,0x0F};
//const uint8_t spOIL[] PROGMEM = {0xA1,0x0C,0x61,0xBC,0x44,0x3A,0xA6,0xC5,0x95,0xB3,0x10,0xEB,0xD5,0x86,0x10,0x2E,0xCC,0x25,0xEF,0x6A,0xA3,0xDA,0xF4,0xE4,0xAC,0xAB,0xC9,0x7C,0xDC,0x9B,0xFB,0xAC,0xA6,0x88,0x56,0x1B,0xD9,0xB3,0xDA,0x2A,0x46,0x64,0xAD,0xCB,0x1A,0x2A,0x6B,0xF7,0x96,0x4D,0x6B,0xCC,0x6C,0xB2,0x5C,0xF2,0x8C,0x35,0xB1,0xED,0x52,0x49,0x5B,0xD6,0xC8,0x7B,0x52,0x38,0x6B,0x5A,0x23,0xAF,0x4E,0xE1,0xAE,0x69,0x4B,0x3C,0xBC,0xC9,0x5A,0xFF,0x3F};
//const uint8_t spOFF[] PROGMEM = {0x69,0x70,0xBB,0xCD,0x25,0x36,0xB5,0xCE,0xD7,0x0D,0x57,0xED,0x3C,0x3A,0x5F,0x2F,0xCD,0xB4,0xF3,0xE8,0x7D,0xBE,0x34,0xD3,0xCE,0x63,0x08,0xFE,0xD3,0xDC,0x32,0x8F,0x39,0xFA,0x0F,0x73,0xCF,0xD4,0x8E,0xE8,0x3E,0xCC,0xBC,0x77,0x99,0x63,0xB8,0x30,0xF3,0x4E,0xE9,0x8E,0x79,0xDC,0x25,0x76,0xFA,0x9B,0x00,0xC3,0x56,0x10,0x60,0xFA,0x0A,0x01,0x4C,0x97,0xAE,0x80,0x66,0xCB,0x08,0x30,0x54,0xFA,0xFF,0x03};
//const uint8_t spNEAR[] PROGMEM = {0xAE,0x4D,0x0A,0xD7,0xCD,0x1D,0x9B,0x36,0x48,0x5A,0x55,0x4F,0xAD,0xDA,0x24,0xF1,0xCC,0x24,0xB3,0xAB,0xBD,0x94,0x55,0xD7,0xD4,0xAD,0x2A,0x8A,0x2D,0x2A,0x4A,0x8D,0xAA,0x3B,0x65,0xEB,0x98,0xB4,0xEA,0x11,0x9C,0xB8,0xFD,0xD6,0xA8,0x7B,0x30,0x94,0xB1,0x47,0xAD,0xA9,0x51,0xD1,0x47,0x5F,0xB5,0xA6,0x64,0xC3,0x18,0xDE,0x54,0xEA,0x5C,0x1D,0xED,0xB8,0x77,0xA9,0x53,0x4D,0x94,0xA7,0x3C,0xA5,0x4A,0xB9,0x50,0x9F,0xF2,0x94,0x29,0xC5,0xC6,0x38,0xCA,0x93,0xCE,0xE8,0x17,0x7B,0xB8,0xE7,0xFF,0x03};
//const uint8_t spGREAT[] PROGMEM = {0x6E,0xF3,0x59,0xC2,0x46,0xD9,0xA9,0xCD,0x0C,0x95,0x0E,0x55,0x6E,0x36,0x3D,0x9D,0xAA,0x4C,0xAE,0xD9,0xF4,0x0C,0xCC,0x36,0x7B,0x6E,0xF5,0x8B,0xF4,0x4C,0xB2,0x95,0x29,0x76,0xCC,0xD2,0xF4,0xB6,0xA6,0x5C,0xC4,0xD3,0xAA,0xEF,0x9A,0xAA,0x2F,0x8C,0x8C,0x4D,0x6B,0x19,0x6E,0x48,0xD2,0x56,0xAD,0x7D,0xB8,0x42,0x4E,0x5F,0xDD,0xCE,0x6E,0x0C,0x7C,0x72,0x71,0x38,0x87,0x36,0xD0,0xCE,0xD9,0x6C,0x1B,0x5A,0xC9,0x22,0x12,0x23,0x70,0x8A,0x52,0x15,0xAA,0x01,0x00,0x0E,0x18,0xD2,0xCD,0x01,0x9B,0xAB,0x09,0xE0,0x98,0x2D,0x01,0x2C,0x15,0x86,0x80,0x1A,0x15,0xFE,0x1F};
//const uint8_t spMIXTURE[] PROGMEM = {0x61,0x8C,0x92,0x6B,0x4D,0xEA,0x94,0x31,0x0B,0xF6,0x29,0x49,0xDC,0x86,0x2A,0x44,0xB3,0x2D,0xCD,0xEA,0xAB,0x0A,0xD7,0xD0,0xDE,0xAB,0xEB,0x2A,0x55,0xD3,0x7B,0xAF,0xBE,0xDB,0x24,0x0F,0xDB,0x84,0xC0,0x29,0x4A,0x55,0xA8,0x06,0x04,0x60,0xEB,0xE9,0x00,0x7C,0x9B,0xED,0x80,0xDF,0x42,0x14,0xF0,0x7B,0x28,0x02,0xA7,0x28,0x55,0xA1,0x1A,0xA0,0x80,0xB3,0x3B,0x13,0xB0,0x82,0xE9,0xE8,0x7A,0x4C,0x26,0xB3,0xBC,0xA3,0xAB,0x59,0x58,0x4B,0xF7,0xB6,0x29,0x27,0xA1,0x2C,0xF9,0xDA,0xB6,0x5C,0x92,0x64,0xA9,0x6F,0x3B,0x73,0x57,0xCE,0xE6,0x3E,0xE9,0xCA,0xDD,0x31,0x86,0xFA,0x95,0x27,0x97,0x44,0x5F,0xEA,0x9F,0xFE,0xD4,0x94,0xAA,0xB9,0x5F,0xF8,0x53,0x15,0x9A,0xB2,0x7C,0xFF,0x0F};
//const uint8_t spMUCH[] PROGMEM = {0x61,0x4A,0x92,0xAA,0xC5,0x13,0xA7,0xA9,0x08,0xD1,0x16,0x8D,0xDB,0xC6,0xCE,0x5C,0xDA,0x31,0xEE,0x1A,0x2A,0x6B,0x6F,0xA3,0x24,0xAB,0x49,0x6E,0xC3,0xDD,0x36,0xAD,0x3A,0xDB,0xB6,0x92,0xD8,0xB8,0xCA,0x9C,0x9C,0xDB,0xAB,0x31,0xAB,0x3D,0x4B,0xAB,0x0C,0x99,0x08,0x9C,0xA2,0x54,0x85,0x6A,0x00,0x01,0x66,0x55,0x55,0xC0,0x6C,0x9D,0x0E,0x98,0x7D,0x26,0x00,0xAB,0x4F,0x39,0x60,0xB6,0x99,0x00,0xCC,0x3E,0x15,0x80,0xD9,0x3A,0x15,0x30,0xFB,0xD6,0xFF,0x03};
//const uint8_t spGREAT2[] PROGMEM = {0x6A,0xD1,0x55,0x75,0xC2,0x95,0xAA,0x5D,0x0C,0xD1,0x4E,0x55,0x66,0x56,0x35,0x58,0x3B,0xD5,0x99,0x99,0xCD,0x24,0x9F,0x50,0x77,0x61,0x0A,0x03,0xAB,0x4C,0xB2,0xB5,0x3E,0x2D,0x2C,0x0B,0xCD,0xBA,0xBA,0x52,0x35,0xC4,0x2D,0xDB,0x6A,0x9B,0x2B,0xD1,0xB4,0x2D,0xAB,0x1A,0xB6,0x88,0xD3,0xB7,0xAC,0x7C,0xD8,0x44,0xAE,0x5C,0xB3,0xD2,0xE1,0x1D,0x34,0x73,0xC9,0x48,0x47,0x12,0x34,0xEB,0x26,0x26,0xDB,0x8C,0x59,0xAD,0x1A,0x21,0x70,0x8A,0x52,0x15,0xAA,0x01,0xE0,0x80,0x2D,0xC3,0x1C,0xF0,0xAD,0xFB,0xFF,0x03};
//const uint8_t spIS[] PROGMEM = {0xA3,0xED,0xC6,0x30,0x3D,0x57,0xAD,0x7E,0xA8,0x42,0xA9,0x5C,0xB5,0xFA,0xA9,0x8A,0xB8,0x62,0xF3,0xEA,0x86,0x48,0xE6,0x8A,0x57,0xAB,0xEB,0x22,0x58,0x23,0x5E,0xAF,0xAE,0xCA,0x64,0xF5,0x7C,0x3C,0xBA,0xCA,0x93,0xD5,0xE3,0x76,0xEB,0x3B,0x4E,0x55,0xB3,0x4D,0x65,0xB8,0x58,0x5D,0xDD,0x72,0x97,0xE9,0x1B,0x55,0x27,0x4D,0xD3,0xE6,0x85,0xD5,0x4D,0x3D,0x6B,0xF9,0x5F,0x50,0x1B,0x26,0x27,0x0A,0xF8,0xAD,0x54,0x01,0xBF,0xBA,0x0B,0xE0,0xA7,0xF4,0xFF,0x07};
//const uint8_t spCAUTION[] PROGMEM = {0x0A,0xC8,0xF9,0xD9,0x01,0xD9,0x3D,0x19,0x20,0xA5,0xA1,0x11,0x45,0xBB,0x56,0xC2,0xAD,0x46,0x91,0xCC,0x56,0x24,0x75,0x19,0x65,0x52,0x57,0x5A,0xBC,0x65,0xE6,0xA3,0x88,0xA9,0xA4,0xC3,0x33,0x2A,0xC0,0x71,0xB3,0x04,0xAC,0x50,0x99,0x80,0x15,0xBB,0x13,0x30,0xE3,0xD6,0x98,0xA7,0xDF,0x48,0x61,0x36,0x6B,0xA9,0x3E,0x59,0x33,0xBA,0xAC,0xB5,0xCA,0x14,0xAF,0xD8,0xDC,0xB6,0xE2,0xC4,0x52,0x72,0x51,0x39,0xBB,0x32,0x9C,0xE0,0xB9,0xE5,0x6A,0xDA,0xB8,0xC4,0xEA,0x96,0xBB,0x4B,0xA7,0x52,0xA9,0x57,0xEE,0x6A,0xC4,0x52,0x22,0x6E,0x7D,0xD2,0x53,0xB3,0xB9,0x8A,0xD6,0xFA,0x7F};
//const uint8_t spBELOW[] PROGMEM = {0x0C,0x50,0xD6,0x6C,0x24,0xD5,0x39,0x73,0x58,0xEB,0x55,0x75,0x9F,0x8C,0x65,0x6B,0x56,0xD3,0x9C,0x92,0x94,0x3F,0x19,0x6D,0xD3,0xC6,0x9C,0xB6,0x66,0x74,0x8B,0x89,0x6B,0x52,0xB7,0xD1,0x2D,0xC6,0x11,0xC1,0xE9,0x5B,0xB7,0x04,0x65,0x3A,0x66,0x1F,0xDD,0x16,0x54,0xA5,0xD8,0x6D,0xD5,0x8D,0x66,0xBB,0xF2,0xD6,0x55,0x15,0x9E,0xED,0x2A,0x5B,0x56,0x95,0x79,0x4F,0xA8,0x74,0x19,0x65,0x14,0xD3,0x21,0xD2,0xB9,0x15,0x51,0xCE,0x18,0x6B,0xE7,0x52,0x78,0xBD,0xAD,0xA4,0x9D,0x53,0xE9,0xE5,0xB6,0x91,0x74,0x49,0x55,0x90,0xD3,0xC2,0xBA,0x25,0xD4,0x91,0x74,0xAB,0x69,0x1B,0x57,0x47,0x31,0xEA,0xAA,0x75,0x44,0x23,0x45,0xBB,0x9B,0xCD,0xF9,0x7F};
//const uint8_t spCYLINDER[] PROGMEM = {0x0C,0x78,0xC6,0x95,0x01,0x3F,0xA5,0x28,0xE0,0xB7,0x52,0x0B,0x04,0xE0,0xB7,0xD4,0x51,0x0C,0x9E,0x6A,0x6A,0xBD,0x57,0xD1,0x44,0xBA,0x84,0x6E,0x5E,0x45,0xC7,0xD1,0xE6,0xBA,0x75,0x15,0x87,0xD2,0xB4,0xB3,0xDB,0x55,0x1E,0x4C,0x55,0xA9,0x4E,0x56,0xD1,0x60,0xA7,0xBB,0xB5,0x5E,0x65,0xC7,0x1D,0x1A,0xB6,0x79,0x94,0x4D,0x91,0x8D,0xBB,0xBD,0x56,0x56,0x85,0x31,0x1E,0xF2,0x52,0x99,0x05,0xE6,0xA9,0xC6,0x53,0xAD,0x17,0xDC,0xC3,0x59,0x79,0x0D,0x53,0x87,0xB3,0x4A,0xD6,0x55,0x56,0x5D,0x42,0xE9,0xD9,0x56,0x59,0xED,0x12,0x0D,0x67,0x1D,0x55,0x89,0x8B,0xBC,0x94,0x67,0x54,0x39,0x34,0xD8,0xB2,0xEF,0x5A,0x85,0x32,0xF8,0xC6,0x2C,0xE8,0xFD,0xFF};
//const uint8_t spCONTACT[] PROGMEM = {0x0E,0x28,0x79,0xC4,0x00,0x39,0x3B,0x8C,0x22,0xC7,0xF0,0x36,0xAB,0xB5,0x86,0xAC,0x27,0xBD,0x64,0xF3,0x1A,0x2B,0xDB,0x96,0xF6,0x2E,0xAB,0x2B,0xE6,0xCC,0xD3,0x16,0xAD,0xBA,0xD8,0x15,0x4F,0x5F,0xB4,0xAA,0x6A,0xC2,0x92,0xB2,0x6D,0x2B,0x9B,0x66,0x1B,0x2E,0x4D,0xA1,0xCA,0x92,0x3A,0xA9,0x55,0xB1,0x2E,0x0A,0x57,0xD7,0xB2,0x94,0x80,0xC9,0x8A,0x4A,0xD1,0x43,0xB1,0x52,0xD6,0x59,0x45,0xF1,0xA6,0x69,0x5D,0x79,0x55,0xD5,0xA7,0x96,0xE7,0xE2,0xD5,0x96,0x50,0x52,0x11,0x8B,0x57,0x53,0xB3,0x5B,0x69,0xCF,0x1E,0x75,0xAD,0x46,0x2D,0x5D,0x06,0x81,0x53,0x94,0xAA,0x50,0x0D,0x00,0x00,0x03,0x4C,0xA1,0x6E,0x80,0xE7,0x2B,0xFE,0x1F};
//const uint8_t spAND[] PROGMEM = {0x6B,0xA8,0x2E,0x79,0xAC,0x37,0xAE,0xA5,0xBA,0xE4,0xCE,0x5C,0xB8,0xA6,0xE6,0x92,0xB3,0x62,0xD1,0x9A,0xAA,0x2B,0x8E,0x8A,0x45,0x6B,0xAA,0xA6,0x38,0x33,0x66,0x97,0xA9,0x39,0xCC,0xD0,0xF0,0x9C,0xA6,0x66,0xB1,0x5C,0xD2,0xB3,0x99,0x93,0xA4,0x0E,0x19,0x17,0x64,0xE3,0xBA,0x34,0xB3,0x6D,0x96,0xA7,0x69,0x53,0x57,0xDD,0xD2,0x96,0x6A,0x8A,0x45,0xA2,0xF5,0xFF,0x03};
//const uint8_t spFUEL[] PROGMEM = {0x04,0x18,0xB6,0x82,0x00,0xD3,0x57,0x08,0x60,0xBA,0x74,0x05,0x34,0x5B,0xB6,0x8A,0x19,0x92,0x21,0x7D,0xF3,0x2E,0x56,0x31,0x62,0x09,0xA4,0x6C,0x59,0x65,0xE3,0xA6,0xDA,0xB2,0xB5,0xD4,0x41,0xA4,0x67,0xD2,0xEA,0xD4,0x5B,0x3D,0x11,0x4E,0x5B,0xD2,0x1A,0xF8,0x86,0x07,0xEE,0x2D,0x5B,0xA2,0x5B,0xA6,0x9A,0x35,0x1D,0x89,0x6E,0xBB,0x48,0xBF,0xF4,0x26,0x3E,0x53,0xCC,0x59,0xD3,0x97,0x68,0x6F,0x09,0xA7,0x09,0x7F,0x14,0x35,0x21,0xD4,0xE4,0xFF,0x01};
//const uint8_t spFOR[] PROGMEM = {0x08,0xA8,0x56,0x98,0x00,0xD5,0x97,0x13,0x60,0xD8,0x50,0x51,0x58,0x77,0xA5,0x81,0x59,0x62,0x57,0xBA,0x20,0x6E,0x25,0x58,0x5B,0xEB,0x83,0xB9,0xE2,0x14,0xEF,0xA3,0x0F,0x7E,0x2D,0x8A,0xBD,0x8D,0x3E,0x86,0x11,0x4F,0xF3,0x37,0x86,0x64,0x53,0xCB,0x2D,0x77,0x18,0x33,0x2F,0x09,0x97,0x45,0xFF,0x0F};
//const uint8_t spSEQUENCE[] PROGMEM = {0x0C,0xF8,0x4E,0xCC,0x00,0x3F,0xBB,0x1B,0xE0,0x77,0x57,0x03,0xFC,0x15,0x12,0x80,0x3F,0x4D,0x57,0xD2,0x8D,0xB2,0xB8,0x2F,0x5E,0xE9,0xF0,0xCE,0xE4,0xFE,0x78,0x65,0x23,0x18,0x52,0xE5,0xE2,0x94,0x8F,0x4A,0x10,0xDD,0x95,0x10,0x38,0x45,0xA9,0x0A,0xD5,0x00,0x04,0x84,0x7C,0x82,0x00,0x55,0xDD,0x5A,0x16,0x4D,0x87,0x15,0x6F,0x5E,0x4B,0x56,0x15,0xDE,0xB2,0x79,0x6C,0x59,0xA7,0x47,0xDB,0xAA,0x72,0x66,0x9D,0x96,0xED,0x0B,0xC3,0x93,0x4C,0x78,0x57,0xCC,0x0C,0x7F,0xB5,0x1C,0x23,0x95,0x58,0xFD,0x59,0x73,0xA4,0x7A,0x62,0xF2,0x37,0x6E,0xE2,0x66,0x6E,0x08,0xF0,0x1D,0x91,0x00,0x7E,0x71,0x34,0xC0,0x1F,0x29,0x06,0xF8,0xB5,0xD4,0x00,0xBF,0x17,0x1B,0xE0,0x67,0x43,0x05,0xBC,0xEE,0xF2,0xFF};
//const uint8_t spSIDE[] PROGMEM = {0x06,0x38,0x00,0xD5,0x01,0x3F,0x31,0x3B,0xE0,0x1F,0xB1,0x00,0xFC,0xAE,0x56,0x8A,0x5F,0xCD,0x8B,0x8D,0xE9,0x2A,0x2A,0x1F,0x97,0xB4,0xD5,0xAB,0x2B,0x72,0xDC,0xCA,0x36,0xAF,0xAE,0x89,0x4D,0x29,0xDB,0xB2,0xBA,0x2E,0x26,0xB4,0xAC,0xCB,0x6A,0xAB,0x2D,0xCD,0xB4,0xD5,0xAB,0xA9,0x21,0x24,0x23,0x16,0xAD,0xAA,0x5A,0xE7,0xCE,0x9C,0x95,0xAA,0x2C,0x8D,0xC2,0x2B,0xA1,0xAA,0xB9,0x49,0x1B,0x2B,0x8B,0xAE,0x1E,0x46,0x94,0xCC,0xD2,0x94,0xA1,0x6A,0x55,0xB5,0x5C,0xF5,0xFF};
//const uint8_t spSLOW[] PROGMEM = {0x04,0xF8,0x8E,0x98,0x00,0xDF,0x30,0x2A,0xE0,0x27,0x11,0x07,0xFC,0x64,0x6C,0x80,0x9F,0xD5,0x1C,0xF0,0x8B,0x48,0xEB,0x2B,0xCE,0x52,0x93,0x2C,0xAD,0xCF,0x38,0xBB,0x02,0xB3,0xAE,0x2E,0xB1,0xE9,0x62,0xEE,0xBB,0xDA,0x24,0x7B,0x42,0xB8,0xEF,0x6A,0x0A,0xC9,0x4E,0xE7,0x6C,0xAB,0x8A,0x7C,0xCA,0x8D,0xF3,0xB4,0x2A,0xC8,0x2D,0x57,0xEE,0x5D,0x4A,0xAF,0x37,0xDD,0xB0,0xB7,0x2B,0x55,0x9C,0x30,0xE1,0x8E,0xAC,0x96,0xFA,0xC2,0xD9,0xDC,0xFC,0x3F};
//const uint8_t spTO[] PROGMEM = {0x09,0xD8,0x4E,0x34,0x00,0x4B,0xA7,0xA5,0xBC,0xE9,0x62,0x55,0x4B,0x53,0x9A,0xAC,0x5C,0x2D,0xF9,0x4B,0xE9,0x32,0x73,0xD3,0xA1,0x3D,0xA5,0x4F,0x52,0x2D,0x9B,0xB6,0xA4,0x21,0x79,0x95,0xC0,0xAC,0xAD,0x16,0xED,0xDC,0x22,0x23,0xC2,0xFF,0x03};
//const uint8_t spRICH[] PROGMEM = {0xAE,0x50,0xD1,0xA2,0x94,0xAD,0xB9,0xDA,0x44,0xF3,0x74,0x8E,0xE3,0x5A,0x9D,0xCC,0xDC,0xD5,0x6E,0xE8,0x6C,0xD2,0x74,0x55,0x67,0xA9,0x0D,0x89,0x3C,0x42,0x93,0xB7,0x2A,0x0F,0x4A,0x72,0x4B,0xB7,0xCA,0x1A,0x4D,0xD5,0x75,0xCD,0x2A,0x9A,0x0B,0xB6,0xB0,0xD7,0xAB,0x6C,0x36,0xC9,0xC2,0x5F,0xAD,0xB6,0x05,0x67,0xF7,0x58,0x55,0xE6,0xEA,0x83,0xCC,0xE3,0x13,0x02,0xA7,0x28,0x55,0xA1,0x1A,0x40,0x80,0x59,0x55,0x15,0x30,0x5B,0xA7,0x03,0x66,0x9F,0x09,0xC0,0xEA,0x53,0x0E,0x98,0x6D,0x26,0x00,0xB3,0x4F,0x05,0x60,0xB6,0x4E,0x05,0xCC,0xBE,0xC5,0x80,0xD1,0xA6,0xFE,0x1F};
//const uint8_t spPUMPS[] PROGMEM = {0x02,0x88,0xCE,0x53,0x00,0xC9,0x86,0xA6,0x22,0x9A,0xCE,0x64,0x69,0xB5,0xDA,0x64,0x36,0xDD,0x75,0xF3,0xEA,0x32,0xDF,0xB6,0x92,0xCE,0x63,0xCE,0x7C,0xCB,0x4A,0x37,0xB7,0x3D,0xA9,0x0D,0x4B,0x5D,0x9C,0x8E,0x10,0x3A,0xC3,0x62,0x49,0x38,0x83,0x0A,0x2F,0x12,0x37,0xFA,0x44,0xE0,0x14,0xA5,0x2A,0x54,0x03,0x00,0x40,0x01,0x49,0x79,0x1A,0xE0,0x19,0x57,0x05,0xFC,0x94,0x62,0x80,0xDF,0x4A,0x2D,0xA0,0x80,0xDF,0x52,0x15,0xF0,0x4B,0xD9,0xFF,0x03};
//const uint8_t spLEVEL[] PROGMEM = {0x69,0xAB,0xC4,0xB3,0xD8,0x92,0x86,0x2D,0x83,0xEE,0x60,0xCD,0x12,0xD6,0x0C,0x66,0x45,0x2C,0x73,0x58,0x0B,0xA8,0x53,0xD6,0xAC,0x6D,0xE9,0xC0,0x57,0xC5,0xB2,0xAE,0xA1,0xB0,0x49,0x0D,0x7B,0xBD,0x86,0xA2,0x47,0x35,0xE3,0xF5,0xEA,0xB2,0x4B,0x4B,0xCB,0xC7,0xA3,0xCD,0xDE,0x23,0x59,0x1A,0x9A,0x31,0x8B,0xB0,0x54,0x76,0xE3,0xC6,0x26,0x5C,0x2C,0xCC,0x76,0x6B,0x92,0xBC,0x34,0x95,0xC6,0xA3,0xCE,0x74,0xDB,0x85,0x3B,0x8F,0xBA,0x90,0x9C,0x51,0xCC,0xD6,0xEA,0x4C,0x63,0x56,0x30,0x6D,0xA9,0x23,0xCF,0x59,0xD0,0x34,0xB5,0xF9,0x7F};
//const uint8_t spLOWER[] PROGMEM = {0x66,0x4D,0xA8,0x2A,0x4C,0xDA,0x9A,0x3D,0xC2,0x6D,0x31,0x6F,0xE3,0xB6,0x06,0x7C,0x55,0x22,0xA9,0x5B,0x23,0xE8,0x31,0xD3,0x34,0x61,0x49,0x28,0xBB,0x83,0xB2,0x94,0xB9,0x02,0xEB,0x4A,0xF2,0xBB,0xC6,0x42,0x23,0x43,0x2D,0xEE,0xEA,0x0B,0xA9,0x09,0xE3,0x6E,0xAB,0x29,0x24,0x27,0x95,0xBD,0xAD,0x3A,0xB1,0x9E,0x50,0xCA,0x36,0xAA,0xC0,0x67,0x5C,0xD9,0x6B,0xAA,0x9C,0xBE,0x36,0x23,0x2F,0xA5,0xB2,0xFE,0x42,0x42,0xFC,0x8C,0x22,0xC4,0x15,0x2B,0xCE,0x33,0x8A,0x98,0x9D,0xA7,0xA9,0x77,0x2B,0x52,0x17,0xDE,0xE4,0xDC,0xAD,0x48,0x2D,0x60,0x8B,0x73,0x97,0x3C,0x35,0x83,0x2D,0xCA,0xF2,0xFF};
//const uint8_t spREAR[] PROGMEM = {0x66,0x54,0xCD,0xCD,0x43,0x95,0x9A,0x49,0x95,0x50,0x4F,0x71,0xEA,0x26,0x53,0x4C,0x23,0xD9,0x4D,0x1A,0x62,0xC5,0x70,0xD7,0x74,0xAB,0xAD,0x9D,0x9D,0x42,0xDB,0xAD,0xBA,0xFB,0x52,0x68,0x59,0xBB,0xAA,0xEE,0x92,0x61,0x74,0xF5,0xAA,0x7B,0x2C,0x82,0xD1,0xCD,0xAB,0x6B,0x21,0x91,0x46,0x37,0x8F,0xB9,0x7A,0x47,0x5F,0x7D,0xDD,0xE6,0x1A,0x12,0x75,0xF9,0x53,0x39,0x6A,0x6E,0xD4,0xC5,0xDD,0xED,0x28,0x65,0xD0,0x16,0x7B,0x87,0x3B,0x97,0x01,0x3D,0xEA,0x1B,0xBE,0x9C,0x16,0xF9,0xB1,0x6F,0xF8,0x73,0x2B,0x88,0xA1,0x2E,0xE1,0xCF,0xDB,0x21,0x9B,0xDA,0x84,0x3F,0x6F,0x87,0x49,0xEA,0x1C,0xFE,0x3C,0x12,0xA6,0x25,0x4B,0xF8,0xF3,0x54,0x3E,0xD7,0xD4,0xFF,0x0F};
//const uint8_t spHOLD[] PROGMEM = {0x08,0x28,0xDA,0x03,0x03,0xA1,0x1F,0xD0,0xFD,0x83,0x12,0xB7,0x36,0xCA,0xDA,0x40,0xCD,0xD2,0xDA,0xCC,0xFD,0x82,0xA8,0x6B,0x6B,0x12,0xF3,0x2B,0xA6,0xAE,0xAD,0x8E,0x2C,0xB7,0x09,0xDB,0xB6,0x3A,0xD1,0x9A,0x11,0x68,0xDB,0xAA,0x8C,0x6B,0x4B,0xA0,0x6D,0xAB,0x32,0xC9,0x2D,0xC1,0xB4,0xAD,0x48,0x2C,0xB7,0x98,0xD2,0x96,0x3C,0x31,0xDB,0x60,0xC9,0x56,0xB2,0x24,0x6C,0x9C,0xD5,0x6B,0xCA,0x93,0x90,0x0A,0x35,0x37,0xA9,0xCA,0x54,0xDD,0x32,0x92,0x8E,0xB4,0x8A,0x16,0xD5,0x78,0x3D,0x8A,0x6A,0x8A,0x4C,0x6B,0xF1,0xFF,0x03};
//const uint8_t spLONG[] PROGMEM = {0xAE,0xAF,0xC0,0x32,0x92,0xB3,0x86,0xB5,0x02,0x2F,0x77,0xEE,0x17,0xD6,0x0C,0xB3,0xD5,0xB5,0x4B,0x58,0x0A,0xF0,0xCE,0xA0,0x3E,0x63,0xAE,0xC8,0xAB,0x03,0xB2,0x8C,0x31,0xAA,0x9B,0x60,0xED,0xB2,0x86,0xE0,0x6E,0x9C,0xAD,0xED,0xEA,0xA3,0xBD,0x71,0xB6,0xAE,0xAB,0x8D,0xEE,0xC6,0xC4,0xDB,0xAE,0x36,0xFA,0x6B,0x53,0x6F,0xBB,0x9A,0x18,0xB7,0x4C,0x3D,0xCB,0xAA,0x43,0x9C,0x34,0xF5,0x36,0xA3,0x8A,0xA6,0xAB,0xD9,0x93,0xB6,0xAA,0x70,0xF3,0x53,0xB7,0xD3,0xEA,0xC2,0xD5,0xD7,0xCC,0x6E,0xAB,0x9B,0x26,0x6B,0x77,0x25,0xAD,0x4E,0xC6,0x2A,0xD8,0xE5,0xFC,0x3F};
//const uint8_t spLEVEL[] PROGMEM = {0xA5,0x1E,0x40,0x27,0x84,0xF3,0x94,0xB6,0x03,0x5F,0x65,0x8F,0x9B,0xBA,0x09,0x64,0x1D,0xA3,0xCE,0x6A,0x2B,0xEB,0x34,0xB5,0xC7,0xAB,0xAE,0x62,0x4C,0x23,0x67,0xAF,0xBA,0xE8,0x11,0xF7,0x5C,0xBC,0xEA,0x62,0x4B,0x43,0x63,0xF1,0xAA,0x53,0xF0,0x0A,0xCD,0xD9,0x66,0xCC,0x22,0x2C,0x95,0xDD,0xB8,0xB1,0x09,0x17,0x0B,0xB3,0x1D,0xF6,0x22,0x23,0xD3,0x39,0x96,0x99,0x6D,0xEB,0x10,0x89,0xC5,0x65,0x09,0xFA,0xDA,0x44,0x7A,0xB7,0x2D,0xF1,0x1D,0x17,0xCD,0x52,0xF6,0xC4,0xAE,0x9D,0xA5,0x6F,0x3A,0x12,0xBD,0x76,0x96,0x2C,0xE9,0x8C,0xFC,0xCB,0x59,0xBB,0xB8,0x3B,0xCA,0xED,0x62,0xEE,0xA4,0x1E,0xEF,0x3E,0x9D,0xBC,0xF5,0xFF,0x03};
//const uint8_t spLEFT[] PROGMEM = {0x6E,0x4C,0xB8,0x8B,0xB5,0xDA,0xA6,0x75,0x23,0xEA,0x24,0x4B,0x1B,0xD6,0x0D,0x69,0x02,0xBD,0x5D,0x59,0x36,0xA2,0x49,0xB4,0x76,0x65,0xDC,0x88,0xC7,0x31,0x96,0xAD,0xA1,0xF1,0x8A,0x30,0xD9,0xB2,0xBA,0x2E,0xDB,0xC2,0x74,0xCB,0x6A,0x9B,0x29,0x4D,0xB3,0x35,0xAB,0x6B,0xAE,0x25,0x2D,0x56,0xAF,0xB1,0xF8,0xD4,0xB2,0x9C,0x23,0x80,0x6A,0x52,0x05,0xD0,0x75,0x28,0x03,0xBA,0x29,0xE5,0x00,0x02,0xA7,0x28,0x55,0xA1,0x1A,0x00,0x0A,0x18,0xD2,0x8D,0x01,0x9B,0xAB,0x21,0x70,0x8A,0x52,0x15,0xAA,0xF1,0xFF};
//const uint8_t spRIGHT[] PROGMEM = {0xAA,0x90,0xD5,0xAD,0x55,0x9D,0xA9,0x56,0x94,0xD4,0x0A,0x97,0xAB,0x7A,0x39,0x9C,0xBB,0x44,0x5D,0xE8,0xFD,0x14,0x3D,0x53,0xF7,0xAD,0x09,0x5D,0xAB,0xD4,0xDD,0xAD,0x3A,0xCB,0x0B,0x2F,0xE9,0xBC,0xEA,0xA2,0xCF,0xBC,0x74,0xD5,0xAA,0xAB,0x1D,0x89,0xD2,0xC7,0xAB,0xAD,0x21,0xA9,0xD2,0x1F,0x8F,0xB1,0x5A,0xA7,0xA9,0x7A,0x54,0x8E,0xE1,0x12,0xBC,0xF2,0x65,0x38,0xBB,0x67,0x8A,0xEE,0x56,0x08,0x9C,0xA2,0x54,0x85,0x6A,0x00,0x80,0x03,0xA6,0x50,0x77,0xC0,0xF3,0x15,0x04,0xD8,0xCA,0xEC,0xFF,0x01};
//const uint8_t spOPEN[] PROGMEM = {0xA5,0x4D,0xB2,0xD7,0x84,0xBA,0xB4,0x2A,0xCA,0x59,0x16,0xDD,0x3A,0xCA,0xC4,0x67,0x85,0xA5,0xDF,0x2A,0x2A,0xCA,0x75,0xE5,0x6C,0x2D,0xCF,0x28,0x27,0x9C,0xBD,0x21,0x70,0x8A,0x52,0x15,0xAA,0x01,0x90,0xA2,0xAE,0xCA,0x5C,0xD5,0xF1,0xCA,0xAB,0x32,0xAF,0xA0,0xCE,0xAB,0x2C,0x3A,0xDC,0x4D,0xBE,0x8C,0xB2,0x38,0x0D,0x91,0x9C,0xD3,0x8A,0x6E,0x48,0xC7,0x2C,0x6E,0x29,0x9A,0x64,0x1D,0xB3,0xB8,0xA5,0xAC,0x5C,0x74,0xCC,0x92,0x96,0x2A,0x6B,0x73,0x97,0xAC,0xFD,0xFF};
//const uint8_t spSTRAY[] PROGMEM = {0x04,0x78,0xC6,0x95,0x01,0x3F,0xA5,0x28,0xE0,0xB7,0x52,0x0D,0x18,0xE0,0xB7,0x54,0x05,0xFC,0x52,0x86,0xC0,0x29,0x4A,0x55,0xA8,0x06,0x30,0x20,0x1A,0x51,0x75,0xD4,0xD8,0x99,0x69,0x76,0x46,0x13,0x07,0x87,0x95,0xA4,0x5F,0x75,0x1A,0x92,0x5A,0x9C,0x6E,0xD5,0xB9,0x9A,0x5B,0x71,0xB6,0x55,0xE6,0x9C,0xE2,0x25,0x5B,0x56,0x59,0x6D,0xB1,0xB5,0xBE,0x5E,0x75,0x57,0xC5,0x3A,0xB6,0x7A,0x4D,0x5D,0x05,0x7B,0xDB,0xA3,0x31,0x37,0x1B,0x64,0x1D,0x8F,0xC6,0xD1,0xA3,0xB2,0x47,0xDE,0x6E,0x67,0x0B,0xCC,0x59,0x75,0xB9,0xDD,0xCD,0x91,0x74,0xE5,0xE4,0xF2,0x74,0xE7,0x28,0x9B,0xB3,0xD3,0xDB,0x8D,0xA1,0x5D,0x3E,0x2A,0x6F,0x33,0x42,0x39,0xBD,0x38,0xFD,0xA3,0x3B,0xAA,0xE7,0x9A,0xF0,0x8F,0xA1,0xA4,0x56,0x4B,0xCC,0x3F,0x96,0xB3,0x48,0x2C,0xF9,0x7F};
//const uint8_t spCLOSE[] PROGMEM = {0x0C,0x88,0xBD,0xD2,0x00,0x59,0x4D,0x19,0xA0,0x8A,0x2E,0x05,0x74,0x65,0x11,0x8A,0x4C,0xA3,0x47,0xB0,0xE9,0x28,0x33,0xAB,0x09,0xE1,0xCE,0xA3,0xA9,0x24,0x26,0x8C,0xFB,0x8C,0xA6,0xD0,0x1A,0x55,0xE9,0x33,0xBA,0xC4,0xA7,0xCD,0x64,0x6B,0x1B,0xA2,0xDA,0x34,0x95,0xCD,0x65,0xF5,0x7E,0x5D,0xD5,0x37,0xA7,0xDD,0xFB,0x4A,0x13,0xDD,0x94,0x8E,0xA0,0x2B,0xCD,0x78,0x93,0x3B,0x83,0xA9,0x50,0x93,0xCD,0xE6,0x0B,0xD6,0x32,0xC4,0x57,0xBB,0x2F,0x79,0x33,0x95,0x58,0xAC,0xBE,0x64,0x4D,0x4D,0xFC,0x91,0x7B,0x06,0x76,0x17,0xB3,0x6C,0xEE,0xB9,0x96,0x3D,0x49,0xD2,0xA5,0xF7,0x39,0xD1,0x22,0xCE,0x46,0x5E,0x47,0xD2,0x27,0x23,0x15,0x7F,0xD3,0xDB,0x9D,0x91,0x8B,0x6D,0x71,0x6F,0x8F,0x29,0x22,0xB6,0xE5,0xFF,0x01};
//const uint8_t spEVACUATE[] PROGMEM = {0x21,0x19,0xDA,0x89,0xAA,0x16,0x8F,0x7E,0x6A,0x63,0xAA,0x5A,0x7C,0xFA,0x69,0x83,0x31,0x72,0xCD,0x69,0x86,0x0F,0xA2,0xF4,0x2D,0xA3,0x6D,0x4E,0xD8,0x42,0xBB,0x94,0xBE,0x3A,0x33,0x55,0x69,0x9D,0xC6,0xAE,0xCD,0x54,0xCD,0x4D,0x19,0x87,0x72,0x17,0x31,0x37,0xAB,0xAB,0xDE,0xD5,0x54,0x5B,0x9F,0xAA,0xF9,0xD0,0x50,0x5B,0x73,0x8A,0x66,0x5A,0xC2,0x63,0xCD,0xC9,0x6A,0x0C,0x2D,0xEB,0xC5,0x27,0xAB,0x49,0xBD,0x6C,0x1A,0x8D,0xA4,0x15,0xF6,0x92,0x93,0x8C,0xC0,0x29,0x4A,0x55,0xA8,0x06,0x18,0x60,0x45,0x57,0x03,0x9C,0x3C,0xB2,0xD2,0x11,0x12,0xB1,0x6C,0xCB,0xEA,0x9A,0x72,0xD2,0xD6,0x2D,0xA3,0x2F,0xA8,0x52,0x9A,0xBA,0x96,0x29,0xF2,0x4D,0x2B,0xE8,0xD2,0xE6,0x4C,0x27,0xAD,0xB1,0xEF,0x9A,0x9B,0x69,0xF3,0xC4,0x6D,0x67,0x6F,0x3E,0xD5,0x52,0xBB,0xAD,0xA3,0x87,0x36,0x4A,0xED,0xBA,0xCE,0x1E,0x52,0x38,0x7D,0xF3,0x3E,0xD3,0x35,0x6C,0x32,0x55,0x6C,0xB1,0x37,0x02,0xA7,0x28,0x55,0xA1,0x1A,0x00,0xA0,0x80,0x29,0xD4,0x05,0xF0,0x7C,0xC5,0xFF,0x03};
//const uint8_t spFAILURE[] PROGMEM = {0x04,0x18,0xB6,0x82,0x02,0x04,0x98,0xBE,0x42,0x00,0xD3,0xA5,0x6B,0x60,0xD5,0xC3,0x95,0x48,0xC8,0x96,0xD5,0x0D,0x57,0xCC,0xA5,0xAB,0x57,0xDF,0x54,0xB0,0xB5,0xAD,0x5E,0xC3,0x60,0x95,0x62,0x9A,0xAE,0x2D,0x9D,0xBA,0x7B,0xA8,0xF7,0xB4,0x36,0x19,0x4E,0xEE,0xE9,0xCA,0xDA,0x75,0x20,0xB7,0x6D,0x69,0x6B,0xD3,0x81,0x32,0xB1,0xA6,0x6D,0xCD,0x05,0x68,0x47,0xDF,0xB2,0x37,0x5F,0x24,0x2D,0x5D,0xC2,0x55,0x5C,0x92,0x9C,0xF4,0x09,0x6F,0xB6,0x85,0x76,0x96,0xC5,0xBD,0xD9,0x37,0xE8,0x9A,0x3E,0xF7,0xE6,0x16,0x90,0x69,0xDE,0xDC,0x97,0xAB,0x63,0xB4,0xA7,0xFD,0x7F};
//const uint8_t spSERVICE[] PROGMEM = {0x0C,0xF8,0x29,0x45,0x01,0xBF,0x95,0x5A,0x20,0x00,0xBF,0xA5,0x3A,0xE0,0x97,0x32,0x03,0xFC,0x5C,0x56,0xF2,0x6A,0x2A,0x20,0x2C,0xF9,0xC8,0x8A,0x2F,0xC1,0x95,0xEC,0x23,0xCD,0x31,0x99,0x97,0xB3,0x8F,0x34,0xBB,0x12,0x5A,0xF1,0x1E,0xF2,0xE4,0x42,0xA5,0xC8,0xA9,0x98,0x9C,0x49,0xD5,0x08,0x37,0x6D,0x29,0x26,0x55,0x52,0xBA,0xB6,0xB5,0x58,0x17,0x0F,0x7F,0xDD,0xCE,0x6C,0x5D,0xC2,0xF3,0xD7,0x78,0x9A,0x49,0x51,0xB3,0xCE,0xE5,0xAB,0x3A,0xD9,0xCC,0x76,0x95,0xBF,0xDB,0x76,0x15,0xF6,0x67,0x80,0x5F,0x53,0x0C,0xF0,0x6B,0xB2,0x03,0x7E,0x4E,0x37,0xC0,0x6F,0x66,0x0A,0xF8,0xAB,0xD9,0x00,0x7F,0xA6,0x29,0xE0,0xB7,0x92,0xFF,0x07};
//const uint8_t spABORT[] PROGMEM = {0xAD,0x4E,0x66,0x4A,0xDC,0x17,0xAF,0xA5,0xC8,0x19,0x35,0xDD,0xBA,0x86,0x22,0x7A,0xCC,0x64,0xEB,0x1A,0x92,0x9A,0x56,0xB3,0x2E,0x6A,0x36,0x31,0x85,0x2C,0x5A,0x89,0x45,0xDB,0x56,0xB2,0x68,0x2D,0x56,0x69,0xCA,0x59,0xBD,0x35,0x5B,0xB9,0xEA,0x50,0xB5,0x2E,0x6C,0xE5,0xA2,0xBA,0x5C,0x5D,0x8F,0x26,0xF1,0x19,0x55,0xCE,0xBA,0xEA,0x28,0x66,0xCC,0x28,0xFB,0xAA,0x12,0xEB,0x55,0x67,0xF7,0xAB,0x08,0xFA,0x5A,0x82,0xBD,0x9D,0x2C,0xDA,0x0D,0x29,0xD1,0xB6,0x92,0x58,0x8B,0xB3,0xA8,0xCF,0x8A,0x72,0x4E,0xCA,0x32,0xAD,0x25,0x2C,0xDB,0x8C,0xD5,0x95,0x22,0x70,0x8A,0x52,0x15,0xAA,0x01,0xE0,0x80,0x21,0xDD,0x0C,0xB0,0xB9,0x1A,0x03,0xA7,0x28,0x55,0xA1,0x1A,0xFF,0x0F};
//const uint8_t spIDEMTIFY[] PROGMEM = {0xA9,0x8C,0x23,0xDD,0xB3,0xA7,0x9C,0xB1,0xA9,0x89,0x08,0x59,0x73,0x86,0xA6,0xCA,0xB2,0x74,0xF3,0xE9,0xBB,0x1A,0xD6,0xB6,0xCD,0xA3,0x1F,0x6A,0x88,0x4A,0x3F,0x22,0x70,0x8A,0x52,0x15,0xAA,0x01,0x02,0xC8,0xA0,0xEC,0x14,0xD5,0x26,0x95,0xE7,0xE2,0x93,0x15,0xDD,0x5C,0x15,0x8B,0x4E,0x96,0x4D,0x49,0x47,0xD5,0x1E,0x59,0x36,0xEE,0x43,0x1D,0xA9,0x54,0xC7,0x87,0x8A,0x8B,0x9D,0x55,0x54,0x95,0x92,0x12,0x8B,0x46,0x91,0x83,0x6B,0x70,0xCE,0x6E,0x75,0xF6,0x61,0x89,0xD1,0x04,0x14,0xD0,0x5D,0x88,0x01,0x9A,0x6B,0x1F,0x59,0x51,0x1D,0xA9,0x92,0x7A,0xD4,0x31,0x76,0xB8,0xC9,0xEB,0x35,0x44,0x37,0x11,0xA6,0xAF,0xD7,0x98,0xF5,0x85,0x85,0xBE,0x5E,0x63,0x15,0x1B,0x5A,0xBA,0x7A,0xCD,0x5D,0xB4,0x7B,0xEB,0xE6,0xB5,0x74,0x59,0xA2,0x6D,0x9B,0xD7,0xDA,0x75,0x91,0xB4,0xAF,0xFA,0x7F};
//const uint8_t spTOO_LOW[] PROGMEM = {0x01,0xD8,0x41,0x33,0x00,0x33,0x66,0x29,0xA0,0x58,0xA3,0x92,0x04,0x63,0xEE,0xE5,0x93,0x46,0x5A,0x98,0xA5,0x14,0xB7,0x6D,0x59,0x61,0x16,0x56,0xD0,0x35,0x65,0x85,0x6A,0x5A,0x43,0xB6,0x54,0x64,0xC3,0x95,0x01,0xF1,0x5A,0xD5,0x85,0x78,0x14,0xB4,0x6B,0x75,0x27,0x52,0x9E,0xD0,0x6D,0xD5,0x83,0x6A,0x7B,0x60,0xB7,0x53,0x77,0xE6,0x6D,0x8E,0xFD,0x4E,0xDB,0x68,0x8C,0x07,0xF5,0x3B,0x6D,0xA5,0xD9,0x11,0x94,0x6F,0xF5,0x85,0xD5,0x84,0x73,0xF6,0x31,0x16,0x56,0x93,0x26,0xF9,0xC7,0x9A,0x59,0x4D,0x9A,0xF8,0x6B,0x67,0xE6,0x35,0xA1,0xE2,0xB7,0x5C,0x89,0x77,0xA7,0xAA,0xBF,0xF2,0x44,0x39,0xED,0x2A,0x79,0xCA,0x13,0xD4,0x96,0x8A,0xE5,0x2D,0x4F,0x70,0x5B,0x2A,0x96,0xA7,0xFC,0xC1,0x4E,0xB9,0x72,0x6E,0xF7,0x7B,0x7F,0xA9,0x2C,0x79,0xCC,0x6F,0xD2,0xBA,0x8A,0xF5,0xF9,0x7F};
//const uint8_t spCENTRE[] PROGMEM = {0x0A,0xF8,0xAD,0xD4,0x00,0xBF,0xA5,0x3B,0xE0,0xB7,0x72,0x07,0xFC,0x59,0x1E,0x80,0x1F,0xD5,0x56,0xD6,0xAD,0xAB,0xA9,0x6C,0x59,0x55,0xCB,0xAE,0xA6,0xB9,0x66,0x0D,0x35,0xA5,0xBA,0xE6,0xEC,0x35,0xD6,0xE8,0xEA,0x52,0x73,0xDA,0xD4,0x1C,0xA7,0x88,0x27,0x71,0x43,0x91,0xE8,0x95,0x61,0x0F,0x12,0xF0,0x94,0x5A,0x02,0xA6,0x32,0x2B,0xC7,0x8A,0xEA,0xAA,0x6A,0xBB,0xEC,0x2D,0xA6,0x88,0x49,0xA7,0x74,0x94,0xA2,0x54,0xA9,0x9D,0xC2,0x59,0x8A,0x62,0x97,0x6E,0x4E,0x57,0xA9,0x8D,0x36,0xDC,0x25,0xDC,0xD5,0x1D,0xC3,0x4A,0xBE,0xF0,0x34,0x73,0x0C,0x67,0xFE,0xC2,0x5B,0xEA,0x02,0xAD,0xE4,0x31,0x6F,0x79,0x81,0xE9,0xD4,0xF9,0xFF,0x01};
//const uint8_t spAREA[] PROGMEM = {0xA5,0xAF,0x89,0x35,0xB2,0x6B,0xAF,0xAE,0xFB,0x62,0x6E,0xDB,0xBC,0xEA,0xEE,0x46,0x78,0x64,0xCB,0xAA,0x6A,0x6E,0x96,0xA1,0xAE,0xAB,0xCA,0x8B,0x3D,0x92,0xB3,0xB6,0x2A,0x1D,0x4A,0x73,0xCE,0x3A,0xEA,0xB2,0x29,0xD5,0x24,0xF3,0xAA,0xEB,0x64,0x09,0xD3,0xD5,0x6B,0xA8,0x59,0x30,0x32,0x36,0xAD,0xB1,0x05,0x07,0x8F,0xDC,0xBC,0xE6,0x6A,0x1D,0x23,0xEA,0xD5,0x5A,0x9B,0x29,0x0A,0xCD,0x4D,0x6B,0x6D,0xAA,0x38,0x34,0x5F,0xAF,0xB5,0xD3,0xA1,0xD0,0x5C,0xDC,0xD6,0xC1,0x52,0x5C,0x65,0xCF,0xFF,0x03};
//const uint8_t spBASE[] PROGMEM = {0x0C,0x50,0xD6,0x6C,0x75,0xC5,0x86,0x48,0x46,0x9B,0xD5,0x54,0xEF,0xA2,0xEE,0x6B,0x56,0xD3,0xA3,0x8A,0x7A,0x2E,0x5E,0x55,0x4F,0x42,0x66,0x35,0x7B,0x94,0x3D,0x10,0x45,0xCC,0xE2,0x52,0x36,0x87,0x1A,0x39,0x75,0x4A,0xFB,0x74,0x99,0xA0,0x7A,0x35,0xC0,0x33,0xAE,0x0A,0xF8,0x29,0xC5,0x00,0xBF,0x95,0xFE,0x3F};
//const uint8_t spCONTROL[] PROGMEM = {0x0A,0xA8,0xBA,0xB8,0x14,0xDD,0x9C,0x92,0x98,0xEB,0x55,0x54,0xDD,0xA6,0x61,0x9D,0x57,0xDB,0x78,0xBB,0xA6,0x6E,0x5E,0x6D,0xE3,0x6E,0x99,0xDC,0xB8,0x74,0x55,0x89,0xAF,0x70,0xF4,0xD4,0x67,0x45,0xDD,0x6C,0x76,0x55,0x19,0x44,0x46,0xB1,0x39,0x32,0xC0,0xB0,0xC5,0x0E,0x18,0xB6,0x53,0x01,0xC1,0x98,0x94,0x2A,0x14,0x4B,0x09,0xC9,0xB2,0xAA,0x68,0x2A,0x3D,0xD8,0xFB,0x2A,0x93,0x98,0x76,0x63,0xEF,0xA7,0xCC,0x6C,0x3A,0x8D,0xB3,0xAE,0x2A,0xB1,0xED,0x64,0xC9,0x32,0xEA,0x82,0x67,0x4A,0x28,0x6B,0x6B,0x33,0xA9,0x69,0x94,0xAC,0xBD,0x2D,0x43,0xD4,0xDD,0x01,0x9A,0x2F,0x4C,0x59,0xC9,0x38,0xAA,0xDF,0xFF,0x07};
//const uint8_t spMEASURED[] PROGMEM = {0x61,0xF0,0xDC,0xA3,0x42,0x9C,0x94,0x3E,0x09,0xB5,0x4A,0x4E,0xD2,0xDA,0xCA,0x45,0xBD,0xCD,0xC9,0x6A,0xAB,0x0B,0xD3,0xD0,0xC5,0xAB,0xA9,0x3A,0xD4,0xDA,0x1F,0xAF,0xBA,0xEB,0x50,0x6D,0x7F,0xBD,0x9A,0xE6,0x43,0xD4,0x7D,0xD1,0x18,0x46,0x30,0x65,0xF5,0xCE,0x6D,0xDE,0xAD,0xC2,0x50,0x98,0x05,0x60,0x45,0xD7,0x00,0x74,0xAD,0xD4,0x96,0x92,0x85,0xB4,0xAC,0x73,0xD9,0x72,0x36,0xD4,0xD1,0xBC,0xE5,0xCC,0xD9,0xD0,0x57,0xF3,0xA5,0x27,0x17,0x43,0x1F,0xE9,0x93,0x9E,0x9C,0x1C,0x7D,0x2C,0x5F,0x79,0x4B,0x54,0xB2,0xCC,0x6C,0xE6,0x2B,0x91,0x4C,0x39,0x1A,0x8B,0xAF,0x69,0x94,0x88,0x4E,0xCC,0xFE,0x88,0xDC,0x2B,0x32,0x71,0xFA,0xBB,0x35,0x67,0xF3,0xD4,0xE1,0xA9,0x59,0x55,0xD4,0x57,0xFF,0x3F};
//const uint8_t spD[] PROGMEM = {0x08,0x20,0xBA,0x0D,0x03,0x6D,0x3E,0x2C,0x55,0x45,0xB3,0x8C,0xBE,0x05,0x65,0xD5,0x78,0x32,0xDA,0xEE,0x85,0x34,0xF2,0xF6,0xE8,0x86,0x33,0xE0,0xCA,0xC7,0xAD,0x9B,0xCE,0x81,0xBB,0x66,0xB7,0x61,0x06,0x07,0xEE,0x9C,0xD5,0xC6,0xA9,0x1D,0x65,0x72,0xD1,0xFF,0x03};
//const uint8_t spTHE[] PROGMEM = {0x08,0x20,0xBA,0x0D,0x03,0x69,0xDF,0xA8,0xCD,0x85,0x3B,0xD7,0x79,0xF4,0x59,0xB7,0xA9,0xFA,0xA2,0xD5,0x27,0xD9,0x6E,0x11,0x8B,0xC6,0x90,0xB4,0x47,0xA8,0x6D,0xFA,0x7F};
//const uint8_t spVACUUM[] PROGMEM = {0x66,0x2B,0x2E,0xCC,0x98,0x12,0xBB,0xA3,0x4B,0x77,0x13,0xB7,0x5D,0x8E,0x6A,0x5C,0x43,0xAD,0xF5,0xEA,0x72,0x30,0x77,0xAB,0xD9,0xAB,0x29,0x3E,0x2C,0xAC,0x16,0xAF,0xA6,0xF8,0xB4,0xB4,0x5A,0xBC,0xEA,0x9A,0xDC,0xCA,0xBA,0xF6,0xA8,0x6B,0x11,0x0F,0xEB,0x50,0x08,0x9C,0xA2,0x54,0x85,0x6A,0x80,0x01,0x66,0x0C,0x56,0xC0,0x89,0xA5,0x06,0x98,0x21,0xB9,0x4D,0xCD,0x2B,0x6A,0xFB,0xA6,0x36,0x37,0xEF,0xC4,0xED,0x7B,0xDA,0xD6,0xAC,0xB3,0xB4,0xF6,0x69,0x7B,0xB5,0x2E,0x56,0xD2,0xBB,0x1C,0xD9,0x84,0x45,0x4A,0xD3,0x72,0x66,0x55,0x1E,0x2E,0xF1,0xCA,0xD5,0x94,0x5B,0x98,0x9A,0x29,0x77,0x17,0xAE,0xE1,0x1C,0x25,0x3D,0x4D,0xA6,0x85,0x8B,0x99,0xFF,0x07};
//const uint8_t spABEAN[] PROGMEM = {0xAD,0xCF,0x3E,0x25,0xAC,0x56,0xF5,0x7E,0xF6,0xAA,0x13,0xB6,0x4D,0xC3,0x6A,0xAB,0x41,0x9A,0x32,0x0B,0x4D,0xEC,0x06,0xA7,0x5D,0x33,0xDC,0xF1,0x1A,0x7A,0x74,0x61,0xE7,0x37,0xAB,0x1E,0xD1,0x19,0xD3,0xB6,0xAC,0x7A,0x3A,0x63,0xEC,0x58,0xB3,0x9A,0xE9,0x8D,0x68,0xA3,0xD2,0xEA,0x86,0x53,0xD2,0x8B,0xC0,0x63,0x9C,0x4E,0x49,0x2E,0x43,0x8F,0x65,0x68,0x65,0x3D,0x37,0xDD,0xB6,0x61,0x94,0x75,0x3D,0x54,0x39,0x9A,0x21,0xCB,0xB6,0x8A,0xE5,0xA9,0x8A,0xAD,0x4A,0x6C,0x97,0xA7,0x28,0xB6,0x4C,0x8D,0x5D,0xDE,0xAC,0xD8,0x2B,0x4C,0x4E,0x39,0x9B,0xE1,0x34,0x0A,0x25,0xE5,0xAC,0x4A,0x23,0xD1,0x94,0xA4,0xAB,0x19,0x4A,0x13,0x53,0x92,0xAE,0x66,0x38,0x92,0x55,0xCE,0xFF,0x03};
// ROM VM61005
//const uint8_t spATU[] PROGMEM = {0x29,0xE9,0x25,0x94,0x23,0xEA,0x8C,0x79,0x78,0x67,0xAE,0x5C,0xB3,0xE6,0x11,0x82,0x39,0xAA,0xF5,0x6A,0xA7,0x4F,0xA2,0xAC,0x25,0xBB,0x5D,0xD5,0x8C,0x45,0x18,0xB9,0x74,0xE5,0x33,0x35,0x62,0xE4,0x92,0x91,0x8D,0x2C,0x28,0x59,0x4B,0x10,0x38,0x45,0xA9,0x0A,0xD5,0x00,0x04,0x14,0xAA,0x62,0x80,0xAA,0x94,0x05,0xE0,0x34,0x65,0x0B,0x8B,0x22,0xAB,0xCD,0xC8,0x23,0x1D,0x45,0x90,0xB2,0xE6,0x8C,0x6C,0x66,0x41,0xAA,0x9E,0x33,0xB2,0x99,0x04,0xA9,0x7B,0x49,0xCB,0x66,0x64,0xE4,0x9E,0x25,0x25,0x9F,0x91,0x91,0x6B,0x16,0x97,0x62,0x46,0x46,0xEE,0x59,0x52,0x8A,0x11,0x09,0xB9,0x67,0x71,0x29,0x46,0x26,0x94,0xAE,0x25,0xAD,0x18,0x45,0x90,0x2A,0x9E,0x8C,0x7C,0x04,0x25,0x2A,0x5F,0x3B,0xF2,0x69,0x8D,0xA9,0x64,0xED,0x28,0xBB,0x56,0xD1,0xE2,0x2F,0xA3,0xAD,0xC2,0x4D,0x92,0xB7,0x94,0x21,0x49,0x37,0x4F,0xFA,0x12,0x06,0x17,0x2C,0x83,0x7D,0xB1,0x9A,0x64,0x33,0x75,0xCF,0x55,0x6A,0x12,0x25,0x3D,0x54,0x3B,0xBB,0x59,0x9B,0x49,0x73,0xF1,0xE2,0x56,0xA7,0x3A,0xC2,0xC5,0x8B,0x5B,0x03,0xEF,0x72,0x53,0xB5,0x7E,0x73,0x9B,0xD7,0x1D,0xA9,0xAC,0xF5,0xFF,0x01};
//const uint8_t spFSS[] PROGMEM = {0x6D,0xEE,0xC6,0x55,0x3A,0x56,0xAF,0xB1,0x79,0x17,0xEB,0x58,0xBD,0xEA,0x66,0x53,0x3C,0x63,0xF1,0x2A,0x6B,0x72,0x4D,0xEB,0xC6,0x2B,0x2B,0x45,0xC3,0x6C,0xA2,0x84,0x72,0xAA,0x60,0x13,0xB1,0x43,0x80,0x61,0x2B,0x28,0x40,0x80,0xE9,0x2B,0x08,0x30,0x5D,0x3A,0x01,0x9A,0x2D,0x43,0xE0,0x14,0xA5,0x2A,0x54,0x03,0x60,0xB4,0x2D,0x9A,0x84,0xF7,0xE2,0xD5,0xB4,0x60,0x92,0x51,0x8B,0x57,0xD5,0x5C,0xB2,0x47,0x2E,0x59,0x55,0x8D,0x6E,0x6E,0xBD,0x78,0x95,0x35,0x5B,0xB0,0x4F,0xEC,0x56,0x76,0x36,0xAC,0x16,0x35,0x05,0xF0,0x8C,0xAB,0x00,0x7E,0x4A,0x11,0xC0,0x6F,0xA5,0x12,0x50,0xC0,0x6F,0xA9,0x0A,0xF8,0xA5,0x4C,0x01,0x3F,0x97,0x21,0x70,0x8A,0x52,0x15,0xAA,0x01,0xCA,0xEF,0x51,0xD5,0xB5,0xB6,0x8E,0xBE,0x39,0xE7,0x8C,0x9C,0xBD,0xFA,0xEE,0x8A,0x3D,0xEC,0xF5,0xAA,0x9A,0x0F,0x8E,0x88,0x27,0xAB,0xAA,0xDE,0x25,0xA3,0xEE,0xAC,0xBA,0xC5,0x12,0xB7,0x78,0xB2,0xA6,0xA1,0x46,0x2C,0xF4,0xF3,0xD8,0xAB,0x2F,0x0E,0xEF,0xC7,0xE1,0xAE,0xDD,0x5D,0x74,0x13,0x0B,0xE0,0x19,0x57,0x01,0xFC,0x94,0x22,0x80,0xDF,0x4A,0x35,0xA0,0x80,0xDF,0x52,0x05,0xF0,0x4B,0x99,0x00,0x7E,0x2E,0x13,0xC0,0x4F,0x69,0x04,0xF8,0xAD,0x94,0x00,0xBF,0xBA,0xFF,0x3F};
//const uint8_t spILS[] PROGMEM = {0x66,0x0B,0x63,0x45,0x2F,0x27,0xB6,0x2D,0xB9,0x2B,0x0D,0x9F,0x3D,0x96,0xAC,0x76,0x34,0x6D,0xCD,0x18,0x2B,0xDF,0xB1,0xD2,0xB5,0xAB,0xAF,0xF2,0x52,0xCB,0xD6,0xAC,0xBA,0x89,0x0D,0x6F,0xFD,0xBC,0xAA,0xAE,0x46,0xA2,0xF4,0xD5,0x2A,0x9B,0x4F,0x2A,0x8F,0xC7,0xAB,0xE8,0x3E,0x31,0x22,0x16,0xAF,0xA2,0xDB,0xC0,0xC8,0x5C,0xBC,0xCA,0xEE,0x92,0x22,0x72,0xF1,0xAA,0x9A,0x2B,0x8A,0xC8,0x25,0xAB,0xAE,0xA6,0xA4,0x2C,0x1E,0xAF,0xBA,0x98,0xD1,0x52,0x7F,0xBC,0xAA,0xEC,0xC7,0x43,0x62,0x71,0xAB,0xA2,0x3D,0x73,0xC9,0x45,0xA5,0x8C,0xE6,0xD2,0xC9,0x16,0xA7,0x2A,0x98,0x73,0x63,0x5B,0x3C,0xAA,0x2C,0xCE,0x4D,0x6D,0xF5,0xAA,0xB2,0x1A,0x0D,0xCB,0xDB,0xAB,0xAE,0xAA,0x25,0x2C,0x1E,0xAF,0xAE,0x9A,0x92,0xF0,0x7C,0x3C,0x86,0xEA,0x8A,0xC3,0xEB,0x71,0x5B,0xAB,0x2D,0x8E,0xC8,0xC7,0xED,0xCC,0x26,0x35,0xB3,0x66,0x95,0xB7,0xD8,0xB0,0xD2,0x5A,0xDC,0xFE,0x1A,0x52,0x43,0x7B,0x76,0x7A,0x73,0x34,0x37,0xDF,0x58,0xEE,0xA8,0xD1,0x52,0x64,0x1D,0x19,0xE0,0x19,0x57,0x05,0xFC,0x94,0x62,0x80,0xDF,0x4A,0x2D,0x10,0x80,0xDF,0x52,0x1D,0xF0,0x4B,0x99,0x01,0x7E,0x2E,0xFB,0x7F};
//const uint8_t spIFR[] PROGMEM = {0x66,0x0B,0x63,0x45,0x2F,0x27,0xB6,0x2D,0xB9,0x2B,0x0D,0x9F,0x3D,0x96,0xAC,0x76,0x34,0x6D,0xCD,0x18,0x2B,0xDF,0xB1,0xD2,0xB5,0xAB,0xAF,0xF2,0x52,0xCB,0xD6,0xAC,0xBA,0x89,0x0D,0x6F,0xFD,0xBC,0xAA,0xAE,0x46,0xA2,0xF4,0xD5,0x2A,0x9B,0x4F,0x2A,0x8F,0xC7,0xAB,0xE8,0x3E,0x31,0x22,0x16,0xAF,0xA2,0xDB,0xC0,0xC8,0x5C,0xBC,0xCA,0xEE,0x92,0x22,0x72,0xF1,0x2E,0x57,0xDD,0xBC,0x4B,0x44,0x2F,0x5E,0x75,0x75,0x21,0x11,0x3D,0x7B,0x55,0xD5,0xA5,0x84,0xF7,0xEC,0x55,0xE5,0x50,0x9A,0xDE,0xB3,0x57,0x99,0x7D,0x99,0xCB,0xD4,0x4E,0x65,0x2A,0x25,0x69,0x19,0xC6,0x00,0xC3,0x56,0x28,0x60,0xFA,0x0A,0x05,0x4C,0x97,0xAE,0x80,0x66,0xCB,0x5A,0x13,0xCD,0xB6,0x2B,0x6F,0x1E,0x6D,0x32,0xD7,0xAA,0xBA,0x7A,0x74,0x49,0x5F,0x9B,0xE9,0xE6,0xD1,0x25,0x75,0x25,0xAE,0x5B,0xDA,0x10,0xDD,0x27,0x97,0x6F,0x6E,0x4B,0x74,0x97,0x5A,0xBA,0xB9,0xED,0xC9,0x5D,0x6A,0xEB,0xE6,0x72,0xC6,0x32,0xE6,0xAD,0x9B,0xD3,0x1D,0xE3,0xB8,0xAF,0xF4,0x4E,0x4F,0x4A,0x6D,0xBA,0xD2,0x27,0x3D,0x39,0xB5,0xDB,0x72,0x96,0xF4,0xA6,0x92,0x1A,0x27,0x7D,0xC2,0x9B,0xA7,0x4B,0xB5,0x76,0x36,0x5F,0xBE,0x12,0x23,0xBA,0x98,0x7E,0xFF,0x0F};
//const uint8_t spVFR[] PROGMEM = {0xE6,0xCC,0xC6,0x44,0x53,0xB3,0xB8,0x35,0x6B,0x53,0x4D,0xCD,0x1B,0x96,0x64,0x55,0x2D,0xB4,0xB3,0x5B,0x8B,0x31,0x15,0x53,0xCF,0x6E,0xEB,0xCA,0x59,0x54,0x1D,0x87,0x7D,0x5A,0x73,0x61,0x55,0x5C,0xA6,0xE9,0x5C,0x58,0x5C,0xCD,0x68,0x67,0x08,0x01,0xD3,0xB6,0xAB,0x9E,0xC1,0x18,0xDD,0x97,0xAC,0x6A,0xA6,0x20,0xD0,0x58,0xB2,0xAA,0x15,0x83,0xC0,0x62,0xC9,0x2A,0x67,0x0E,0xA4,0xC8,0x27,0xAB,0xEC,0x5E,0xC8,0xA3,0xE6,0xAC,0xAA,0x07,0x93,0xF0,0xBC,0xB3,0xEA,0x6A,0x43,0x32,0xE2,0xF1,0xAE,0x57,0x5B,0x7D,0x4A,0x5A,0x3C,0x5E,0x6D,0xF1,0x6E,0x21,0xB6,0xD0,0x00,0xC3,0x56,0x28,0x60,0xFA,0x0A,0x05,0x4C,0x97,0xAE,0x80,0x66,0xCB,0x5A,0x13,0xCD,0xB6,0x2B,0x6F,0x1E,0x6D,0x32,0xD7,0xAA,0xBA,0x7A,0x74,0x49,0x5F,0x9B,0xE9,0xE6,0xD1,0x25,0x75,0x25,0xAE,0x5B,0xDA,0x10,0xDD,0x27,0x97,0x6F,0x6E,0x4B,0x74,0x97,0x5A,0xBA,0xB9,0xED,0xC9,0x5D,0x6A,0xEB,0xE6,0x72,0xC6,0x32,0xE6,0xAD,0x9B,0xD3,0x1D,0xE3,0xB8,0xAF,0xF4,0x4E,0x4F,0x4A,0x6D,0xBA,0xD2,0x27,0x3D,0x39,0xB5,0xDB,0x72,0x96,0xF4,0xA6,0x92,0x1A,0x27,0x7D,0xC2,0x9B,0xA7,0x4B,0xB5,0x76,0x36,0x5F,0xBE,0x12,0x23,0xBA,0x98,0x7E,0xFF,0x0F};
//const uint8_t spVHE[] PROGMEM = {0x66,0xCD,0x32,0x1C,0x3D,0xD2,0xBA,0xB5,0x2A,0x77,0x74,0x4E,0x13,0xB6,0x2A,0x4D,0x45,0xCC,0x4D,0xD8,0xA6,0x0B,0x56,0x11,0xB5,0x65,0x9D,0xAE,0xDD,0x98,0xD9,0xB4,0x7E,0xDA,0x34,0x16,0xD5,0x36,0xEA,0x6A,0x99,0x2D,0x73,0xF5,0x2A,0x46,0x52,0xA2,0x88,0x25,0x2B,0x1F,0x99,0x89,0xA3,0x96,0xAC,0x74,0x24,0x41,0xAA,0x5E,0x32,0x92,0x11,0x08,0xB5,0x67,0xCE,0x48,0x66,0x64,0x94,0x9A,0x25,0x2B,0x9D,0x51,0x40,0x72,0xE6,0x34,0x6B,0x18,0x85,0xE8,0x99,0x12,0xE8,0xEE,0x05,0x32,0xEF,0x76,0x1B,0x46,0x72,0x34,0xED,0xD5,0x67,0x6E,0x56,0xB8,0xB3,0xAB,0x9C,0x76,0xFA,0x44,0xCD,0x58,0x72,0xCA,0x51,0x8C,0xCC,0x6B,0xC9,0x29,0x67,0x0B,0x50,0xAF,0x25,0x27,0x9F,0x5D,0xC1,0xA2,0x97,0xAC,0x62,0x76,0x03,0xB1,0x5E,0x52,0x9A,0x26,0x89,0xAD,0xB3,0xB1,0x00,0xBA,0x40,0x73,0xC0,0x69,0x29,0x0E,0x38,0x79,0x3B,0x01,0x2B,0x85,0x04,0x60,0x7A,0x21,0x04,0x4E,0x51,0xAA,0x42,0x35,0xA0,0x75,0xB3,0x08,0x72,0xF6,0x9C,0xD6,0xAC,0x64,0x88,0x59,0xB3,0x47,0xB3,0x4A,0x22,0x78,0x2E,0x19,0xED,0x6A,0x81,0x60,0xB5,0x64,0x74,0xAB,0x3A,0x60,0xD4,0x92,0xD1,0xAF,0x1A,0x40,0x5E,0xB3,0xC7,0xBC,0xA2,0x01,0x57,0xCF,0x6E,0xEB,0xCA,0x06,0x14,0x3D,0xBB,0x6C,0x2B,0x19,0x70,0xF6,0xA3,0xB4,0x4F,0xAF,0x20,0xDD,0xB3,0xC3,0x31,0x83,0x82,0xF4,0x3C,0x0A,0xE7,0x0C,0x0A,0xD2,0x73,0x2B,0x5C,0xB3,0x2B,0xB2,0xF7,0xEC,0x70,0xCF,0xE2,0xC0,0x5E,0x4B,0xC2,0xB3,0x52,0x02,0x79,0xBD,0x0E,0xEF,0xCC,0x0A,0x9A,0xB3,0xEA,0xFF,0x01};
//const uint8_t spLANDING_GEAR[] PROGMEM = {0x66,0x1F,0xC0,0xC7,0xD5,0xB2,0x85,0x2D,0xA1,0x4D,0x72,0xEF,0x54,0xD6,0x06,0xB2,0x59,0x3D,0xCB,0x98,0xAB,0x98,0x70,0xD5,0xC7,0x6B,0xA8,0xAA,0xDD,0x3D,0x1E,0xAF,0xAE,0xAB,0x56,0xCB,0x58,0xB5,0xAA,0xAE,0x8B,0x23,0x73,0xF1,0x2A,0xBA,0x2E,0xCE,0xAC,0xD9,0xAB,0x68,0xB6,0x39,0x35,0x67,0x97,0xA2,0x3B,0x28,0xD7,0xE0,0xE4,0xAA,0xAA,0x60,0x9C,0x43,0xA3,0xE9,0xAA,0xE2,0x0C,0x0A,0xD9,0x6D,0x9A,0xA2,0x58,0x2C,0x16,0xAD,0xB6,0x3B,0x65,0xD3,0x5E,0xBC,0xBA,0x11,0x14,0x2D,0x6A,0x76,0xEB,0x47,0x26,0xAA,0x0A,0x23,0x69,0xE8,0x0E,0xC6,0x4D,0xDD,0xA4,0xA1,0x19,0x1C,0x57,0x71,0xEB,0xC6,0xA2,0x68,0x45,0x25,0x8B,0x9A,0xA2,0xA4,0x75,0x71,0x2F,0x69,0x59,0x29,0x41,0x2D,0x92,0xA4,0x65,0x24,0x03,0xF1,0x5E,0x3D,0xA6,0x91,0x0C,0x25,0x6A,0xC9,0x18,0x47,0x74,0x94,0x8A,0x27,0x63,0x6E,0x3E,0x41,0xC7,0x3E,0xB7,0xA5,0xC5,0x01,0x19,0xDE,0x53,0xD6,0x5A,0x12,0x7C,0x78,0x4B,0x59,0x4B,0x2F,0xC8,0xA2,0x4D,0x65,0x2F,0xBD,0x20,0x1A,0x7F,0x97,0xB3,0xE4,0x06,0x5B,0xEA,0x52,0xAE,0x92,0x06,0x74,0x69,0x4F,0xB9,0xB3,0x6F,0x88,0x91,0xB4,0xE9,0xC9,0x25,0xA0,0x87,0x56,0xA5,0x27,0x97,0x80,0x4D,0xDE,0x1B,0xDE,0x3C,0x95,0xCB,0xC4,0xED,0xFF,0x03};
//const uint8_t spLEVEL_OFF[] PROGMEM = {0x66,0xC8,0xA0,0xCB,0x4C,0xDA,0x84,0x2D,0x81,0x6A,0x57,0x4D,0x1A,0xD7,0xB0,0x34,0x90,0xC3,0x6A,0xBD,0xD6,0x5C,0x58,0x87,0xB1,0xAC,0x59,0x7D,0xD1,0x9D,0x26,0xF1,0x64,0x35,0x55,0xB7,0x9B,0xC6,0x92,0x55,0x14,0x57,0xEE,0x52,0x8B,0x57,0x9E,0x6D,0x64,0x88,0x37,0x0E,0x55,0x91,0xE5,0xC1,0xE2,0x38,0x55,0x83,0x9B,0x85,0x6A,0xEC,0x96,0x67,0xD1,0x6D,0xA2,0x76,0x56,0x5A,0x68,0x4D,0x33,0x75,0x1E,0x69,0x23,0x36,0xA7,0xE0,0xB5,0xA5,0x85,0xFA,0x2E,0x61,0x97,0x94,0x45,0xEE,0xE7,0x68,0xAD,0x47,0x56,0xF0,0x74,0x13,0x77,0x1E,0x45,0x16,0xD3,0x4D,0xBC,0x69,0x94,0x49,0x6E,0x17,0x4B,0xEF,0x55,0x45,0x73,0x95,0x6C,0xBD,0x57,0x13,0xED,0x55,0xB0,0xF5,0x1E,0x7D,0x08,0x9F,0xC1,0xDE,0x7B,0x4C,0xD1,0x7E,0x06,0x7B,0x9E,0xB6,0x47,0x73,0x95,0xA2,0x79,0xC6,0x15,0xFD,0x65,0x88,0xF7,0x69,0x4F,0x0C,0x9B,0x21,0xD6,0xBB,0x3C,0xB1,0x8E,0x27,0xE5,0x2E,0x77,0xA5,0xE2,0x6B,0x5C,0x8D,0x08,0x30,0x6C,0x05,0x01,0xA6,0xAF,0x10,0xC0,0x74,0xE9,0x0A,0x68,0xB6,0x8C,0x01,0xDD,0x65,0x12,0xA0,0x9B,0xF4,0xFF,0x07};
//const uint8_t spUNDERCARRIAGE[] PROGMEM = {0x6D,0x4C,0x7A,0xCB,0xCA,0x3B,0xAF,0xAE,0xF2,0x29,0x2B,0xEB,0xBC,0xEA,0x26,0x26,0x24,0x75,0xF5,0xAE,0x57,0xD1,0x0C,0x87,0x8B,0xB9,0x69,0x59,0x55,0x54,0x2E,0xE1,0x3A,0x65,0x59,0x52,0x85,0x54,0x63,0x95,0x37,0x6B,0xC6,0x6C,0x6D,0x56,0x51,0x63,0x30,0x47,0xE4,0x5D,0x45,0x09,0x85,0xDA,0x9A,0x77,0x95,0xCD,0x2C,0xD2,0x88,0xBF,0xD2,0x74,0x3E,0x84,0xA3,0x79,0x54,0x57,0x8C,0xA2,0x67,0x64,0x01,0x03,0xCC,0x1A,0x12,0x80,0x61,0x0D,0x1D,0x30,0x43,0xD0,0x6A,0x9B,0x77,0xB2,0x8C,0xD5,0xAB,0xEB,0xBE,0x98,0xCB,0xB6,0xAC,0x7E,0xAA,0x76,0x1C,0xEF,0xBA,0x86,0x21,0x3B,0x70,0xB5,0xEF,0xDA,0x9A,0x1E,0xE7,0x95,0x7C,0x63,0xCF,0xD5,0xCC,0xCB,0xB2,0xB5,0x35,0x0F,0xF1,0x70,0xCB,0xDE,0xCE,0xD2,0x4C,0xDD,0x3C,0x7D,0xBB,0x8A,0x6F,0xB2,0xB2,0xED,0xE3,0xEE,0x76,0x84,0x53,0xBB,0x94,0xBB,0xEB,0x62,0x2E,0xDF,0x5D,0x9E,0xA1,0x52,0x38,0xBD,0x4B,0x78,0xA6,0x0E,0xE1,0xD0,0xAE,0x08,0x9C,0xA2,0x54,0x85,0x6A,0x80,0x00,0xBA,0x61,0x51,0xC0,0xEE,0x21,0x06,0x58,0x6D,0x47,0x3D,0x7D,0x4D,0xBA,0xA3,0x96,0xFF,0x07};
//const uint8_t spSPOILERS[] PROGMEM = {0x04,0xB8,0x81,0x51,0x00,0x7F,0xB8,0x28,0xE0,0x77,0x27,0x03,0xFC,0x5E,0x6C,0x80,0x7F,0x4B,0x0C,0xF0,0xA6,0x2A,0x02,0xA7,0x28,0x55,0xA1,0x1A,0x80,0x80,0x42,0x45,0x5B,0x9A,0x55,0xA6,0xBB,0x5B,0x6E,0x65,0xE2,0xB5,0xE6,0x98,0xAE,0x95,0x49,0xCE,0x8A,0x72,0xB6,0x91,0x47,0x35,0x2D,0xC1,0xD9,0x46,0x96,0xDC,0x98,0x26,0x6F,0x19,0x79,0x76,0xCD,0x56,0xBC,0x6A,0x55,0x45,0x0F,0xEB,0xC8,0xEA,0x51,0x55,0xD1,0xEA,0x29,0x9F,0x47,0x57,0x49,0xA5,0x27,0x76,0x2D,0x4B,0xA2,0xD3,0x66,0x92,0xAF,0xAC,0x59,0xB6,0xA5,0xE3,0x9A,0xB2,0xE6,0x98,0xA6,0x29,0x5D,0xCA,0x5E,0x4A,0x0B,0xB7,0xF8,0x2F,0x67,0xA9,0x83,0xD2,0xEA,0x2D,0xDD,0xA5,0x37,0x58,0xA9,0xFF,0xF4,0x96,0x19,0x68,0xA5,0x59,0xC3,0x5B,0x6A,0xA0,0xB6,0x66,0x0B,0x6F,0xF1,0x49,0xDC,0x9E,0x3D,0x7D,0x97,0x84,0x88,0x4B,0xDE,0xF4,0x5D,0xC4,0x6E,0x1E,0x6E,0xF2,0x57,0xFE,0xEF,0x23,0x4C,0x98,0x99,0x02,0xBE,0x47,0x12,0xC0,0x86,0x9C,0xFF,0x0F};
//const uint8_t spAIR_BRAKES[] PROGMEM = {0x6D,0x6E,0x56,0x38,0xAA,0x56,0x9E,0xAE,0xFB,0x60,0x2E,0xDF,0x72,0xEA,0x9E,0x82,0x24,0xED,0xCD,0x29,0x5A,0x2E,0xB2,0x94,0x27,0x2B,0xAB,0xDD,0xA8,0x5C,0x1E,0x8F,0xB4,0xB4,0x80,0x49,0x5E,0xDC,0xD2,0xDC,0x15,0x37,0x79,0x75,0xC9,0x52,0x57,0x9C,0xC2,0xD5,0xA6,0xE3,0x39,0xD9,0xC2,0xED,0xB0,0x55,0xA9,0x09,0x55,0xB7,0x83,0x00,0xE0,0x36,0x5A,0xDB,0x75,0xA5,0xA8,0x59,0x19,0x6D,0x4A,0x25,0x74,0xEC,0x7D,0x8D,0x25,0x96,0xD2,0x8A,0xF7,0xB5,0x34,0xDB,0x01,0xED,0xDE,0xD7,0xD2,0x6D,0x39,0x96,0x65,0x5F,0x47,0x0B,0xA5,0x94,0xDA,0x65,0x9C,0xDD,0x17,0x63,0xF9,0x9E,0xB2,0xD6,0x48,0x3C,0x5B,0xAB,0xEA,0x1A,0xFE,0x5E,0x05,0x2C,0x63,0x31,0x02,0xA7,0x28,0x55,0xA1,0x1A,0x40,0x80,0xA1,0xDA,0x11,0x50,0x6D,0xAB,0x02,0x9E,0x71,0x55,0xC0,0x4F,0x29,0x0C,0xF8,0xAD,0x94,0x02,0x08,0xF8,0x2D,0xF5,0xFF,0x01};
//const uint8_t spAERIAL[] PROGMEM = {0xA3,0x6F,0x41,0x59,0x27,0x56,0xAD,0xA6,0xC7,0x66,0x4E,0x6F,0xB3,0x8A,0xEE,0x86,0xB9,0xB5,0xCB,0xCA,0x4A,0x49,0xB6,0x92,0xBC,0x23,0xCB,0x8B,0xC3,0x82,0xB3,0xB4,0x2C,0x4D,0x6A,0x49,0xEA,0xDC,0xB2,0x34,0xA8,0x39,0x25,0xD7,0xC8,0xF3,0xA0,0x14,0xF3,0x2C,0xAB,0xAC,0xC5,0xC9,0x4D,0xB6,0xAC,0xA6,0xBB,0x44,0x69,0xDF,0xB2,0x86,0xE1,0x0A,0xB9,0x6C,0xF3,0x9A,0xBA,0x09,0xD4,0xF6,0xCF,0x6B,0x19,0x26,0x99,0x52,0xF7,0xAE,0xAD,0xD9,0x34,0x75,0xD9,0xD2,0xF6,0x6C,0xD2,0xD2,0xED,0x73,0x39,0x42,0xD8,0xA4,0xAA,0xCE,0xE9,0xF4,0x71,0xCB,0x34,0x7A,0xA5,0x33,0xA9,0x9E,0x34,0xCE,0x9C,0xAE,0x28,0x67,0x5C,0x25,0x6B,0xB8,0x82,0xEE,0x09,0xA5,0x7C,0xE6,0xF6,0xE6,0x86,0xD4,0x9A,0xFD,0x3F};
//const uint8_t spENGINE[] PROGMEM = {0xAB,0x1F,0xC1,0xC9,0x33,0x67,0xAD,0x7A,0x9A,0x64,0x9D,0x98,0xB5,0x8A,0xE1,0x8B,0x35,0x7D,0xD6,0xCA,0xBA,0x09,0x8E,0x8C,0xD9,0x2B,0xED,0x8E,0xD3,0xD4,0x13,0xAF,0xA4,0x19,0x4A,0x37,0x73,0xB5,0x92,0xAA,0xA8,0xCC,0xD4,0x75,0x4B,0xB3,0xA0,0x76,0x09,0xD7,0x2D,0x4F,0x82,0xCB,0xC2,0x13,0x8F,0x62,0x58,0x12,0xB5,0x4A,0xE5,0x80,0xC2,0x58,0x56,0x3F,0x63,0xB9,0x30,0xEB,0x59,0x7D,0x0B,0x2A,0x12,0xBE,0x7A,0x0D,0xDD,0x86,0x52,0xD8,0xD6,0xB5,0x76,0x9D,0xC6,0xA1,0x5B,0xD6,0x36,0x75,0xB8,0x04,0xF7,0x2D,0x47,0xB3,0xE4,0xA5,0x66,0xB7,0x9C,0x45,0xB2,0x97,0x58,0xD4,0x72,0x15,0xC5,0xD6,0xA2,0x71,0xEB,0x1D,0xEE,0xAA,0xB1,0x3C,0x5C,0x4D,0x78,0x9A,0xC6,0x08,0x0F,0x25,0xFF,0x0F};
//const uint8_t spFLAME_OUT[] PROGMEM = {0x04,0x18,0xB6,0x82,0x02,0x04,0x98,0xBE,0x42,0x00,0xD3,0xA5,0x2B,0xA0,0xD9,0xB2,0x56,0x65,0x29,0xEB,0xCC,0x59,0x57,0xD9,0x69,0x8F,0x18,0x65,0x59,0x79,0x17,0x1D,0xEA,0xB2,0x66,0x65,0xCD,0x84,0x44,0xC6,0xEC,0x95,0x76,0x67,0xE4,0x13,0x93,0x56,0xD6,0xAD,0x91,0xAF,0x55,0x1A,0x45,0xF7,0x64,0x69,0x96,0x64,0x54,0xD5,0xB0,0xA7,0x89,0xDD,0xD1,0x35,0xAD,0x92,0xC1,0x71,0x47,0xDF,0x44,0xA7,0x14,0x6F,0x1E,0x73,0xE3,0x5D,0xD6,0xB2,0x65,0xAC,0x8D,0x77,0x6B,0xE9,0x96,0xB6,0x37,0xD6,0xAD,0xAD,0x7B,0xDB,0x5E,0xC4,0xB4,0x96,0x75,0xE9,0x7B,0xBB,0xB2,0xDA,0xB2,0xD2,0xDD,0xE9,0x89,0x6E,0x22,0x42,0x5B,0xB9,0x2F,0xE4,0xAA,0x50,0x5B,0x84,0xC0,0x29,0x4A,0x55,0xA8,0x06,0x00,0x18,0x60,0x0A,0x75,0x01,0x3C,0x5F,0xF1,0xFF};
//const uint8_t spFLAK_LOAD[] PROGMEM = {0x04,0x18,0xB6,0x82,0x00,0xD3,0x57,0x08,0x60,0xBA,0x74,0x05,0x34,0x5B,0x96,0x9A,0x24,0x6D,0x43,0xD9,0x4D,0xE9,0xBD,0xEB,0x0A,0xD2,0x25,0xAB,0xCB,0x72,0xD3,0x8C,0x17,0xAF,0xBA,0xA8,0x0B,0x37,0x7B,0xB3,0xCA,0x62,0x47,0x23,0x72,0xC9,0xCA,0x8B,0x6F,0xAD,0xC8,0xC5,0x2B,0x2B,0x29,0xAC,0x2C,0x67,0x8F,0x2C,0x87,0xB4,0x52,0x2F,0x85,0xC0,0x29,0x4A,0x55,0xA8,0x06,0x08,0x20,0x1A,0x51,0x73,0xD4,0xD8,0x99,0x69,0x76,0x4C,0x1B,0xA5,0x4F,0x40,0x26,0x8D,0x63,0x9A,0x13,0x8D,0x1A,0xA2,0xD5,0x63,0x6E,0x38,0x3B,0x8D,0xBA,0xAC,0xA9,0x92,0xEA,0x30,0xEA,0xB2,0xE6,0x42,0xBB,0xCD,0xB4,0x4B,0x5B,0x92,0xD8,0x52,0xB3,0xDE,0x6D,0x4F,0x6A,0x22,0x94,0xF7,0x94,0x2B,0xA9,0x0D,0x33,0xED,0x1D,0xAE,0xE0,0xDA,0x0A,0xED,0x77,0x78,0xA2,0xAD,0x48,0x96,0x2E,0xE1,0x8B,0xB2,0x3D,0x55,0xBA,0xB8,0x3F,0xEA,0xD6,0x10,0xEF,0xEB,0xFE,0x1C,0xDC,0x54,0xBD,0x8B,0xFA,0x92,0x73,0x36,0xC9,0x34,0xEC,0xCB,0x86,0x2C,0xD0,0x57,0x93,0xDB,0x91,0xF4,0xC9,0x48,0x45,0xEF,0xB4,0x77,0x67,0xE4,0x62,0x5B,0xDC,0xD9,0x63,0x8A,0x88,0x6D,0xF9,0x7F};
//const uint8_t spINBOUND[] PROGMEM = {0xAA,0x1C,0x91,0xC9,0x6C,0x13,0x8F,0x7A,0x58,0x43,0xCD,0x9A,0x3D,0xCA,0xE9,0x92,0x38,0xE2,0xC9,0xC8,0x86,0x4B,0x66,0x8F,0x27,0x2B,0x9B,0x32,0x94,0xC3,0x6E,0xAF,0x64,0x38,0xB4,0x34,0x4F,0xB6,0x92,0x61,0xC9,0xD2,0xDD,0xD9,0x4A,0x9B,0xA4,0x34,0x73,0xC7,0x23,0x2B,0x82,0x2A,0xDC,0x1C,0xB7,0x3C,0x71,0x19,0x77,0x4F,0x9C,0x0A,0x2F,0xA5,0xD3,0xAC,0xB6,0x6B,0x85,0xD1,0x76,0xCE,0xD4,0xBE,0x5D,0x7D,0xD1,0x69,0x66,0xDC,0x78,0x35,0x45,0xB5,0x6B,0xCA,0xEA,0xD5,0x17,0xDD,0xEE,0x29,0x8F,0xD6,0x50,0xF4,0xB8,0x97,0xBE,0x5E,0x73,0x55,0xE3,0x5E,0xF2,0x7A,0x2D,0x55,0xAD,0x5B,0xCA,0xEB,0xB5,0x55,0xB9,0x29,0xA5,0x9B,0xD7,0xD9,0xF8,0x16,0x97,0x6E,0x59,0x67,0xD1,0x97,0x92,0xB2,0xBA,0x9D,0x59,0x5F,0x70,0xE9,0xAB,0x76,0x26,0xB7,0xEE,0x2E,0x8B,0xD2,0x19,0x4A,0x9B,0x59,0x2C,0x0E,0x67,0x28,0xA5,0xC1,0x55,0x39,0x5C,0x59,0x94,0x35,0x5B,0x95,0x70,0x55,0xCD,0xD1,0x12,0x6A,0xC2,0xD5,0x0C,0x79,0x4B,0x2A,0x35,0x57,0x91,0x14,0x43,0x51,0x47,0x5C,0x49,0x71,0x19,0x6D,0xAD,0xF4,0x0C,0x93,0x21,0xA6,0xA9,0xC7,0xD7,0x82,0x9B,0xB1,0xAF,0x09,0x77,0xCD,0xE6,0x42,0xDD,0xF8,0xFF,0x01};
//const uint8_t spIGNITE[] PROGMEM = {0x65,0x28,0x52,0xBD,0xBA,0x62,0xAF,0x61,0xC8,0x20,0xED,0x5C,0xBC,0x87,0xD5,0xF7,0x68,0xE0,0x15,0x77,0xDA,0xD0,0x8B,0x82,0x77,0x2C,0x72,0x53,0x92,0x22,0x93,0x52,0x1B,0x81,0x53,0x94,0xAA,0x50,0x0D,0x30,0x53,0x94,0x9C,0xA3,0xE1,0xBA,0x0C,0xCD,0x41,0xA6,0xB9,0x9B,0xD5,0xD5,0x10,0xE1,0xAC,0x4B,0x56,0x5D,0x7C,0x6B,0xB8,0xDE,0x19,0x75,0xF1,0xA3,0x9E,0x7A,0x67,0xD5,0xD5,0xB4,0x46,0xEB,0xED,0xD5,0x56,0x5F,0x9C,0x69,0x8F,0xCA,0xD0,0x82,0x51,0x67,0x4E,0xAA,0x43,0x19,0x5B,0x66,0x4A,0xAB,0xD9,0x08,0x9C,0xAA,0x54,0x85,0x6A,0x00,0x00,0x28,0x60,0x0A,0x75,0x02,0x3C,0x5F,0xF1,0xFF};
//const uint8_t spNO_TURN[] PROGMEM = {0x6A,0xF5,0x4C,0x63,0x52,0x6B,0x9B,0x35,0x70,0x89,0x09,0x5B,0xE4,0xD6,0xC8,0xC4,0xBB,0x64,0xB1,0x5B,0x33,0x11,0xAF,0xE2,0xC5,0x6D,0xE9,0x5A,0x4C,0x95,0xBA,0xAE,0xBE,0x78,0x4B,0xE3,0x78,0xB3,0xDA,0xAC,0x32,0xD2,0xE4,0xCD,0x2A,0xB3,0x9C,0x34,0xA3,0x2D,0x2B,0x8B,0x6C,0x53,0xC2,0x5A,0xB7,0xD4,0xAB,0xCD,0x30,0xDA,0x5C,0x52,0xAF,0x27,0xCC,0xAC,0xB3,0xAA,0x5C,0x12,0xCA,0x2E,0xD7,0x08,0x9C,0xA2,0x54,0x85,0x6A,0x00,0x04,0xE0,0x4A,0x53,0x0F,0x04,0x60,0x2A,0xB3,0x15,0x94,0x14,0xAC,0xA5,0x59,0x56,0x5A,0x62,0x91,0x2E,0x77,0x19,0x79,0x71,0x4D,0xFC,0x94,0x65,0xE4,0xB9,0x26,0xFA,0x51,0xE7,0x51,0xE6,0xD2,0x68,0xC7,0x9D,0x47,0x57,0xD2,0x90,0x1C,0x77,0x19,0x7D,0x0D,0xC3,0x7C,0xDC,0x65,0x2C,0xCD,0xAF,0xE0,0x72,0x96,0xB1,0x35,0x3F,0x82,0xAB,0x59,0xC7,0xD1,0x5C,0x0B,0x75,0xB8,0x1B,0x67,0x0B,0xA1,0x12,0xD1,0xB4,0x5C,0xCD,0xAB,0x84,0x4A,0xDD,0x72,0x37,0x6F,0x6E,0xA4,0x75,0xCA,0x53,0x0D,0x79,0xA9,0xC5,0x2D,0x4F,0x33,0xA2,0xA9,0x12,0x37,0xBD,0x3D,0x8A,0xB9,0x69,0xE3,0xF4,0x57,0x6B,0xEA,0x69,0x0B,0xD3,0xDF,0x82,0xAB,0xBB,0xAD,0xFE,0x7F};
//const uint8_t spFLAPS[] PROGMEM = {0x04,0x18,0xB6,0x82,0x00,0xD3,0x57,0x08,0x60,0xBA,0x74,0x05,0x34,0x5B,0xD6,0x8A,0xA2,0x65,0xD2,0xD8,0xED,0xE8,0xA2,0xE9,0x0E,0x92,0x36,0xAB,0x4D,0x6A,0xD3,0x55,0x16,0xAF,0x3A,0x9B,0x75,0x73,0x5F,0xBC,0xAA,0x1C,0xDA,0xCA,0x73,0xF6,0xAA,0x72,0x0C,0x6F,0xEB,0x29,0xAB,0xC9,0x31,0x6D,0xBC,0x27,0xB7,0x31,0xC5,0x88,0xB1,0x99,0xDC,0xCE,0x12,0xD3,0xDA,0x72,0x76,0xBF,0xC2,0x9D,0x93,0x7B,0x5A,0x2E,0x41,0xE0,0x14,0xA5,0x2A,0x54,0x03,0x00,0xC0,0x00,0xD1,0x88,0x32,0xE0,0x19,0x57,0x06,0xFC,0x94,0x42,0x80,0xDF,0x4A,0x29,0x40,0x80,0xDF,0x52,0xFF,0x1F};
//const uint8_t spEVACUATION[] PROGMEM = {0xA5,0xEF,0x4C,0x45,0xB6,0x16,0x95,0x71,0x6A,0x67,0xEC,0x5C,0xDD,0xC6,0x1E,0x9D,0xA8,0x6C,0x4B,0x58,0xAB,0x30,0x95,0x52,0xAF,0xE6,0x48,0x5C,0xD5,0xC3,0x93,0xB8,0xA3,0x6B,0x57,0x66,0x75,0xBA,0x86,0xEA,0x42,0xCD,0xB4,0xCD,0xEA,0x9A,0x2E,0xF1,0xB0,0xCD,0xAB,0xAB,0xAE,0x34,0x3D,0x56,0xAF,0xA6,0x86,0xD4,0xB2,0x5A,0xB4,0xAA,0x9A,0xCC,0xD2,0xAB,0xF6,0x2C,0x10,0x38,0x45,0xA9,0x0A,0xD5,0x00,0x03,0xAC,0xE8,0x6A,0x80,0x93,0x47,0x0C,0xB0,0x53,0x4A,0x2B,0x7A,0x74,0xE0,0xB4,0x35,0xAD,0x2A,0x34,0xC4,0x86,0xB7,0xA4,0xDA,0xF3,0x0D,0x09,0xDC,0x5C,0xDA,0xC0,0xAF,0x38,0xB8,0xF3,0xAA,0x93,0xD8,0xD0,0xA0,0xDE,0xAB,0x2A,0xB2,0xC5,0x92,0x37,0xAF,0xB2,0xF9,0x22,0x73,0xD9,0xBC,0x8A,0x1E,0x0D,0xDD,0x7D,0x75,0xA8,0x5A,0x20,0xF6,0xCA,0x45,0x0C,0x38,0x71,0x54,0x01,0xBB,0x6D,0x19,0x60,0x97,0xEB,0x00,0xEC,0xB2,0x16,0x80,0x95,0x2F,0xD6,0xD4,0x54,0xA8,0x94,0x77,0x6E,0x73,0xD3,0xA1,0x1E,0xB2,0xBA,0xAD,0xDD,0xB1,0x94,0x8B,0xB5,0xB1,0x77,0xCB,0x52,0xAE,0xD6,0xCA,0x31,0x9C,0x48,0xA8,0x45,0x4D,0xE7,0x70,0x46,0x61,0x12,0x2D,0x5D,0x53,0x3B,0x99,0x73,0xB4,0x74,0x0F,0xED,0x92,0xAA,0x51,0xD3,0xD3,0x5C,0xBA,0xAB,0xA5,0xF9,0x7F};
//const uint8_t spDOORS[] PROGMEM = {0x0A,0x28,0x30,0xAC,0x35,0x43,0x85,0x89,0x58,0xDE,0x51,0x67,0xED,0x6E,0xAE,0xAB,0x57,0x9D,0x44,0x87,0x26,0x77,0x1D,0x4D,0xA2,0x53,0x16,0xEC,0x6D,0x36,0xA5,0xF7,0x75,0xD4,0x93,0xBC,0xB5,0x25,0xB4,0xE6,0x4C,0xCE,0x9A,0xB6,0x50,0x9B,0x2A,0xA9,0x5F,0x3A,0xE2,0x70,0x69,0xC7,0x3E,0x69,0x8B,0xD3,0xB9,0x03,0xFB,0x86,0x2B,0xD5,0xC4,0x6C,0xF6,0x93,0x9E,0x5C,0x12,0xAA,0xC4,0x6F,0x7A,0xF2,0x34,0xF2,0x56,0xBF,0xE9,0xC9,0xCD,0x30,0xCA,0xFC,0xA5,0x27,0x17,0x65,0xAD,0xE8,0x13,0xDE,0xEC,0x44,0xC3,0x63,0xB3,0x79,0x93,0x15,0xF1,0xC8,0xD5,0xE9,0xBB,0x24,0x44,0x5C,0xF2,0xA6,0xFF,0x22,0x76,0xF3,0x70,0x93,0xFF,0xF4,0x7F,0x1F,0x61,0xC2,0xCC,0x14,0xF0,0x3C,0x92,0x06,0xFE,0x1F};
//const uint8_t spCABIN[] PROGMEM = {0x06,0x28,0x42,0xCD,0x01,0x23,0x8A,0x18,0xA0,0x1B,0xE5,0x55,0xB4,0x64,0x6A,0x1E,0x8B,0x57,0x59,0x83,0x6B,0x64,0x2C,0x5E,0x45,0xF1,0xA9,0x95,0xB1,0x78,0xE5,0x25,0x84,0x95,0xE5,0xEC,0x95,0x95,0x98,0x96,0x12,0xB3,0x4D,0x6D,0xBD,0xAB,0xBB,0xB5,0x32,0xAD,0x51,0x61,0xE1,0x9E,0x66,0x35,0xC5,0xBB,0xBA,0xC4,0xA2,0xD5,0x16,0x13,0x12,0x56,0xB3,0xD7,0xD8,0x8C,0x59,0xB0,0xD5,0x6C,0x63,0xB7,0xA8,0xE3,0x6E,0xAF,0x8D,0xC3,0x12,0xB7,0x9B,0xB5,0x32,0x37,0x45,0xB2,0xAE,0xD6,0xEB,0xE2,0x56,0x2F,0x35,0x4B,0xAA,0x8C,0xD8,0x94,0xC8,0x8C,0x4C,0x27,0xFF,0x0F};
//const uint8_t spARRIVAL[] PROGMEM = {0x65,0x4D,0x66,0xD3,0x8A,0xBB,0x8C,0x25,0xF9,0x49,0x29,0xCD,0x37,0xE6,0x58,0xC3,0x6D,0xD8,0x5F,0x98,0xFD,0x64,0xCF,0x62,0x7D,0x6E,0xB6,0x57,0x34,0xCA,0xD4,0xB9,0xC9,0x1C,0x15,0xEF,0x60,0x96,0x46,0xBF,0xD9,0xA2,0x45,0xEB,0x18,0x62,0xF1,0xF0,0x61,0x3D,0xAB,0x4B,0x76,0x23,0x42,0xF3,0xAC,0x26,0xEB,0xF5,0x4C,0xD9,0xB4,0x8A,0x1C,0xCA,0xCA,0x62,0xD5,0x4A,0x4B,0x74,0x6D,0xAB,0xD9,0x2B,0xA9,0xC1,0xB4,0xBD,0x26,0xAF,0xB8,0x65,0x93,0xD0,0x98,0xD5,0xD2,0xEC,0x54,0xC3,0x74,0x51,0x28,0x8A,0x74,0x09,0x63,0x37,0xA1,0x9F,0xCA,0xD4,0xD5,0xAC,0xA4,0xBE,0xF3,0xF0,0x74,0xB6,0xDD,0xFA,0xCC,0x7A,0x42,0x31,0x4B,0xEB,0x2B,0xAA,0x2D,0xC1,0x6C,0x6D,0x68,0x30,0xB7,0x15,0xB2,0xB7,0xB1,0xC3,0x9C,0x56,0xC8,0xDF,0xA6,0x06,0x6A,0x52,0x31,0x6F,0x9F,0xCA,0xD2,0x41,0x4E,0x18,0xF7,0xFD,0x7F};
//const uint8_t spACKNOWLEDGE[] PROGMEM = {0xAD,0x2E,0xB6,0xD4,0x27,0x26,0xAD,0xA9,0x9A,0x56,0xEF,0x78,0xBC,0xC6,0x66,0x5B,0xAD,0xFD,0xCD,0x1A,0x9A,0x1F,0xF1,0xF2,0xD7,0x6B,0xA8,0x3D,0xA9,0x24,0x66,0x23,0x70,0x8A,0x52,0x15,0xAA,0x01,0x40,0x80,0xA8,0xDC,0x43,0x1E,0xA5,0x78,0xAB,0x27,0x29,0x5D,0xD1,0xE8,0xEB,0x52,0x77,0xF4,0xD5,0x91,0x27,0x5B,0xD2,0xD5,0x55,0xD5,0x66,0xC1,0x8F,0x57,0x53,0x45,0xA7,0x25,0x6D,0x5E,0x75,0x56,0x9B,0x1E,0xBC,0x65,0x55,0x59,0x5F,0xBA,0xEB,0xEE,0x95,0x25,0x7F,0x11,0x6A,0xAB,0x47,0x1A,0xC2,0x64,0x41,0x36,0x1E,0x49,0x46,0x1F,0x6E,0xD2,0x69,0xC5,0x29,0xB4,0x15,0x4D,0xED,0x15,0x97,0x98,0x9A,0x3C,0xB5,0x57,0x5C,0x7D,0x72,0x48,0xCD,0x5E,0x49,0xB5,0x2A,0x69,0x3D,0x5B,0x25,0x56,0x5A,0x45,0x67,0x0C,0x91,0x09,0x63,0xD5,0x59,0x16,0x53,0xB5,0x33,0xA3,0x68,0x74,0x49,0xD7,0x8C,0xA4,0xAC,0xDE,0x24,0x5D,0xAB,0x96,0x02,0x8A,0x5D,0x03,0x34,0x4E,0xE4,0x80,0xD9,0xD2,0xFF,0x1F};
//const uint8_t spRAISE[] PROGMEM = {0x62,0x63,0x65,0x45,0xC3,0xED,0xAA,0x55,0x2C,0x67,0xCF,0x70,0x9A,0x06,0xDB,0xD9,0xBD,0xC5,0xEF,0x68,0x52,0xE7,0xB0,0x94,0x6C,0xAB,0x2A,0x39,0x54,0x53,0xBA,0xAE,0xB2,0xF9,0x66,0x49,0x5D,0xBD,0x8A,0xEE,0x8A,0x24,0xED,0xF1,0xAA,0x86,0x2B,0x92,0xF4,0xC5,0xAB,0x1B,0x26,0x50,0x3B,0x16,0xAF,0xBE,0x1B,0x43,0xEF,0x5A,0x3C,0xA6,0xE1,0x0C,0xAC,0x6B,0xF6,0x58,0x7A,0x64,0xF4,0xEA,0xD9,0x65,0x1D,0x41,0x41,0xAB,0x1E,0x97,0x6D,0x24,0x43,0xCE,0x5A,0x5C,0xF6,0xEE,0x04,0xAD,0xEA,0x71,0x78,0xBA,0x57,0x34,0x8F,0xD7,0xEE,0x69,0x5A,0xD1,0xC3,0x3F,0x9B,0xBF,0x48,0xA3,0xF4,0x58,0xEC,0xFE,0x6A,0x8D,0x4D,0x62,0x75,0x5A,0x2F,0x09,0x11,0x97,0xBC,0x61,0xBD,0x88,0xDD,0x3C,0xDC,0xC4,0xB5,0xEC,0xDF,0x47,0x98,0x30,0x33,0x05,0x7C,0x8F,0x24,0x80,0x0D,0x39,0xFF,0x1F};
//const uint8_t spLIST[] PROGMEM = {0x66,0x19,0x98,0xB2,0x8C,0xDB,0x85,0xB5,0x43,0xEE,0x22,0x5B,0x93,0x96,0x0E,0x75,0x0C,0x63,0x75,0x9B,0x36,0xC3,0x2E,0x96,0xB5,0xA3,0x3F,0x9C,0x3A,0x50,0xDA,0xAE,0xBA,0x9A,0x74,0x15,0x5B,0xB3,0xCA,0x26,0x4B,0x25,0x74,0xCD,0x2A,0xBB,0x2A,0xD1,0xD0,0x35,0xAB,0xAA,0x3A,0x24,0x3C,0x16,0x8F,0xA5,0x58,0x97,0xB0,0x9A,0xD5,0xF6,0x12,0x5D,0x4D,0xBA,0xB4,0x01,0x9E,0x71,0x55,0xC0,0x4F,0x29,0x06,0xF8,0xAD,0xD4,0x02,0x01,0xF8,0x2D,0xD5,0x01,0xBF,0x94,0x19,0xE0,0xE7,0x32,0x04,0x4E,0x51,0xAA,0x42,0x35,0x00,0x14,0x30,0xA4,0x1B,0x03,0x36,0x57,0xFB,0x7F};
//const uint8_t spAPPROACH[] PROGMEM = {0xA9,0xCA,0xBA,0xCB,0x4D,0xB7,0x9C,0xA9,0x88,0x69,0x71,0xDB,0x7A,0x86,0xAC,0x37,0xC5,0x6D,0xF3,0x18,0x92,0x19,0x37,0x97,0xDE,0xB6,0x46,0xE0,0x14,0xA5,0x2A,0x54,0x03,0x10,0x10,0x98,0xA9,0x02,0x72,0x30,0x2B,0x49,0x0E,0x11,0x16,0xA6,0x64,0x64,0xB1,0x6A,0x4A,0x72,0x96,0x95,0x67,0x15,0x6D,0x21,0xE9,0x57,0x5E,0x44,0xA7,0x25,0xF6,0x5D,0x79,0xE1,0x9D,0x1A,0xD8,0x77,0x64,0x91,0x77,0x69,0x48,0x36,0x97,0x99,0xE4,0x16,0x11,0x99,0x11,0x38,0x45,0xA9,0x0A,0xD5,0x00,0x02,0xCC,0xAA,0xAA,0x80,0xD9,0x3A,0x1D,0x30,0xFB,0x4C,0x00,0x56,0x9F,0x72,0xC0,0x6C,0x33,0x01,0x98,0x7D,0x2A,0x00,0xB3,0x75,0x2A,0x60,0xF6,0x2D,0x06,0x8C,0x36,0xF5,0xFF};
//const uint8_t spDEPARTURE[] PROGMEM = {0x0A,0x28,0x30,0x6C,0x0C,0x4B,0x86,0xA3,0xD9,0xEA,0xD5,0x4D,0xE5,0xCA,0x6E,0x5B,0x56,0x37,0x6C,0x08,0x9B,0x6F,0x59,0x5D,0x31,0x26,0xE6,0xD1,0x09,0x81,0x53,0x94,0xAA,0x50,0x0D,0x20,0x80,0x37,0x2E,0xAD,0x09,0xF1,0xD8,0xDD,0x35,0xAD,0x22,0x8E,0xD2,0x4C,0xEE,0xB2,0x8A,0x14,0x56,0x7C,0xA9,0xCF,0xCA,0x72,0x1A,0xAE,0xA6,0xCD,0x2D,0x2B,0x35,0xB0,0x53,0x72,0x95,0xAC,0x66,0x56,0x71,0x4D,0x85,0xC0,0x29,0x4A,0x55,0xA8,0x06,0x10,0x60,0x56,0x55,0x05,0xCC,0xD6,0xE9,0x80,0xD9,0x67,0x46,0x53,0x3A,0x53,0x94,0x75,0x2D,0x6D,0x1E,0x4C,0x95,0xFC,0xB9,0x8D,0xB9,0x28,0xC6,0x70,0x9F,0x36,0x97,0xAC,0xE8,0x63,0xF9,0xD2,0x5A,0x3A,0x4A,0x78,0x6C,0x65,0x87,0xD1,0xE2,0xEB,0x19,0xF3,0xFF,0x01};
//const uint8_t spCLEARANCE_DELIVERY[] PROGMEM = {0x02,0xC8,0x71,0xD2,0x03,0x06,0x18,0xCA,0xA7,0x25,0x95,0x44,0x9B,0x59,0x92,0x95,0x55,0x1B,0x6E,0x26,0x6B,0x56,0xDE,0x42,0x09,0x05,0xAF,0x5D,0x79,0x33,0xA5,0xD8,0xBA,0x6D,0xE4,0x39,0x71,0x58,0x4A,0xB7,0x96,0xA5,0x4A,0xE9,0x12,0xCE,0x46,0x96,0x8B,0x94,0x58,0xB8,0x5D,0x69,0x0E,0x5A,0xEA,0x91,0x7A,0xA5,0xC5,0xBA,0x7B,0xF8,0xA2,0x96,0x65,0x29,0xD9,0xE2,0x71,0x43,0x5A,0x04,0xD6,0x8A,0x25,0x49,0xC5,0x12,0x26,0xAA,0xE6,0xC4,0x00,0x3F,0x84,0x58,0xC0,0x01,0x7F,0x66,0x18,0xE0,0x19,0x57,0x04,0x4E,0x51,0xAA,0x42,0x35,0x20,0x00,0x4B,0x84,0xAF,0x62,0x09,0x0D,0x0E,0xE9,0xBB,0xB2,0xC6,0x22,0xC4,0x65,0xCB,0x28,0x26,0x96,0x31,0xB2,0xAD,0xAD,0x9C,0x50,0xD7,0xC0,0xB6,0xAC,0x62,0x62,0x6D,0x13,0x6D,0xBB,0xF2,0x26,0xCB,0x55,0x75,0xF5,0xCA,0x9B,0x2A,0xE3,0xB0,0x35,0x2B,0x2F,0xAE,0x94,0x53,0xDA,0xA4,0x22,0x59,0x0D,0x0D,0xB5,0xA3,0xFA,0xA0,0xCB,0xC5,0x5C,0x89,0x5A,0x12,0x0B,0x77,0x73,0x55,0x61,0x0F,0x93,0x2D,0x52,0xB5,0xA6,0x29,0x0E,0x2C,0x2D,0xCE,0xD2,0x96,0xDC,0x38,0xB9,0xA5,0xCB,0x58,0x73,0x52,0xB3,0x8C,0xAE,0x63,0xAF,0xAE,0x48,0xCB,0x37,0x8F,0xBB,0x59,0xC7,0xA8,0xD8,0x5C,0x9E,0x61,0x82,0xA4,0x7C,0x75,0xFA,0xBB,0x74,0x92,0xCD,0x55,0xE1,0xEF,0xDA,0x50,0x27,0x5F,0xA5,0x7F,0x8C,0x60,0x56,0xDF,0x6A,0xFE,0x3E,0xD9,0xD5,0x72,0xD2,0xFF,0x03};
//const uint8_t spFUEL[] PROGMEM = {0x04,0x98,0xB6,0x52,0x00,0xCD,0x85,0x29,0x60,0xF8,0x32,0x01,0x0C,0xDF,0xC1,0x01,0x97,0xCE,0xB1,0x29,0x81,0x8C,0x4B,0xDE,0x93,0x22,0x85,0xAF,0x19,0xF9,0x70,0x41,0x58,0xB6,0x75,0xA4,0x9D,0x9A,0x49,0x71,0xB7,0x96,0x16,0x5A,0x21,0x01,0x79,0x5A,0xDA,0x70,0x94,0x37,0xF8,0x2B,0x79,0xA6,0x51,0x55,0x90,0xB7,0xE4,0x99,0x59,0x77,0x90,0xB7,0x56,0x55,0x2A,0x3D,0x49,0xEA,0x5A,0x5D,0xA9,0xCC,0x04,0xBA,0x6B,0x6D,0xA5,0x3C,0xE3,0x98,0xAE,0xF4,0x95,0xC9,0xB6,0x60,0x97,0xD4,0x17,0x2A,0x5B,0x8C,0x5D,0xD2,0x98,0x49,0xF4,0x10,0x77,0x0E,0x63,0x05,0x55,0x25,0xB8,0xFB,0xFF,0x01};
//const uint8_t spIDLE[] PROGMEM = {0x61,0x89,0xEE,0x3C,0xD2,0x57,0xB7,0x3E,0xAB,0x0B,0x2B,0xDB,0xBC,0xDA,0x1C,0x56,0xA3,0x7C,0xF1,0xAA,0x4B,0x4C,0x4B,0xF3,0xC5,0xAB,0xAC,0x21,0x29,0xD3,0x57,0xAF,0xB2,0x87,0x42,0x0F,0x5F,0x32,0xCA,0x1A,0x9D,0xDC,0xBC,0xB5,0x02,0x0A,0x0C,0x1B,0x53,0xB6,0xAE,0xC9,0xDE,0x79,0x8D,0x1D,0x55,0x46,0x70,0x9F,0x31,0x0F,0x50,0x95,0x41,0x79,0xDB,0xD6,0x41,0x75,0x3B,0xF9,0x6B,0x47,0x26,0xDB,0x25,0x9C,0x25,0xDD,0x89,0x7F,0x05,0x73,0x9F,0x70,0x07,0x73,0xE9,0x64,0xBD,0xC3,0x1F,0xCC,0x56,0xB0,0x74,0x72,0xBF,0x77,0x17,0x22,0xDE,0xE9,0xFF,0x01};
//const uint8_t spINCREASE[] PROGMEM = {0xAD,0x6F,0xD4,0xC4,0x2F,0x63,0xAD,0x7E,0xEA,0x60,0xEA,0x58,0xBD,0xFA,0xE1,0x92,0x25,0xE3,0xD1,0xEA,0xBA,0x31,0xF6,0xB4,0x59,0xA5,0xAB,0x06,0xB3,0x5C,0x9D,0x94,0xAE,0x6A,0xF2,0x49,0x51,0x12,0xFA,0xA4,0xA8,0x57,0x45,0x29,0x02,0xA7,0x28,0x55,0xA1,0x1A,0x40,0x80,0xDC,0x57,0x05,0x90,0x72,0x99,0x02,0xF2,0xA8,0x68,0x69,0x2A,0xEC,0x52,0xD6,0x75,0x65,0x25,0xAA,0x4A,0xCA,0xD6,0x95,0xF4,0xEC,0xC2,0x2E,0x6B,0x46,0xDC,0x13,0x91,0x47,0x2D,0x29,0x71,0x73,0x28,0x99,0xB3,0xA4,0x44,0x53,0x28,0x49,0x7A,0x17,0x05,0x3C,0xE3,0xAA,0x80,0x9F,0x52,0x0C,0xF0,0x5B,0xA9,0x05,0x0C,0xF0,0x5B,0x2A,0x03,0x7E,0x29,0xFB,0x7F};
//const uint8_t spUP[] PROGMEM = {0x69,0x2C,0x6A,0x32,0xCC,0x97,0xAC,0xA1,0xC8,0x4D,0x37,0x5F,0xB3,0xFA,0xA2,0x36,0x42,0x63,0xC9,0x6A,0x93,0x9B,0x08,0xCD,0x25,0xAB,0xCD,0x76,0x32,0x25,0x96,0x94,0x21,0x96,0x4A,0x97,0xB9,0xE3,0xA6,0xD0,0x3D,0x2C,0xF6,0x0A,0x02,0xA7,0x28,0x55,0xA1,0x1A,0x00,0x00,0x04,0x70,0x2E,0x44,0x00,0x39,0xB9,0x23,0x20,0x35,0xD7,0xFF,0x07};
//const uint8_t spTAXI[] PROGMEM = {0x0A,0xD8,0x5C,0x4D,0x03,0x23,0xA8,0xD6,0x34,0x2C,0x1A,0xAD,0xAA,0x84,0xB4,0x48,0x5F,0xB2,0x9A,0xAA,0xDB,0xBD,0x75,0xCD,0x6A,0x9A,0x6D,0x8D,0xB6,0xD5,0xAB,0x69,0xA5,0xA8,0x3C,0x1A,0x81,0x02,0x6A,0x28,0x33,0xC0,0x4B,0xE5,0x0E,0x78,0xCE,0x4C,0x01,0xAF,0x86,0xA7,0xE2,0x59,0x37,0x96,0x70,0xD3,0xCA,0x6E,0x9D,0xD4,0xED,0x4D,0xAB,0xBA,0x36,0xD4,0x8A,0x37,0xAD,0x1C,0x4E,0xD1,0xAB,0x16,0xB7,0x72,0x78,0x81,0xC8,0x9A,0x5D,0xCA,0xE1,0x15,0xA2,0x66,0x51,0x2A,0x46,0x50,0xF0,0x98,0xC5,0xA1,0x68,0x8A,0x79,0xB2,0x43,0xA9,0xA2,0x7B,0x45,0x31,0x8F,0xFD,0xFF};
//const uint8_t spAS[] PROGMEM = {0x63,0xAF,0x26,0xC4,0x33,0x6B,0xAF,0xB9,0xCA,0x92,0xEC,0xB8,0xB5,0xE6,0x66,0x4A,0xBC,0xFC,0xF1,0x9A,0xBA,0x6A,0xF1,0xF2,0xC7,0x6B,0x6A,0xB2,0x25,0xD2,0x1F,0xAD,0xB1,0xAA,0xE2,0xB0,0xBC,0xDD,0xE6,0xA2,0x42,0x82,0x73,0x51,0x59,0x16,0x35,0x35,0xD7,0xBE,0x0E,0x58,0x80,0xDC,0x00,0x9F,0x22,0xFF,0x3F};
//const uint8_t spCONVERGING[] PROGMEM = {0x0C,0x28,0x65,0xCD,0x03,0xAD,0x28,0xB1,0x99,0xC2,0x1A,0xAD,0xB2,0xEA,0x32,0x4D,0xDD,0xB2,0x9A,0x46,0x33,0xB4,0x6D,0x75,0x6B,0xAA,0x22,0xDD,0xE4,0xBA,0xA3,0x6B,0x82,0x65,0x42,0xE2,0x8D,0xAE,0x72,0xD5,0x74,0xA9,0x92,0xC6,0x68,0x4C,0xD3,0xC4,0xA9,0x59,0xBD,0x2A,0xD3,0x74,0x27,0x65,0x6B,0x3A,0x4C,0x45,0x1D,0xB7,0x3E,0xC5,0xA4,0x28,0xCE,0xBA,0xDA,0x94,0x03,0x63,0x28,0xEF,0xAA,0x8A,0x5B,0xC6,0x53,0xFD,0xAB,0x6C,0x6A,0x1D,0x46,0xB5,0xAF,0xA2,0x74,0x23,0x0D,0xCD,0x5E,0xAA,0x3A,0x48,0x84,0x23,0x59,0x68,0x9A,0x62,0x11,0xCF,0x2C,0x09,0x98,0x82,0x69,0xD5,0x2B,0xA5,0x90,0xA9,0xB7,0x55,0x34,0x6B,0xC2,0x15,0xAD,0x57,0x31,0x62,0x08,0xA5,0xAD,0x19,0x65,0x6F,0x42,0x9A,0x3E,0x6B,0x94,0xCD,0x61,0x66,0xB8,0xD9,0x51,0x56,0x4D,0x95,0x66,0x6A,0x5A,0x59,0x25,0x55,0x9A,0xA9,0xF9,0x7F};
//const uint8_t spABOVE[] PROGMEM = {0x6D,0x89,0x6E,0x33,0x43,0x5B,0xAD,0x29,0xEB,0x09,0x77,0xDB,0xB4,0xA6,0x2C,0x27,0x2D,0xB4,0x73,0x1A,0xA3,0x2A,0x37,0xA1,0x9D,0x66,0x51,0xBE,0x54,0xCC,0x5B,0x99,0xC5,0xD8,0x52,0x15,0xDF,0x64,0x56,0x61,0xCA,0x45,0xBD,0xF5,0xEA,0x1A,0xAF,0x0A,0xA3,0x2C,0xAB,0x2B,0x72,0xCA,0x54,0x36,0xAF,0x2E,0xEB,0x4D,0x67,0xDB,0xB4,0xBA,0x6C,0x36,0x82,0x6D,0xD5,0x6A,0xB3,0xBC,0x70,0xB6,0x4D,0xAB,0x4D,0xB6,0xC2,0x59,0x17,0xA5,0x2E,0xE9,0xF4,0x60,0x69,0xE9,0xE6,0xCC,0xC2,0xCC,0xC4,0xB5,0x5B,0xB7,0x0D,0x13,0x61,0x25,0xFF,0x0F};
//const uint8_t spBRAKE[] PROGMEM = {0x6C,0xE5,0x7C,0xBC,0x3D,0x2D,0x91,0x8D,0xA8,0xC9,0x34,0x77,0x64,0x36,0x4F,0xD2,0xDD,0xC3,0x49,0x39,0x62,0x08,0x97,0x14,0xE5,0x63,0x88,0xC5,0x4C,0x93,0xDD,0xAF,0x3E,0x35,0x0B,0x4D,0xCA,0xBE,0xDA,0x1C,0x52,0xB5,0xAD,0xFB,0x6A,0x9B,0x2E,0xE5,0xD5,0x2D,0xAB,0x19,0xB2,0x94,0xC6,0xB7,0xAC,0x66,0xD8,0x64,0x6E,0x5B,0xBD,0x9B,0xD2,0x0C,0x1B,0x44,0x13,0xAF,0x11,0x38,0x45,0xA9,0x0A,0xD5,0x00,0x10,0x40,0x9D,0x43,0x0C,0xA8,0xCB,0x98,0x03,0xFF,0x0F};
//const uint8_t spCALM[] PROGMEM = {0x06,0x28,0x2D,0xC9,0x00,0xA5,0x3B,0x2B,0x20,0x16,0xE6,0x51,0x25,0xB7,0xA1,0xA9,0x99,0x4F,0x9D,0xCD,0x96,0x24,0x77,0x59,0x4D,0xE1,0xDB,0x5C,0xDA,0x65,0x34,0xC9,0x5C,0x71,0xD9,0xAA,0xD1,0x46,0x77,0x29,0xE5,0x8D,0x5B,0x17,0xE2,0x85,0x74,0x34,0x1E,0x73,0x0C,0xE7,0xDA,0xD1,0xA8,0x1C,0x21,0x9D,0x4B,0x47,0xE3,0x72,0x86,0x78,0xA1,0xE5,0x8D,0xCB,0x15,0xF2,0xB9,0x94,0x37,0x2E,0x57,0x8C,0x1B,0x16,0xDA,0xBA,0xDC,0x99,0x6F,0x84,0x49,0x92,0xF4,0x14,0xC5,0x96,0xA9,0xB1,0xD3,0x9B,0x15,0x7B,0x85,0xC9,0x49,0x67,0x55,0x1A,0x89,0xA6,0x24,0x9F,0xE9,0x6A,0x86,0xD2,0xC4,0x94,0xA4,0xAB,0x19,0x8E,0x64,0x95,0xF3,0xFF};
//const uint8_t spBREAKING[] PROGMEM = {0x04,0x50,0xD6,0x2C,0xB5,0xA1,0xB8,0x5A,0x9A,0xFB,0x35,0xE4,0x14,0x21,0x69,0xEA,0x57,0x97,0x8B,0x87,0x84,0xE5,0x5B,0x6D,0x33,0xC9,0xD6,0xB6,0x65,0xD5,0x23,0x14,0x72,0xD9,0xEA,0x52,0x8D,0x2B,0x24,0x92,0x4B,0x58,0xD3,0x85,0x92,0x86,0xB9,0x26,0xC0,0xB4,0xCA,0x0E,0x98,0x4C,0xA4,0x24,0x3B,0x36,0x2B,0xAB,0xD3,0x55,0x8E,0xC4,0xA4,0xD5,0xB3,0x47,0x3D,0x22,0x51,0x74,0x95,0x1E,0x75,0x0F,0x68,0x5D,0x66,0x76,0xD4,0xDD,0x60,0x64,0xA8,0x9A,0xD1,0x0C,0x8B,0x9E,0x69,0x4A,0x5B,0xDB,0x35,0x66,0xBA,0x39,0x69,0x43,0xD3,0x18,0xE3,0xAA,0x34,0xB5,0x4D,0xA3,0x6D,0x85,0x99,0xFF,0x07};
//const uint8_t spCALL[] PROGMEM = {0x0C,0x48,0xE9,0x59,0x00,0xD9,0x3D,0xB5,0xBD,0xE8,0x55,0x33,0x69,0xBC,0xDA,0x64,0xD6,0xC2,0x24,0xD7,0xE8,0x83,0xDF,0x34,0xD7,0x3E,0x63,0xF4,0x71,0xC3,0x42,0xB3,0xB6,0xC9,0xD7,0x75,0x73,0xEB,0xDA,0x56,0x5F,0x36,0x5C,0xAD,0x6F,0xDB,0x7C,0x9E,0x4C,0xF1,0x5C,0x65,0x0F,0xAD,0xD3,0xD9,0x7A,0x96,0xDD,0xED,0x51,0x97,0xEE,0x95,0x0E,0xB7,0xC7,0x5C,0x7A,0x77,0x3A,0xDD,0x1E,0x0D,0xDE,0x4D,0xE9,0xB2,0xFD,0xD4,0xA4,0x77,0xA7,0xCB,0x97,0xAE,0x80,0xDC,0x9D,0xEE,0xE0,0x6A,0x95,0x35,0x4B,0x7A,0x82,0xD9,0x68,0x90,0x2E,0xFF,0x0F};
//const uint8_t spCROSSWIND[] PROGMEM = {0x08,0x08,0x75,0x85,0x01,0xC1,0x6F,0x38,0xA0,0xEA,0xE2,0x92,0x66,0x5F,0xA9,0x56,0x72,0x47,0x19,0xAA,0x95,0x16,0xB7,0x5E,0x75,0xC8,0x55,0x1E,0xD2,0x6D,0x35,0xD1,0x5E,0x69,0x72,0x97,0x55,0x47,0xFD,0x29,0x29,0x9B,0x47,0x15,0xC2,0xAB,0xA5,0x6F,0x2A,0x55,0xC8,0xAD,0x25,0xD1,0x48,0x01,0x7F,0x19,0x79,0x20,0x00,0xBF,0x85,0x18,0xE0,0xBF,0x10,0x03,0x14,0x5D,0x65,0x0A,0x67,0xC6,0x2D,0x25,0x89,0x99,0x9C,0xB8,0xC1,0xE0,0xC4,0x69,0xF0,0x62,0x8B,0x93,0xBB,0xAC,0xBE,0xB0,0x72,0x6A,0xD9,0x72,0xBA,0x26,0x43,0x75,0x64,0xD1,0x6A,0x1B,0x77,0xD3,0xB5,0x59,0xAB,0x2D,0xD2,0xCD,0xC7,0x2A,0x8D,0xB6,0x49,0x89,0x50,0xAF,0x3A,0xDA,0x26,0xD9,0xD3,0x2D,0x6E,0xE9,0x9A,0xC6,0xE8,0x30,0x7B,0xAE,0x4B,0x02,0x27,0xC5,0x93,0x94,0x71,0x47,0x0B,0x15,0x71,0xD2,0x86,0xC1,0xDC,0xC4,0xAC,0xF7,0xFF,0x03};
//const uint8_t spCRYSTALS[] PROGMEM = {0x08,0x88,0x5B,0x4A,0x00,0x39,0x67,0x96,0xAC,0xA4,0x70,0x11,0xF5,0xB2,0xAA,0x12,0x25,0xC4,0xAD,0xCB,0xAA,0xAB,0x2C,0xD1,0xB4,0x35,0xAD,0x6D,0x22,0xC4,0xC5,0x3B,0x05,0xE0,0x59,0x31,0x05,0xBC,0x97,0xCC,0x80,0x1D,0x19,0x15,0x70,0x92,0x49,0x89,0x7F,0xF0,0x0C,0x55,0xA7,0xAD,0x2A,0x34,0x53,0x5C,0xD6,0xB4,0xB6,0x21,0x1F,0x0B,0xEA,0xD2,0xDA,0x8A,0x7C,0xDC,0xA8,0x4B,0x6B,0x1B,0xF2,0x71,0xC5,0x3E,0xAD,0xCD,0xA4,0xCA,0x59,0x5A,0xA7,0xAE,0xC1,0x8C,0x10,0xC9,0x93,0xD6,0x4B,0x42,0xC4,0x25,0xAF,0x02,0xBE,0x47,0x12,0xC0,0x86,0x9C,0x0A,0xF8,0xD9,0xFC,0xFF,0x01};
//const uint8_t spCYLINDER[] PROGMEM = {0x0C,0xF8,0x8E,0x59,0x00,0x7F,0x06,0x29,0xE0,0x37,0x47,0x03,0xFC,0x1E,0xE2,0x80,0x5F,0x43,0x02,0xF0,0x6B,0xB0,0x03,0x7E,0x15,0x5D,0xC9,0xA4,0xE6,0xE2,0x9E,0x65,0x95,0x4D,0x94,0x73,0xE8,0x9A,0x55,0x77,0x5A,0xCD,0x6E,0x5B,0x57,0x7D,0x28,0x55,0x87,0x38,0x1B,0x75,0x43,0x5D,0x6E,0xE2,0x66,0x95,0x45,0x4C,0x98,0x59,0xCB,0x55,0x36,0x3C,0x1E,0xA6,0xAD,0x5A,0xD5,0x14,0x46,0x6B,0xB0,0x29,0x75,0x95,0x18,0x6D,0xA6,0x2C,0xD5,0x45,0x60,0xAC,0xB1,0xF3,0xD2,0x8C,0xC0,0xC6,0x26,0x49,0x5B,0x55,0x5D,0x08,0x65,0x74,0x19,0x65,0x49,0x81,0xDA,0xDC,0x65,0x94,0x25,0x35,0xCA,0x72,0x9E,0x56,0x96,0xDC,0x20,0x47,0x79,0x5A,0x59,0x7C,0x23,0x1F,0xE7,0x09,0x79,0x8A,0xC2,0x5B,0xBE,0x2A,0x0D,0x25,0x28,0x8F,0x57,0xAD,0xFF,0x07};
//const uint8_t spCYCLE[] PROGMEM = {0x08,0x78,0x1C,0x51,0x00,0x3F,0x0B,0x29,0xE0,0xB7,0x52,0x05,0xFC,0xE2,0xEA,0x80,0xDF,0x8D,0x1D,0xF0,0x93,0xE9,0x8A,0xAB,0xA8,0x30,0x97,0x36,0xAB,0x4E,0x7E,0x4C,0x33,0x36,0xAF,0xBA,0x84,0x32,0x77,0x5F,0xBD,0xAA,0x1A,0x5C,0x33,0x72,0xD1,0xA8,0x5A,0x11,0x09,0xCB,0x4A,0xAE,0xA9,0x0E,0xA5,0x3D,0x22,0x81,0x00,0x72,0x5A,0x1E,0x43,0x12,0x13,0xE1,0xD2,0x79,0xCC,0x89,0x5F,0xBB,0xAA,0xB7,0xB6,0x16,0xB4,0x13,0x22,0xD9,0xCB,0x5A,0xD0,0x4C,0x0A,0x67,0x2B,0x7B,0xA6,0xD5,0x25,0x94,0xD5,0x1D,0x89,0x7A,0xAE,0x48,0xDA,0xFF,0x07};
//const uint8_t spDOWN[] PROGMEM = {0x02,0x28,0x30,0x6C,0x55,0x4D,0x25,0xAB,0xF9,0xEA,0x55,0x57,0x9B,0xA2,0x6E,0x6B,0x56,0x53,0x74,0xAA,0xB7,0xAF,0x5E,0x4D,0xD5,0x6D,0xD6,0xBA,0x78,0x75,0xC5,0xB6,0x79,0xEB,0xE2,0x35,0x64,0x3B,0xA6,0x63,0x4B,0xF6,0xB0,0x96,0xEC,0xD6,0xB4,0x6D,0xC9,0xDA,0x52,0x58,0xD3,0xB6,0xC5,0x6D,0x4B,0xFE,0x4C,0xDA,0x17,0x97,0x3D,0xB4,0xB6,0x48,0x9F,0x5C,0x8E,0x2C,0x2D,0x47,0xC2,0x76,0x3D,0xCB,0x59,0xB9,0xDA,0x68,0x4A,0x2D,0x57,0xB7,0xAC,0x25,0xE1,0xE4,0xFF,0x01};
//const uint8_t spGROUND[] PROGMEM = {0x02,0x28,0xBD,0xD4,0xEC,0xC1,0x97,0x99,0x99,0xAB,0x31,0xA4,0xAC,0x69,0xAE,0xF6,0x56,0x97,0x8A,0xA6,0xA5,0x24,0x5F,0x5D,0x6A,0x96,0xEE,0xD6,0x76,0xB5,0xA9,0xA6,0x87,0xFB,0xE6,0xD5,0x64,0xBF,0xEA,0xA9,0x8B,0x57,0x9D,0xE2,0x8A,0x87,0x2F,0x59,0x55,0x8C,0x6D,0xEE,0xB9,0x64,0x94,0xD1,0x75,0x94,0x66,0xAB,0x56,0x55,0xC9,0xD9,0xEC,0x8E,0x43,0x9D,0x25,0x8D,0xB3,0x64,0x11,0x43,0xE0,0xE1,0x21,0x19,0x53,0x0E,0x61,0xEF,0xCE,0xC8,0xC5,0xB6,0xFC,0x3F};
//const uint8_t spFULL[] PROGMEM = {0x04,0xA8,0x4C,0x85,0x00,0xC3,0x56,0x10,0x60,0xFA,0x0A,0x01,0x4C,0x97,0xAE,0x80,0x66,0xCB,0x5A,0xD9,0x44,0xA4,0x9B,0xD9,0x19,0x55,0x12,0x3D,0x26,0xD4,0x75,0x56,0xAB,0x2A,0x34,0xD7,0x19,0xBB,0xAD,0xAA,0x11,0xDB,0x14,0xCC,0x36,0xCA,0x4E,0x78,0xDA,0xD1,0xFD,0x28,0x1B,0x91,0x69,0x43,0xF7,0xAD,0xCA,0x4C,0x37,0x99,0xD3,0x95,0x2A,0x4B,0x5D,0x27,0x71,0x57,0x2B,0xD7,0x78,0x6B,0x29,0x52,0x4E,0xFF,0x1F};
//const uint8_t spNEW[] PROGMEM = {0xA9,0x2F,0x12,0x27,0x44,0xDC,0xA6,0xA1,0x29,0x18,0x0F,0x4D,0x1C,0x86,0x24,0x78,0x45,0x34,0x75,0x1A,0xAA,0xC4,0x71,0xD5,0xD8,0xAD,0x2F,0x0A,0xDB,0xCD,0x62,0xAF,0xAE,0x1B,0x33,0x0A,0x7B,0xBC,0xEA,0x6E,0x4D,0x39,0xE4,0xC9,0xAA,0x9B,0x52,0x95,0x92,0xD5,0xAD,0xCD,0xDC,0xDC,0x4B,0x3E,0x95,0x21,0xCA,0x70,0x0F,0x7D,0x1D,0x16,0xA7,0x33,0xCA,0xE4,0x91,0xDB,0xBC,0x2C,0x0F,0xA7,0x2F,0xEE,0xF0,0xB2,0xDD,0x9D,0xD6,0xA8,0xCB,0xCB,0x71,0x73,0x5A,0x63,0x5E,0x2B,0x26,0x32,0xA8,0xAD,0xFA,0x9C,0x19,0x37,0x95,0xAC,0xE6,0xF7,0xBE,0xDC,0x55,0xD3,0x9A,0xDF,0xA9,0xF1,0x30,0x49,0x6A,0x7E,0xAF,0xDB,0x42,0x79,0x8D,0xF9,0x43,0x76,0x73,0x8A,0x35,0xFF,0x0F};
//const uint8_t spLEG[] PROGMEM = {0xA9,0x1F,0x40,0x26,0x84,0xDC,0xA6,0x61,0x00,0xDD,0x42,0xCA,0x5A,0xFA,0x01,0x75,0x1D,0xA4,0xC9,0xEA,0x2B,0xAB,0x32,0xB5,0xD5,0xAB,0x6D,0xA2,0x43,0xDD,0x56,0xAF,0xAE,0xC8,0xB4,0xA8,0x58,0xBC,0x86,0x2A,0x4B,0xBD,0x72,0xF1,0x9A,0xAB,0x4A,0x89,0xCA,0xC7,0xE3,0x6C,0x36,0xC9,0x2A,0x16,0x97,0xAB,0x05,0x47,0xEF,0x78,0xE4,0x9E,0xDE,0x19,0xBC,0x62,0x96,0x78,0xB2,0x62,0xDA,0x35,0xCB,0xEC,0x09,0x42,0x7D,0xDB,0x64,0x93,0xD7,0x53,0xCF,0x4E,0x93,0x42,0xDE,0x8A,0x55,0x2C,0x22,0x71,0xFA,0x46,0x3C,0x33,0x33,0xDB,0xE9,0xAB,0x81,0xA9,0x22,0x17,0x87,0xAF,0x45,0xC5,0x8C,0x5C,0xF4,0xFF};
//const uint8_t spMAINTAIN[] PROGMEM = {0xAD,0xCD,0xDC,0xA4,0xDD,0xE2,0x94,0x21,0x73,0x93,0x76,0x8D,0xB3,0xFA,0x1A,0xD5,0xCC,0x7C,0xC9,0xEA,0xBB,0x4F,0x91,0x8C,0xC7,0xAB,0x1B,0x2E,0x59,0x3A,0x1E,0xAF,0x66,0x84,0x24,0xE9,0x98,0x35,0xEA,0xE1,0x1D,0x75,0x7D,0xE2,0xA8,0x9B,0x26,0xEF,0xB0,0xB8,0xAD,0x29,0x92,0x7C,0xDC,0xEC,0xA6,0x36,0x4B,0xAC,0x70,0x77,0x6C,0xFA,0x26,0xB1,0x3C,0x58,0x49,0x00,0xA6,0x49,0x4F,0xC0,0xB5,0xED,0xAD,0xEA,0x26,0x98,0xAD,0x66,0xAF,0xBA,0x7B,0x17,0xF1,0x58,0xB2,0xEA,0x61,0x4B,0x29,0xED,0xCD,0xEA,0xBA,0x0C,0x91,0xCD,0xC5,0xAB,0x1F,0x26,0x45,0xC6,0x1F,0xAD,0x7E,0xDA,0x64,0x1E,0x5F,0xB4,0xFA,0xE9,0x92,0x64,0x63,0xE6,0xEA,0xA6,0x0E,0xD6,0xF3,0x8A,0xAB,0x1B,0xCA,0xD8,0xD7,0x46,0xB5,0xAE,0x19,0x8C,0x72,0xB3,0xDB,0xFA,0xA6,0x29,0xDA,0xCC,0x6E,0xE9,0x9B,0xC1,0x0C,0x73,0x55,0xAD,0x6F,0xC1,0x55,0x25,0x6A,0x86,0xA1,0x28,0xD5,0x10,0x8F,0x6C,0xFA,0xEA,0x54,0x95,0xBD,0xF2,0xFF,0x03};
//const uint8_t spLANDING[] PROGMEM = {0x61,0x1B,0x88,0x67,0x05,0xBB,0x84,0x35,0x91,0x5A,0x45,0x5B,0xBA,0x96,0xAC,0xBB,0xD4,0x75,0xF3,0x1A,0xAB,0x6A,0xD7,0xB0,0xC5,0x6B,0xA8,0x36,0xD5,0x33,0x1E,0xAF,0xAA,0x3A,0x97,0xCA,0x9C,0xBD,0x8A,0xE6,0x83,0x33,0x6B,0xF2,0xCA,0x8B,0x0B,0x29,0xAF,0xCA,0x23,0x6B,0x86,0x32,0x35,0x55,0xB5,0x7C,0x78,0xCC,0x32,0x67,0xE5,0xAA,0x2A,0x50,0x9E,0xC3,0x75,0x19,0xB6,0x4D,0x53,0x56,0x3B,0xAB,0x6E,0xCE,0x4C,0xA4,0xE7,0xAC,0xB6,0x7B,0x67,0xB6,0xBE,0xB3,0x86,0x69,0x93,0x39,0xE3,0xF1,0x1A,0x87,0x77,0x94,0x89,0x99,0x65,0xEA,0x1E,0x6D,0xD2,0x82,0xB5,0xB9,0x1B,0xF2,0x0A,0xB1,0x5B,0xD6,0x6E,0xC9,0x2A,0xD5,0x6A,0x59,0xBB,0x26,0xAB,0xD4,0xA8,0x61,0xAD,0x92,0xBC,0x8B,0xAD,0x99,0x23,0x61,0xB3,0x0D,0xB6,0xFB,0xFF};
//const uint8_t spLEAN[] PROGMEM = {0x61,0x1B,0x88,0x67,0x05,0xBB,0x84,0x35,0x91,0x5A,0x45,0x5B,0xBA,0x9A,0xC6,0xC3,0x44,0xAD,0xCB,0x2A,0xAA,0x56,0xD5,0x8C,0x27,0x2B,0x1F,0x5E,0x99,0x33,0x9E,0xAC,0x6C,0xE6,0x60,0x8C,0x98,0xBD,0xF2,0x99,0x8C,0xB8,0x73,0xD4,0xAA,0x87,0x17,0xB2,0x8D,0x20,0x63,0x18,0x46,0x28,0xCE,0xC3,0xB4,0x71,0x3A,0x45,0x3F,0x37,0xD3,0x96,0xE9,0x85,0xEC,0xC2,0x4C,0xDB,0x87,0x65,0xB6,0x75,0xD3,0xE5,0x18,0x51,0xD8,0x26,0x4A,0xA5,0x67,0x44,0x74,0x6F,0x75,0x9C,0xDE,0x11,0xD1,0xBD,0xD4,0x71,0x7A,0x47,0xA4,0x70,0x75,0x55,0xE9,0x2D,0x32,0x5D,0xCB,0x63,0xFD,0x3F};
//const uint8_t spSET[] PROGMEM = {0x08,0xD8,0x84,0x99,0x01,0xCF,0xB8,0x32,0xE0,0xA7,0x14,0x05,0xFC,0x56,0x6A,0x81,0x00,0xFC,0x96,0xEA,0x80,0x5F,0xCA,0x56,0x3E,0x79,0xAA,0xAA,0xB7,0x5E,0x45,0xD3,0xA9,0x6A,0xF9,0x64,0x15,0xDD,0xB4,0x99,0xC6,0x9A,0x55,0xD4,0x50,0x62,0xD6,0xB5,0x4B,0xD6,0x78,0x4B,0x58,0xCD,0x44,0xE0,0x14,0xA5,0x2A,0x54,0x03,0x00,0x14,0x30,0x85,0x3A,0x03,0x9E,0xAF,0xF8,0x7F};
//const uint8_t spSHORT[] PROGMEM = {0x0C,0x38,0x71,0x54,0x01,0xBB,0x6D,0x19,0x60,0x97,0xEB,0x00,0xEC,0xB2,0x16,0x80,0x95,0x2F,0x02,0x30,0xFB,0xB8,0x03,0x7A,0x0E,0x69,0x45,0xF5,0x1D,0x21,0x22,0xA7,0x95,0xD1,0xB6,0x6B,0xB1,0xF6,0x56,0x87,0xD6,0x62,0xC9,0xDE,0x5A,0x1B,0x46,0x72,0x2C,0x7A,0x6B,0x5D,0x1C,0x81,0x35,0x98,0xA7,0x4C,0xA9,0x3A,0xE6,0xAA,0x1F,0x04,0x4E,0x51,0xAA,0x42,0x35,0x00,0x40,0x01,0x43,0xBA,0x31,0x60,0x73,0x35,0x04,0x4E,0x51,0xAA,0x42,0x35,0xFE,0x1F};
//const uint8_t spWAKE[] PROGMEM = {0x62,0x21,0xE9,0x3A,0x54,0x9D,0x88,0x83,0xA4,0xCF,0x10,0x76,0x2C,0x4E,0x52,0x2E,0x83,0xC5,0xB1,0x3A,0x59,0xDD,0x74,0xD6,0x8C,0xEE,0x10,0xB3,0x92,0x45,0x3A,0x8F,0x25,0xC4,0xCC,0x60,0xED,0xB2,0xA6,0xE2,0xC3,0x42,0xFC,0xCD,0xEA,0xAA,0x57,0x49,0xCF,0xC5,0xAB,0xEE,0x41,0x29,0x22,0xAF,0xAC,0x7C,0x14,0x05,0x8F,0xBA,0x9D,0xB2,0xD1,0x09,0x32,0x7A,0xA1,0xA8,0xA6,0x19,0x32,0x55,0x3B,0x08,0x2C,0xAA,0x54,0x85,0x6A,0x00,0x28,0xA0,0x79,0x11,0x0D,0x08,0xA0,0x15,0xE3,0xFF,0x07,0x08,0x9C,0xA2,0x54,0x85,0x6A,0xC0,0xFF,0x03};
//const uint8_t spADIS[] PROGMEM = {0x6D,0xEA,0x36,0x48,0x2A,0x57,0x8D,0x69,0xFA,0x66,0xCC,0x58,0xBD,0xDA,0xE9,0x8A,0x28,0x63,0xCD,0xAA,0x47,0x48,0x94,0x8C,0x25,0xAB,0x1A,0x49,0xD0,0xAC,0x9B,0x80,0x00,0x9E,0x32,0x6D,0x59,0xF3,0x2A,0x26,0xDD,0xB8,0x65,0xD5,0xA9,0xB8,0xCC,0xE2,0x91,0x15,0xE5,0xE2,0xD1,0xB3,0x47,0xD6,0x44,0xB2,0x4A,0xAE,0x32,0xC0,0x33,0xAE,0x0A,0xF8,0x29,0xC5,0x00,0xBF,0x95,0x5A,0x20,0x00,0xBF,0xA5,0x3A,0xE0,0x97,0x32,0x03,0xFC,0x5C,0xF6,0xFF};
//const uint8_t spNOTEM[] PROGMEM = {0x66,0x8B,0x52,0xBC,0xCD,0x26,0x85,0x35,0x08,0xC9,0x31,0xAD,0x1C,0x97,0x36,0x77,0xE5,0xA6,0x46,0xAB,0x57,0x9B,0xF5,0x88,0x54,0x2D,0x59,0x55,0x51,0x6D,0x6E,0xBC,0x76,0x15,0xD9,0x94,0xA7,0xF0,0xEB,0x91,0x27,0x93,0xA6,0xA6,0x6B,0x5A,0x9E,0xB2,0x8A,0xA4,0xA7,0x41,0xE0,0x14,0xA5,0x2A,0x54,0x03,0x04,0xF0,0x94,0xA9,0x07,0x56,0x55,0xBD,0x8B,0xA5,0xB7,0x5A,0x4D,0x4B,0xAE,0xE6,0xFE,0x78,0x0D,0xCD,0xA6,0x48,0xDB,0xEA,0xF2,0x24,0x9F,0x11,0xEE,0x8D,0xCB,0x53,0x64,0x7A,0x0A,0x39,0x4D,0x77,0x65,0xE3,0x2E,0x62,0x37,0xDD,0x8D,0xB6,0x96,0x48,0xD4,0x70,0x27,0x5F,0x96,0x6C,0x4E,0xFE,0x1F};
//const uint8_t spRVRS[] PROGMEM = {0x65,0x8C,0x79,0x22,0xCC,0x12,0xAF,0x31,0xE9,0x2B,0x4E,0xEB,0xBD,0xC6,0x64,0x2F,0xA5,0xA4,0xCF,0x1A,0x52,0x38,0xF5,0xA1,0xCE,0xAB,0x2D,0xF6,0xC4,0x0F,0x7B,0xAF,0x2A,0xC7,0xC1,0x5E,0xDC,0xB4,0x8A,0x3C,0x12,0xCF,0x79,0x63,0xCB,0x73,0x53,0x5E,0xE7,0x9E,0xA9,0x4E,0x51,0xCD,0x4D,0x9D,0xBA,0x26,0xC9,0xA2,0x30,0xF5,0xE2,0xBA,0xC6,0x4C,0xD4,0x22,0xF1,0xA8,0x9A,0x71,0x52,0xF7,0xBA,0x2B,0xEB,0x51,0xC9,0x3C,0xD6,0xAC,0x6C,0x04,0x43,0x8D,0x5C,0xB2,0xF2,0x61,0x15,0xB4,0x6B,0xF6,0x2A,0x87,0x33,0xD0,0xAE,0x39,0xAB,0xEE,0x46,0xD1,0x27,0x97,0xAC,0xBA,0x1A,0xE7,0x70,0xBF,0xBD,0xDA,0x14,0x93,0xCB,0xE2,0xF6,0xEA,0x62,0x1C,0xC9,0xE2,0x55,0xAB,0x8F,0x69,0x24,0x93,0x5E,0x8D,0x21,0xD6,0x96,0x0A,0x7A,0x35,0xE6,0x58,0xDB,0xA2,0xF8,0xF5,0x98,0x53,0x4D,0x8F,0xE6,0xCD,0x63,0xCF,0xCD,0x3D,0x8B,0x56,0xB7,0x23,0xE7,0xB0,0x18,0xFA,0xDC,0xCE,0xDC,0x42,0xB3,0x69,0x73,0xBA,0x72,0x29,0x8E,0xA1,0xDD,0xE1,0x4A,0xD5,0x78,0x9A,0x3F,0xA5,0x3B,0x25,0xE3,0x59,0xDD,0x1D,0xEE,0x1C,0x9D,0xAA,0xBC,0xB7,0x7B,0x8A,0x0F,0xB2,0x89,0x4C,0xE9,0x29,0x2E,0x89,0xBB,0x5A,0xBB,0xB7,0x7A,0x13,0x93,0x58,0x9C,0xBE,0x63,0xC3,0x8D,0xC4,0x5D,0xFA,0x2F,0x09,0x11,0x97,0xBC,0xE1,0xBF,0x88,0xDD,0x3C,0xDC,0x28,0xE0,0x7B,0x24,0x01,0x6C,0xC8,0x89,0x80,0xE5,0xDD,0xFF,0x1F};
//const uint8_t spSQUALKING[] PROGMEM = {0x0C,0x78,0xC6,0x95,0x01,0x3F,0xA5,0x28,0xE0,0xB7,0x52,0x0B,0x20,0x70,0x8A,0x52,0x15,0xAA,0x81,0x80,0xC4,0xCC,0x30,0xC0,0x81,0x92,0x79,0xBB,0xA1,0x49,0x59,0x47,0xE9,0xE2,0xA6,0x05,0x65,0x5B,0x65,0x48,0x17,0x12,0xDA,0x77,0x55,0x31,0x9E,0x69,0x5A,0xEF,0x55,0xC7,0xD6,0x16,0x26,0x9D,0x5A,0x97,0xE2,0x72,0x39,0xF7,0x01,0x05,0x54,0x1F,0xAA,0x80,0x6A,0x8D,0x47,0xD3,0xB2,0x90,0x47,0x2E,0x1E,0xF3,0xF0,0x25,0x58,0xF6,0xA6,0xED,0xDD,0x1A,0xEB,0xF9,0xC4,0x70,0x35,0xCB,0x5A,0xCB,0x61,0xC3,0xD5,0x0C,0x67,0xA8,0x39,0x76,0x77,0x31,0xDC,0xAE,0xEA,0xD8,0x3D,0xD5,0x48,0xA5,0x98,0x92,0xFF,0x07};
//const uint8_t spMAGNETOS[] PROGMEM = {0x6A,0xD5,0x3A,0xB3,0xD5,0xED,0xBA,0x35,0x08,0xCD,0x0A,0x73,0x9A,0xD6,0xA4,0x38,0xCA,0xDD,0xC9,0x59,0x8A,0x2F,0x97,0x90,0xCD,0x67,0x6A,0xA6,0x5C,0x4B,0xD7,0x9C,0xB1,0xDB,0x72,0x69,0x5D,0x73,0x86,0x6E,0x4A,0x64,0x7D,0xF3,0x19,0x7A,0x59,0xC2,0xD1,0x55,0x6D,0x68,0xD1,0xC0,0x47,0x2A,0xA9,0x51,0x19,0xAF,0x26,0x49,0xAC,0x46,0x27,0xB4,0xDA,0x3D,0x91,0x1B,0x82,0xE0,0x1E,0x35,0xD7,0xAB,0x6D,0x8E,0xC5,0xAD,0x07,0xAF,0xA2,0x07,0x65,0xCB,0x1C,0xBD,0xB2,0x91,0x94,0x34,0x73,0xD2,0xCA,0x46,0x64,0xB2,0xA8,0x59,0x25,0x1F,0x46,0xC9,0x4C,0x3B,0xAF,0xBC,0x6B,0x17,0x53,0x5D,0xB3,0xB2,0xAA,0x52,0xDD,0x74,0xE9,0x2A,0x8A,0x28,0x0B,0x97,0xD7,0xAB,0x2C,0xAC,0xDD,0x43,0x3E,0xEF,0x72,0x55,0x95,0x54,0x5A,0xE8,0xAA,0x55,0x55,0x96,0xAE,0xC2,0x9B,0x47,0x3B,0x84,0x85,0x89,0x78,0x4B,0xEB,0x45,0xEC,0xE6,0xE1,0xA6,0xEC,0xDF,0x47,0x98,0x30,0x33,0x05,0x7C,0x8F,0x24,0x80,0x0D,0x39,0xFF,0x1F};
//const uint8_t spSTABILISER[] PROGMEM = {0x0C,0x78,0xC6,0x95,0x01,0x3F,0xA5,0x28,0xE0,0xB7,0x52,0x0B,0x30,0xE0,0xFB,0x08,0x04,0x4E,0x51,0xAA,0x42,0x35,0x40,0x00,0x4F,0x99,0xAE,0xA8,0x6B,0x57,0x75,0x5F,0xBD,0xCA,0xEE,0x42,0xC4,0xFD,0xCE,0xAA,0xBA,0x77,0x56,0x8F,0x39,0xA3,0x6A,0xCE,0xD9,0xDC,0x17,0xBB,0xDA,0xA8,0x8C,0x70,0x6E,0xC5,0x7A,0xE6,0xDA,0xCC,0x23,0xF5,0x98,0x92,0xEC,0x54,0xD3,0x34,0xA3,0x2F,0xB4,0x26,0x8C,0xBA,0x95,0xB1,0x62,0x1F,0x77,0xE8,0xB2,0xC6,0x4A,0xAA,0xC3,0xA9,0xEB,0x1A,0x1B,0xAD,0xB6,0xE0,0x2D,0x6B,0xAC,0x7C,0x52,0x53,0x37,0xAF,0xB9,0xC9,0x09,0x49,0xD9,0xBC,0x96,0x2E,0xCB,0xB5,0x65,0xF3,0x5A,0x9B,0x48,0x8D,0xB1,0x57,0x6D,0x2F,0x41,0x2C,0xA2,0x27,0x85,0xFD,0x97,0xF6,0x00,0x91,0x5D,0x0F,0x03,0xFC,0xEC,0x6A,0x81,0xB6,0x37,0x1F,0xC2,0xA1,0x6D,0xD2,0x55,0x72,0x92,0xB4,0xE4,0x0B,0x4F,0x59,0xCA,0x91,0xD2,0xD7,0xBC,0x65,0x08,0xE5,0x70,0x67,0xF7,0xA5,0xE4,0xE8,0xE7,0x69,0xCC,0x57,0x86,0x52,0xB6,0x76,0x31,0x7F,0x59,0x2C,0x95,0xBA,0xFA,0xFF,0x01};
//const uint8_t spPAKM[] PROGMEM = {0x0A,0xD8,0x5C,0x4D,0x03,0xAB,0xA8,0x21,0x2C,0x3D,0x96,0xAC,0xAA,0xFA,0xD2,0x08,0x5B,0xB2,0xAA,0x16,0x53,0x32,0x7C,0x49,0xAB,0x4A,0x12,0x39,0xEB,0x30,0x08,0x9C,0xA2,0x54,0x85,0x6A,0x80,0x02,0x9A,0x0B,0x56,0x40,0xCF,0x46,0xAB,0x69,0xC9,0x28,0x2D,0x67,0xAF,0xBE,0x3A,0xE7,0x6C,0xBF,0xBD,0xC6,0x6A,0x43,0x72,0xFC,0xD6,0x58,0x9A,0x4A,0x89,0xF5,0x47,0xE3,0x68,0xBA,0xC4,0xC6,0x66,0xB5,0xA3,0xEA,0x94,0x68,0xAB,0xDD,0xCE,0x2A,0x5A,0xA3,0x6D,0x71,0xB9,0x8A,0x0F,0x2D,0x8F,0xD9,0xE5,0x49,0xBA,0xB4,0x32,0x26,0xD5,0xA7,0x3E,0xE5,0x6D,0x86,0x2D,0xCC,0xEC,0x96,0x77,0x78,0x96,0x30,0x8F,0x9A,0xDE,0x6A,0x24,0x4C,0x23,0x4E,0x7E,0xFF,0x1F};
//const uint8_t spSELCAL[] PROGMEM = {0x0C,0xF8,0x29,0x45,0x01,0xBF,0x95,0x5A,0x20,0x00,0xBF,0xA5,0x3A,0xE0,0x97,0x32,0x03,0xFC,0x5C,0xB6,0x92,0xA6,0x4B,0x39,0x6D,0xF5,0x4A,0x8B,0x4C,0x8B,0xB4,0xD7,0x2B,0xAB,0x7C,0xDC,0x52,0x5F,0xAE,0x2C,0xEA,0x0D,0x37,0xDD,0xBC,0xF2,0x68,0x26,0xD3,0x38,0xB3,0x2A,0x32,0x29,0x35,0x93,0xAC,0x08,0x9C,0xA2,0x54,0x85,0x6A,0x80,0x03,0xAA,0x35,0x72,0x40,0x31,0xC2,0xAB,0xAD,0x45,0xC5,0x3D,0x5B,0xAF,0xAE,0x14,0x95,0xC8,0x5C,0xBC,0xFA,0x62,0x52,0x63,0xED,0xF5,0x6A,0x8B,0x6F,0xB1,0xD6,0x55,0xEB,0x2C,0x7E,0x55,0x4B,0x17,0x8D,0xAB,0xA8,0x75,0x19,0x5B,0xBC,0xFE,0x6C,0xD6,0x3C,0x75,0x76,0x79,0xA3,0x5F,0xF3,0xB0,0xD9,0xE9,0x4F,0xF2,0x4B,0x43,0x37,0xA7,0x3F,0x98,0xAF,0x30,0xE9,0xEC,0x7E,0xEF,0x3E,0x52,0xB5,0x8B,0xFB,0x43,0xE8,0x6A,0xD2,0xD6,0x08,0x70,0xDE,0x03,0x01,0xC1,0x5A,0xFE,0x3F};
//const uint8_t spVORTAC[] PROGMEM = {0x66,0x8D,0x2E,0xDC,0x95,0x9B,0xB8,0xAD,0x30,0x0F,0x29,0x51,0xE2,0x8E,0xCA,0x54,0x35,0xCC,0xB1,0x3B,0x87,0x34,0x65,0x55,0xC5,0x65,0x9B,0x3A,0x53,0x83,0x1C,0xB5,0x2E,0xD8,0x4A,0x4D,0x89,0x3D,0x1A,0xEF,0x2F,0xD4,0x39,0xED,0x68,0x82,0xB9,0x92,0x22,0x6F,0xA3,0x70,0x79,0xD5,0x9A,0xB3,0x8D,0x22,0xD4,0xA2,0x29,0xEC,0x32,0x8A,0xD4,0x94,0xBB,0x38,0xF7,0x28,0xEB,0x70,0x71,0x36,0x27,0x08,0x9C,0xA2,0x54,0x85,0x6A,0x80,0x00,0x9E,0x32,0x95,0xC0,0xAA,0x4B,0x08,0x0A,0xCF,0x8C,0xAB,0xCB,0x3E,0x24,0x3A,0x56,0xAF,0xA1,0xB8,0x12,0x1F,0xDF,0xBC,0xA6,0x6A,0x5B,0x74,0x6C,0xF3,0xDA,0xAA,0x2D,0xB5,0xD6,0xD5,0xE3,0xAC,0xAE,0xC4,0xDB,0x5F,0xB5,0xAF,0xFA,0x94,0x68,0x5B,0x54,0xBE,0x66,0x9B,0x6C,0x6D,0x93,0xFB,0xDB,0x11,0x5E,0x8F,0x98,0x08,0x9C,0xA2,0x54,0x85,0x6A,0x80,0x00,0xBA,0x6F,0x66,0x40,0x8B,0x41,0x14,0xF8,0x7F};
//const uint8_t spVOR[] PROGMEM = {0x6E,0x2D,0xDA,0x45,0x5C,0xDD,0x84,0xAD,0x1A,0x57,0x51,0x51,0x93,0xF6,0xA1,0xC2,0x58,0x59,0x49,0x3A,0x96,0xAF,0x20,0x51,0xC5,0x6D,0xE8,0xC6,0x48,0x2D,0x32,0xAF,0xB6,0x47,0x63,0x0A,0x5B,0xBD,0xAA,0x11,0x9C,0x30,0xE3,0xCD,0x2A,0x67,0x74,0x86,0xC8,0x35,0xAB,0x98,0xC1,0x08,0x33,0x97,0xAC,0x62,0x64,0x43,0xCA,0x58,0xBD,0x8A,0x91,0x1D,0x39,0x6C,0xCD,0x2A,0x9A,0x56,0x89,0x94,0xAD,0xAB,0xCC,0xAA,0x4D,0xDD,0x5A,0x8F,0x2A,0xEA,0x75,0x73,0xD9,0xD2,0xEA,0xA8,0x2E,0xDD,0xB8,0x77,0xAF,0x5B,0x1D,0xD4,0x65,0x18,0xE5,0x29,0x75,0x50,0x57,0x6E,0x94,0xB7,0xD4,0x4E,0x5F,0xBB,0xB1,0x9F,0x52,0x7B,0x73,0xAD,0xAA,0x79,0x5A,0x15,0xF4,0xB6,0x07,0xE5,0x59,0x75,0xF0,0x97,0xE2,0x9E,0x6F,0xD5,0xC1,0x5D,0x6A,0x58,0xB6,0xD5,0x44,0x7B,0xA9,0x29,0x7D,0x57,0x17,0xE2,0xB9,0x94,0x75,0x5E,0x7D,0x4C,0x6B,0x56,0xDA,0x65,0x2D,0x31,0x8E,0x7B,0x4B,0xE7,0xB5,0xA4,0x5C,0x96,0x45,0x9D,0xC7,0x91,0x62,0x9B,0x0D,0xF7,0x2D,0x57,0xCA,0x65,0xB6,0xDC,0x25,0xDD,0x29,0x96,0xE9,0x73,0x9F,0xF2,0xA4,0x12,0x9A,0xCB,0xAD,0xD3,0x9B,0x8B,0x73,0x2E,0x6D,0x0E,0x6F,0x2A,0x49,0x71,0xB2,0x25,0xBD,0xB9,0x05,0x76,0x6B,0x67,0xF7,0xE5,0x16,0x30,0x6E,0x9D,0xDD,0x57,0xB6,0xE1,0xB8,0x65,0x34,0x5F,0x79,0x62,0x65,0xD2,0xFA,0xFF,0x01};
//const uint8_t spBARKER[] PROGMEM = {0xA1,0x0D,0xDA,0xCB,0xC1,0x9D,0xA6,0x3E,0x2A,0xAF,0x04,0x8D,0xDB,0xFA,0xAC,0x2C,0x5B,0xD8,0x4A,0xEB,0x7D,0xD9,0xB4,0xA4,0xA6,0xAD,0x0D,0x79,0x25,0x96,0x56,0xF7,0x76,0x54,0x31,0x0E,0xD7,0xD2,0xA6,0x51,0x25,0x3F,0x98,0x4F,0x9B,0x4A,0x5D,0xC2,0x83,0xA7,0x38,0x41,0xE0,0x14,0xA5,0x2A,0x54,0x03,0x18,0xD0,0xCD,0x9B,0x02,0x4A,0x4C,0x34,0x40,0xCC,0x68,0x6D,0xCC,0x53,0xB1,0x8A,0x77,0xB7,0x35,0xF7,0x44,0x39,0xEA,0xDB,0xD6,0xD2,0x9B,0x78,0x29,0x6F,0x3A,0x4B,0x5E,0x81,0xE3,0x7C,0xE9,0xC9,0xAD,0xD0,0x46,0x73,0x87,0xB7,0xB4,0x42,0x1D,0xCA,0x63,0xBE,0xF2,0x98,0x47,0x74,0xF7,0xFF,0x03};
//const uint8_t spHEADING[] PROGMEM = {0x08,0x08,0x06,0x05,0x01,0x51,0x81,0x96,0xB6,0x67,0xA3,0x10,0x8B,0xB4,0xAA,0x62,0xD9,0x3A,0x2A,0xD2,0x2A,0x5B,0x72,0xF6,0xC8,0x25,0xAB,0x6A,0x36,0xD8,0x33,0x1F,0xAF,0xAA,0xAB,0x64,0xF3,0xB8,0xAD,0x1A,0x6E,0xC2,0xA3,0x32,0x62,0xEA,0x0A,0x52,0xCB,0x8C,0xD4,0xAB,0xEA,0xCE,0x49,0xB5,0x96,0xAC,0xAA,0x07,0x43,0xF5,0x9A,0xB3,0xEA,0x1E,0x88,0xAB,0xB2,0xF0,0xA8,0x9B,0xC1,0x4E,0x57,0xA5,0xA3,0x6E,0x06,0x2B,0x5C,0xED,0xAC,0xBA,0x69,0x8A,0x72,0x8D,0x5B,0x9A,0xA6,0xC8,0x37,0xC5,0xEE,0xFF,0x03};
//const uint8_t spETA[] PROGMEM = {0xAD,0x5F,0x31,0x18,0x3C,0x97,0xAC,0x6E,0xC5,0x22,0xF0,0x5C,0xBA,0x9A,0x15,0x03,0xA1,0x6A,0xCE,0x2A,0x67,0x71,0xC0,0xAA,0xC5,0xAB,0x98,0x41,0x41,0xBA,0x17,0xAB,0xCA,0xD2,0xC8,0x2D,0xB5,0x83,0xC0,0x29,0x4A,0x55,0xA8,0x06,0x28,0x60,0x50,0x95,0x04,0x7C,0x9B,0x96,0x80,0xED,0xAF,0x46,0xD6,0x0D,0xB3,0x57,0xD7,0x5E,0xF9,0xCC,0x8E,0x14,0xB9,0x64,0x15,0x2B,0x07,0x62,0xC4,0x92,0x55,0xAE,0x1C,0x88,0x99,0x4B,0x56,0x35,0x73,0x20,0x66,0x2E,0x19,0xD5,0x8C,0x06,0xDC,0xF9,0x64,0xD5,0x23,0x18,0x4A,0xC6,0x9C,0xD5,0x0C,0x9F,0x24,0xE9,0x8F,0x57,0xD7,0x6D,0x90,0x55,0x3C,0x5E,0x43,0x37,0x41,0xD6,0xFE,0x78,0xCD,0xDD,0x24,0x59,0xFB,0xE3,0xB5,0x76,0x13,0xEC,0x13,0x8B,0xC6,0x31,0x6C,0x92,0xB4,0xBF,0x1A,0x77,0x77,0x46,0xDE,0x31,0xBB,0x3C,0xC3,0x05,0x4A,0xFB,0xE3,0xF4,0x0D,0x17,0xA0,0x13,0xAF,0xD2,0xD7,0x8D,0x60,0x4D,0xDD,0x2A,0xFF,0xC8,0x42,0x96,0xD5,0x26,0xFD,0xA3,0x10,0x7B,0x74,0x5B,0xF3,0xF7,0x22,0xAE,0x1C,0x65,0xFE,0x1F};
//const uint8_t spDOWNWIND[] PROGMEM = {0x0C,0x28,0x30,0xAC,0x95,0xCB,0x4E,0x85,0xAA,0x9B,0xD5,0x4F,0x15,0x46,0xA1,0x7D,0x57,0x57,0x6D,0xA8,0x96,0xAF,0x59,0x6D,0xB5,0x65,0x1E,0xF6,0x7A,0x35,0xC5,0xAF,0x59,0xD8,0xA3,0x55,0x65,0xB7,0x6A,0xE9,0x8B,0x57,0x99,0xFC,0x68,0x78,0xCC,0x59,0x59,0x8C,0x99,0xAE,0x59,0x67,0x65,0x55,0x4B,0x85,0xA4,0xAA,0x96,0x35,0x45,0xD5,0x12,0xAA,0x47,0x99,0xB4,0x4D,0x50,0x3A,0x2E,0x75,0xD4,0xB2,0x89,0xA1,0x26,0x35,0x41,0xEB,0x16,0x49,0xDD,0x55,0x47,0x93,0x59,0x42,0x8B,0x57,0x55,0xB4,0x5B,0x3A,0xBF,0x5E,0x65,0xD3,0x2E,0x91,0x7A,0x7B,0x95,0xCD,0x98,0x44,0xFA,0xE5,0x55,0x16,0xCB,0xA5,0x5E,0x55,0x46,0x55,0x35,0x75,0xA8,0xC5,0x69,0x55,0x55,0xD8,0x61,0xEA,0xA4,0xD5,0x59,0x52,0x87,0x69,0x62,0x57,0x3B,0x29,0x9D,0xDC,0x15,0x5B,0xBF,0x98,0xB9,0xB0,0xF5,0xF9,0x7F};
//const uint8_t spCEILING[] PROGMEM = {0x0C,0xF8,0x29,0x45,0x01,0xBF,0x95,0x5A,0x20,0x00,0xBF,0xA5,0x3A,0xE0,0x97,0xB2,0x95,0x0E,0xED,0x8A,0x61,0x6B,0x46,0x39,0x7C,0x30,0x86,0x7E,0x19,0xC5,0x88,0x4E,0x94,0xFA,0x65,0x15,0xDD,0x29,0x6B,0xEB,0xEA,0x56,0x54,0xA6,0x16,0xC5,0xAB,0x47,0x31,0xB0,0xA6,0x85,0xB6,0x59,0x79,0x53,0xCE,0x91,0x3E,0x6B,0x14,0x4D,0xA9,0x54,0x79,0xA9,0x52,0x54,0x8D,0x39,0x21,0x56,0x4B,0xD1,0x34,0x76,0xB9,0xDA,0x2D,0x79,0xD3,0x58,0xED,0x6A,0x37,0xE5,0x59,0x51,0x55,0xB0,0x13,0x91,0x31,0x57,0x61,0x6A,0x69,0x48,0xA6,0x59,0x55,0x85,0xCB,0xF9,0x7F};
//const uint8_t spMIDPOINT[] PROGMEM = {0xE2,0xE0,0x62,0xAA,0x5D,0xED,0x98,0x5D,0xA8,0x8C,0x0A,0x8D,0xE3,0x36,0xAD,0x2D,0xCA,0x2D,0xB6,0xDB,0x8C,0xB2,0x68,0xD7,0x38,0x6B,0xA9,0x4A,0x4D,0xCB,0x5A,0xAF,0xBE,0x59,0x55,0xCD,0x78,0xB5,0xEA,0x6E,0x9C,0xD5,0xE3,0xCE,0x2A,0xBB,0x49,0x11,0xF5,0x27,0xA2,0x14,0x2A,0xA3,0xBD,0x03,0xB1,0x5A,0x88,0x8E,0x0E,0xB7,0xC4,0x6A,0x21,0x2A,0xC2,0x23,0x31,0x69,0x1D,0x8E,0xAA,0x4C,0xDB,0x08,0x00,0x7A,0x12,0x03,0x0A,0x08,0xD6,0x3D,0x55,0xD5,0xA4,0x3B,0x99,0xAD,0x52,0x79,0x3F,0x99,0x42,0xAD,0x4E,0x19,0xED,0x54,0x05,0xB6,0x39,0x55,0xD4,0xDB,0x96,0xB4,0xF4,0x54,0xD1,0x4C,0x78,0xEA,0xD2,0x53,0x65,0x57,0xEA,0xE5,0x6B,0x4E,0x55,0x54,0x4A,0x6E,0x34,0x6A,0x55,0x54,0x52,0x65,0x69,0x51,0x35,0x5A,0x46,0xB4,0x99,0x23,0x03,0x4C,0xA1,0xEE,0x80,0xE7,0x2B,0x04,0x70,0x63,0xE6,0xFF,0x03};
//const uint8_t spSIGNET[] PROGMEM = {0x0C,0x78,0xC6,0x95,0x01,0x3F,0xA5,0x28,0xE0,0xB7,0x52,0x0B,0x04,0xE0,0xB7,0x54,0x07,0xFC,0x52,0x76,0x8A,0x2E,0xC3,0xD8,0x6D,0xF5,0xC9,0xBB,0x4E,0x95,0xF0,0xD7,0xA7,0xE8,0x3A,0x59,0xD2,0x57,0xAF,0x62,0xA4,0x00,0x0D,0x5D,0xED,0xEA,0x22,0x99,0xBA,0xAD,0xA2,0x68,0xB9,0xED,0x4C,0x37,0x59,0x62,0xE0,0x6A,0xC3,0xCD,0x9C,0xA8,0xD1,0xB0,0x8E,0x70,0x4F,0x9C,0xE6,0xA8,0xCD,0xC3,0xB5,0x4E,0x9E,0xCB,0x58,0xAC,0xBB,0xA5,0x3E,0x2E,0x73,0xD1,0xEE,0xD1,0xFE,0x68,0xAC,0x4D,0xBB,0x7A,0xD9,0xAB,0xB2,0x57,0xE3,0x1A,0xEE,0x3F,0x11,0x38,0x45,0xA9,0x0A,0xD5,0x00,0x00,0x05,0x4C,0xA1,0x2E,0x80,0xE7,0x2B,0x08,0x70,0x63,0xE6,0xFF,0x03};
//const uint8_t spROLL_OUT[] PROGMEM = {0x2C,0x16,0x31,0xA5,0xD2,0xE5,0x9A,0x53,0xFB,0x51,0xF5,0x88,0xA2,0x0E,0x91,0x5A,0x2C,0xCD,0xAE,0x3B,0x5C,0x36,0xC9,0x50,0x7B,0x65,0x0D,0x45,0x34,0x43,0x9C,0x8F,0x29,0x64,0x0F,0x4D,0x4D,0x3F,0xFA,0xA8,0xBA,0xD2,0xA9,0xEB,0xE8,0xA2,0x98,0x71,0xA3,0xAE,0xA3,0x4E,0xB4,0x37,0x95,0xB2,0x8E,0x32,0x91,0xD9,0x10,0xCE,0x3A,0xAA,0x28,0x7A,0x52,0x38,0xDD,0xA8,0x83,0xCA,0x6A,0xB4,0x64,0xA3,0xC9,0xC2,0x6A,0x50,0xEB,0xAC,0x36,0xCB,0x4D,0x33,0xDB,0xBC,0xFA,0xA4,0x37,0x34,0x7C,0xF5,0xEA,0xB3,0xDE,0xD0,0xF4,0xD5,0xAB,0xCB,0x7A,0x43,0xD3,0x5B,0x8F,0x36,0x86,0x35,0xCF,0x68,0x39,0xEA,0x58,0xCA,0xDC,0x72,0x51,0x2B,0x43,0xCE,0x0C,0x8D,0x45,0xA9,0x4C,0x31,0xDC,0x24,0x6A,0x9B,0x36,0xF1,0x4A,0x77,0xF8,0x8C,0xC0,0x29,0x4A,0x55,0xA8,0x06,0x80,0x02,0xA6,0x50,0x57,0xC0,0xF3,0x15,0x02,0xB8,0x31,0xF3,0xFF,0x01};
//const uint8_t spCROCS[] PROGMEM = {0x0A,0x28,0x4A,0x5D,0x01,0xA5,0xB8,0xBB,0xA4,0x94,0xEA,0x72,0xB7,0x32,0x92,0xD8,0x24,0x5D,0x2D,0xCB,0xAA,0x52,0xAC,0x74,0x37,0x2F,0xAB,0x4A,0x7E,0x22,0x5D,0x36,0xAF,0x2A,0xFB,0xF1,0x74,0x59,0xB3,0xAB,0x55,0xE7,0x54,0x51,0x62,0x4B,0x5A,0x93,0x6C,0x46,0xAA,0xC4,0x41,0xE0,0x14,0xA5,0x2A,0x54,0x03,0x00,0x0C,0x10,0x8D,0xA8,0x02,0x9E,0x71,0x55,0xC0,0x4F,0x29,0x06,0xF8,0xAD,0xD4,0x02,0x0A,0xF8,0x2D,0x95,0x01,0xBF,0x94,0x31,0xE0,0xE7,0xB2,0xFF,0x07};
//const uint8_t spAIRCRAFT[] PROGMEM = {0x61,0xEE,0xCA,0x44,0x3B,0x63,0xAD,0xB9,0x19,0x67,0xDD,0x6C,0xB5,0xBA,0x16,0x8B,0xA4,0x6D,0xF3,0x6A,0x5A,0x1A,0x92,0xE1,0x2D,0xA3,0x2A,0x79,0x50,0x96,0x36,0xB7,0x2A,0xFB,0x45,0x3D,0xDC,0x9D,0xBA,0x64,0x07,0xA2,0x39,0x31,0x02,0xA7,0x28,0x55,0xA1,0x1A,0x40,0x80,0x62,0x5E,0x05,0x90,0xDB,0xA8,0x02,0x72,0x6B,0x1F,0x59,0x9E,0x14,0xA9,0x96,0x69,0xD4,0xB9,0xB1,0x97,0xD9,0xE6,0xD5,0x17,0xDB,0x62,0x23,0x9B,0xD7,0x54,0xD5,0xA8,0xAE,0x6E,0x5E,0x73,0x57,0xA3,0x32,0xB2,0x79,0xAD,0x4D,0xAD,0xEA,0xE8,0xE6,0xB5,0x96,0x50,0x9C,0x61,0xAB,0x0C,0x50,0x4D,0xAA,0x01,0xBA,0x0E,0x65,0x40,0x37,0xA5,0x1C,0x40,0xE0,0x14,0xA5,0x2A,0x54,0x03,0xC0,0x00,0x43,0xBA,0x29,0x60,0x73,0x35,0x04,0x4E,0x51,0xAA,0x42,0x35,0xFE,0x1F};
//const uint8_t spALTIMETER[] PROGMEM = {0x23,0xCF,0xBE,0x38,0x23,0x57,0xAF,0x2A,0xDB,0xF6,0x34,0x7B,0xBD,0xAA,0xE4,0xD6,0xC3,0x6C,0xF3,0x2A,0x93,0xBA,0x08,0xB3,0xDE,0xAB,0x4A,0xBA,0xA2,0x45,0xBB,0x84,0x2E,0x2B,0x4D,0x67,0x69,0x03,0x06,0x78,0x31,0x23,0x02,0x2B,0x5B,0xDA,0x44,0x92,0x3B,0xAD,0xB4,0xB9,0x34,0x31,0xED,0xBC,0xB2,0xE2,0xD2,0x2C,0x75,0xF5,0xC8,0x92,0xCD,0x6C,0x65,0x2B,0x23,0xCB,0x26,0x63,0x54,0xC2,0x9C,0x22,0x9B,0x8C,0x74,0x69,0x73,0xCA,0xA2,0xCB,0x3C,0x6C,0xD3,0xA9,0xAA,0x0E,0x4B,0xB1,0xD5,0xA9,0x0E,0x4A,0xB2,0x38,0x12,0x8D,0x66,0x86,0x0A,0x55,0x55,0xDA,0xFA,0x11,0x5A,0x44,0x55,0xE9,0x18,0x72,0x63,0x09,0xB3,0xAC,0x63,0x2C,0xC5,0x30,0x5A,0xBA,0x8C,0xA5,0x84,0x42,0x5D,0xC9,0xDA,0xD6,0x12,0x17,0x69,0xD5,0x5B,0xDB,0x4A,0x29,0xD4,0x95,0xAC,0x65,0x2F,0xA5,0x50,0x57,0xB2,0xFC,0x3F,0x61,0x0C,0x21,0x29,0x3D,0xDC,0xBA,0xD9,0x35,0xB5,0x30,0x97,0xEB,0x06,0xDF,0x39,0x2C,0x9C,0x6B,0xEB,0x42,0xD5,0xD0,0x74,0x76,0xAB,0x4E,0x21,0xD3,0x82,0xDB,0xAE,0x3A,0x9B,0x0D,0x0D,0xD9,0xBC,0xEA,0x1C,0xD3,0xCD,0x7D,0xF5,0xA8,0x8B,0xE5,0x72,0x4D,0x39,0xA5,0x29,0x9A,0x3A,0xC5,0x9C,0xB4,0x2E,0x1B,0x6D,0xA7,0x74,0x9C,0xA6,0xE8,0xBC,0x8A,0x24,0x5E,0x98,0xBD,0x89,0x1C,0xE1,0xA4,0x61,0x37,0x61,0xC3,0x03,0xB3,0xB4,0x3D,0xF8,0x0D,0x0B,0xCA,0x3B,0xF6,0xAC,0xDB,0xBC,0xA8,0xEF,0x3A,0xAA,0x6D,0xF1,0x92,0xCD,0xEB,0xAA,0xBA,0xC4,0xC6,0xB6,0xAC,0xAB,0xE9,0x14,0x6D,0x5F,0xDD,0xEE,0xA6,0x93,0x75,0x7C,0x73,0x7B,0x9A,0x75,0xF2,0x8E,0xD5,0xE5,0x6B,0x49,0xD9,0x23,0x67,0x87,0xBF,0x3B,0x43,0xAB,0x98,0xF5,0xFF};
//const uint8_t spAUTOPILOT[] PROGMEM = {0x65,0x8F,0xB6,0xCB,0x5C,0x9D,0x8C,0x3D,0x9A,0x5D,0x55,0x6D,0xBB,0xA6,0x2C,0x66,0x5D,0xA5,0xEB,0x1A,0x92,0xBA,0x76,0xD5,0xDE,0xAB,0x2D,0x6A,0x32,0x45,0xF2,0xB6,0xA9,0x59,0xC9,0x70,0x52,0xB3,0x8A,0x1C,0xCB,0x9D,0x35,0xD5,0xAA,0xB2,0x1A,0x55,0x8F,0x4C,0xAB,0x2E,0x74,0xDC,0xC2,0x7C,0xAF,0x3A,0x93,0x4D,0x35,0xC9,0x53,0x5A,0x6F,0x36,0x4D,0xB8,0x13,0x02,0x9F,0x2A,0x55,0xA1,0x1A,0x20,0x80,0x2C,0xCA,0x5B,0x95,0x55,0x5A,0xA8,0xC5,0x5A,0x55,0xF2,0x93,0x69,0xB4,0x6A,0x75,0xD9,0x4D,0x86,0xF3,0x96,0xD5,0x55,0xB5,0x69,0xC5,0x5B,0x56,0x57,0xEC,0x9A,0x96,0xAE,0x5E,0x5D,0x71,0x63,0x1E,0xB6,0x79,0xB5,0x03,0x55,0x0B,0x67,0x9B,0xD5,0x74,0xDC,0xA5,0x9C,0x69,0x56,0x55,0x5C,0x69,0x72,0xAC,0x5C,0x65,0xB3,0x4B,0xC9,0xB1,0x64,0x15,0xD5,0x06,0x27,0xD5,0x62,0x36,0x48,0x1D,0x1E,0x99,0x2D,0xFF,0x1F};
//const uint8_t spLOCALIZER[] PROGMEM = {0x2C,0x2B,0x40,0x3A,0x52,0x93,0x88,0xD5,0x91,0x9A,0x0C,0x49,0xAD,0xD6,0x80,0x63,0x32,0x38,0xB3,0x5B,0x12,0xD6,0xEE,0xE0,0xD4,0x69,0xEE,0x84,0xB2,0x9B,0xDC,0x8E,0xBA,0x50,0xDF,0x12,0x6A,0x77,0x8A,0xC2,0x62,0x53,0x38,0xDB,0x49,0x32,0xCB,0x0E,0xE5,0xAC,0x21,0x0A,0x62,0x5A,0x94,0x72,0x93,0xC4,0xCA,0x0E,0x17,0x51,0x03,0x0C,0x48,0xFA,0xA5,0x85,0x49,0x77,0x98,0x69,0xCB,0x91,0x25,0x95,0xE3,0x4E,0x59,0x4B,0xE5,0xCD,0x56,0x12,0xA7,0x29,0x75,0x46,0x3B,0x6C,0xDC,0x69,0xB5,0x49,0x4D,0xBB,0xE8,0xE6,0xD5,0x17,0x31,0x15,0xAA,0x5B,0xD6,0x58,0xC5,0x94,0xA7,0x6D,0x59,0x53,0x53,0x13,0x5A,0xFA,0x79,0xCD,0x5D,0x8F,0x49,0xDB,0xAB,0x31,0x57,0x6F,0x52,0x99,0x97,0x04,0xB0,0x20,0xB1,0x07,0x0C,0xF0,0xB3,0xEB,0xDA,0x9B,0x0F,0xE1,0xD0,0x36,0xED,0x2A,0x39,0x49,0x5A,0xF2,0xB5,0xA7,0x2C,0xE5,0x48,0xE9,0x5B,0xDE,0x32,0x84,0x72,0xB8,0x73,0xFA,0x52,0x72,0xF4,0xF3,0x34,0xE9,0x2B,0x43,0x29,0x5B,0xBB,0x84,0xBF,0x2C,0x96,0x4A,0x5D,0xFD,0xFF};
//const uint8_t spCOWL[] PROGMEM = {0x06,0x68,0x61,0xC4,0x01,0x45,0x27,0x39,0xA0,0xB6,0xE2,0x91,0x97,0x94,0x62,0x69,0x89,0x57,0x9E,0x73,0x79,0xB9,0x2E,0x5E,0x65,0xB6,0x1B,0x96,0xBC,0x65,0x94,0xC9,0x6D,0x44,0xC8,0x96,0x51,0x46,0x7F,0x61,0xAE,0x9B,0x47,0x15,0xED,0x65,0x98,0x6C,0x69,0x75,0xD4,0x5F,0xEE,0xDC,0xA5,0xD5,0xC1,0x7E,0xA9,0xCA,0x96,0x56,0x07,0xFF,0x69,0xA2,0xAB,0x4B,0xE9,0xE3,0x95,0x91,0xAD,0x4E,0xB9,0x8B,0x3B,0x42,0xD1,0x26,0x64,0x36,0xEE,0x08,0x66,0xAA,0x98,0x85,0x3C,0xC8,0x8F,0x00,0x6F,0xF2,0xFF};
//const uint8_t spINFLIGHT[] PROGMEM = {0x6D,0xE8,0x5A,0x28,0xAA,0x2B,0xAF,0xB6,0x39,0x21,0xEF,0x9A,0xBD,0x9A,0xEE,0x8D,0x2C,0x6B,0xF6,0x2A,0x6B,0x14,0xB5,0x98,0x3A,0x25,0xAB,0x1A,0x3A,0x2C,0x12,0xB7,0xB4,0x28,0x6A,0xB7,0x48,0x3C,0xD2,0x2A,0xA9,0xC2,0xDD,0x75,0x49,0xAA,0xC4,0x0E,0x77,0x4F,0x21,0x4D,0x82,0xA6,0xD4,0x35,0x9B,0xBC,0xB0,0xD0,0x52,0x93,0x45,0x80,0x61,0x2B,0x08,0x30,0x7D,0x85,0x00,0xA6,0x4B,0x57,0x40,0xB3,0x65,0x0A,0x18,0x86,0xB4,0xB4,0x41,0x55,0x85,0xF0,0x92,0xD1,0x16,0xBA,0x63,0x4E,0x6B,0x56,0x5F,0xE9,0xB5,0xBA,0xAE,0x5E,0x7D,0x51,0x17,0x9E,0xBE,0x68,0x75,0xD5,0x8E,0x44,0xF8,0xAA,0x55,0x37,0xEF,0xDC,0x5E,0xB3,0x57,0xDB,0xBC,0xF0,0xF8,0xD6,0x6E,0x6D,0x33,0xCC,0xED,0x13,0x1B,0x81,0x53,0x94,0xAA,0x50,0x0D,0x00,0x05,0x0C,0xE9,0xC6,0x80,0xCD,0xD5,0x10,0x38,0x45,0xA9,0x0A,0xD5,0xF8,0x7F};
//const uint8_t spOVERSPEED[] PROGMEM = {0xA9,0x0B,0x7A,0x87,0x59,0xB7,0x94,0x3A,0x8A,0x59,0x11,0xDE,0x5A,0xAA,0xC8,0x6B,0x4D,0xA9,0x4B,0x2B,0x22,0xEF,0x51,0xA3,0x2E,0x2D,0x8F,0xBC,0xCB,0x1D,0x53,0x9B,0x3A,0xA2,0xF4,0xB4,0x90,0x1D,0x9A,0x69,0x5C,0x94,0x5C,0x75,0x2B,0xA3,0x4D,0x77,0x77,0xBB,0xAD,0x88,0xD1,0xB8,0x92,0xB6,0x94,0x32,0x25,0xC3,0x1C,0xEA,0x53,0xCA,0xDC,0x1C,0x6C,0xA8,0x4F,0x29,0xCB,0x24,0xCA,0x90,0x3E,0xAD,0x9C,0xA6,0x84,0xCC,0x9C,0x06,0xE0,0x47,0x55,0x07,0xFC,0xE2,0x62,0x80,0x3F,0x4B,0x0C,0xF0,0xBD,0x32,0x02,0xA7,0x28,0x55,0xA1,0x1A,0x20,0x80,0xE2,0xC2,0x5B,0xD9,0x1C,0xB3,0x96,0xAD,0x1E,0x55,0x8F,0x42,0xDC,0xFE,0xB8,0xD5,0xC3,0x0B,0xF2,0xE6,0xE3,0x56,0x8F,0x28,0x28,0x9B,0xB3,0x4A,0x33,0xA2,0x80,0x6C,0xCD,0x2A,0xCD,0x0C,0x02,0x72,0x39,0xAB,0x34,0xD3,0x29,0xF0,0xD6,0xA4,0xD2,0x74,0xAE,0xA4,0xED,0x0B,0x45,0xCB,0x74,0x55,0x8B,0x44,0x66,0xBD,0x50,0x95,0xAD,0x6C,0xA9,0x4C,0xDD,0x88,0x72,0x64,0xE7,0xFF,0x07};
//const uint8_t spDEPARTURE[] PROGMEM = {0x0A,0x28,0x30,0xAC,0x65,0x5D,0xBA,0x8A,0xD9,0xE6,0x51,0x55,0x65,0x2A,0x6E,0xAB,0x43,0x9D,0x8C,0x99,0x86,0xCC,0x42,0xE0,0x14,0xA5,0x2A,0x54,0x03,0x40,0x00,0x55,0xA4,0x31,0x20,0x99,0xB6,0x52,0xC4,0xD2,0x52,0x89,0x69,0x46,0x15,0xCB,0xB2,0x0F,0x6C,0x19,0x75,0x4A,0xC3,0xB1,0xB8,0x67,0xB4,0xC5,0xAD,0xF0,0x51,0x9F,0xD1,0x95,0x50,0x64,0x2B,0x7D,0xD3,0x90,0x0B,0x6B,0x87,0xBB,0x02,0x05,0x0C,0xAB,0x92,0x80,0x9D,0x3A,0x13,0x30,0xD3,0x86,0x03,0x8A,0x16,0x29,0x4D,0x69,0x42,0xD1,0xD2,0xBB,0xAD,0xA5,0x07,0xC9,0x50,0xDF,0x74,0x95,0x56,0x44,0x47,0xF9,0xCA,0x53,0xB6,0x51,0x14,0xE5,0x75,0x7F,0x9E,0x4A,0xD1,0x92,0x27,0xFC,0x79,0x19,0x5A,0x4B,0xDE,0xF0,0xE7,0xAE,0x58,0xE3,0x9E,0xCD,0x5F,0x9E,0x6A,0x29,0x67,0x51,0x7F,0xED,0x25,0xEE,0x2A,0xE7,0xFF,0x01};
//const uint8_t spLAUNCH[] PROGMEM = {0x6E,0x2E,0xD0,0xA3,0x8A,0x32,0xA7,0x25,0xC3,0xAC,0x4E,0xCA,0xB4,0xE6,0x4C,0xAA,0xDB,0x28,0xED,0x1A,0xA2,0xBA,0x71,0xD1,0xB6,0xAB,0x4F,0x72,0x3B,0xD4,0xD2,0xAE,0x26,0xBA,0xA9,0x30,0xEB,0xBC,0xAA,0x58,0xCB,0x5D,0x63,0xD5,0xC8,0x92,0x2F,0x4B,0x8D,0x44,0x29,0x4B,0x4A,0xA3,0xA8,0x1C,0xB9,0x2C,0x2A,0xC9,0x90,0x8A,0x85,0xC0,0x29,0x4A,0x55,0xA8,0x06,0x28,0x60,0xB6,0x4E,0x07,0xCC,0x3E,0x13,0x80,0xD5,0xA7,0x02,0x30,0xDB,0x8C,0x03,0x66,0x9F,0x72,0xC0,0x6C,0x9D,0x0A,0x98,0x7D,0x4B,0x00,0xA3,0x4D,0xFD,0x3F};
//const uint8_t spTOWER[] PROGMEM = {0x06,0x78,0x4A,0x2D,0x00,0x53,0x99,0xB5,0x2A,0xDB,0x62,0x8B,0x4C,0x34,0xAA,0x12,0xCB,0xC2,0x6C,0xF1,0x18,0x8A,0x9E,0xB0,0x94,0xCD,0x6B,0x2A,0x72,0x4A,0x8B,0xBA,0xAC,0x39,0xCB,0x6D,0x29,0xEE,0xD2,0xD6,0x68,0xAE,0xA5,0xA9,0x4B,0xD9,0x83,0xBB,0xD4,0xC1,0x2E,0x6D,0x8F,0xE1,0xCC,0x16,0xB3,0x94,0x23,0xD9,0x53,0x39,0xEC,0x53,0xCE,0x5C,0x06,0xFD,0x30,0x4B,0xB9,0x72,0x5D,0xB4,0xC3,0xDE,0xE9,0xCE,0x65,0xC1,0x8E,0xFB,0x86,0xBB,0xAC,0xC0,0x0A,0x69,0x1B,0x9E,0xD2,0x12,0xAA,0xB5,0x53,0x78,0xF3,0x33,0x6E,0xB1,0x4C,0xFF,0x0F};
//const uint8_t spFLIGHTWATCH[] PROGMEM = {0x02,0x18,0x2E,0xDD,0x00,0xDD,0x74,0x18,0x60,0x86,0x72,0x03,0x8C,0x90,0x92,0xA2,0x2A,0xB8,0x7A,0x4C,0xEE,0xCA,0x92,0xD8,0x36,0x93,0x24,0x2B,0xCF,0xE2,0xD2,0x4C,0x57,0xAF,0x2C,0x87,0xB1,0x94,0x58,0xBC,0xB2,0x1A,0x52,0x4A,0x73,0xCE,0xCA,0x5B,0x48,0x2C,0xCF,0x45,0xA3,0x6A,0x59,0x30,0xAD,0x1B,0x23,0x70,0x8A,0x52,0x15,0xAA,0x01,0x08,0x28,0xDE,0x54,0xAC,0x5A,0x77,0x84,0x86,0x22,0xB5,0x09,0xBB,0x91,0xAA,0x4A,0xD5,0x26,0xF2,0xB9,0xBA,0xB8,0x0D,0x8B,0xC9,0x17,0x16,0xE4,0x77,0x2C,0xC1,0x6D,0x6A,0xB1,0xBF,0x35,0x27,0x7D,0x2D,0xC9,0x79,0xD6,0x5A,0xC4,0x8E,0x24,0xF7,0x1D,0x5B,0x65,0x3B,0x9C,0xD2,0x67,0xEC,0x45,0x6F,0x5A,0xF1,0xE6,0x74,0xA7,0xD0,0x96,0x69,0x2B,0x11,0x38,0x45,0xA9,0x0A,0xD5,0x00,0x00,0x05,0xAC,0x12,0x1E,0x80,0x55,0x3A,0x02,0xB0,0xCA,0x76,0x00,0x66,0xDE,0x74,0xC0,0xE8,0x9B,0x0A,0x18,0x75,0x8A,0x00,0xAD,0xA6,0xFE,0x3F};
//const uint8_t spSTALL[] PROGMEM = {0x0C,0x78,0xC6,0x95,0x01,0x3F,0xA5,0x28,0xE0,0xB7,0x52,0x0B,0x04,0xE0,0xB7,0x54,0x04,0x4E,0x51,0xAA,0x42,0x35,0x40,0x01,0x43,0xBA,0x31,0x60,0x73,0xB5,0x95,0x35,0x91,0x4E,0x29,0x5B,0x57,0x9D,0x64,0x85,0xA5,0x6C,0x59,0x6D,0x92,0x5D,0x9E,0xD4,0x75,0xF5,0xD1,0x4C,0x45,0x50,0xDF,0x35,0x44,0x3B,0x95,0x46,0x7D,0xC7,0x1A,0xDC,0x54,0x28,0xF7,0x1D,0x5B,0xB4,0x53,0xA9,0xDC,0xA5,0xED,0xC1,0x4F,0x35,0xCB,0x9E,0x76,0x44,0xBB,0x95,0x22,0x7D,0xDA,0x19,0xDD,0x54,0xB3,0xF4,0x29,0x57,0x70,0x53,0x25,0xDA,0x39,0xDD,0x21,0x5C,0x26,0x69,0xE7,0xF4,0x04,0x7B,0x55,0x22,0x59,0xC2,0x13,0x7C,0x4D,0x92,0xE6,0x75,0xAF,0xAE,0xDD,0xC2,0x91,0x59,0x7E,0xFF,0x0F};
//const uint8_t spTOUCHDOWN[] PROGMEM = {0x02,0x78,0x4A,0xCD,0x00,0x53,0x99,0xB5,0x64,0xE8,0x10,0x57,0x59,0xB9,0xB2,0x92,0x52,0x5D,0x6D,0xCD,0x2A,0x4A,0x2C,0x89,0xF0,0xD5,0xAB,0x28,0x21,0x39,0x3D,0x56,0x33,0xC0,0x7A,0x76,0x04,0x74,0x4E,0x66,0x80,0x9B,0x33,0x02,0x70,0x4B,0x4D,0x00,0x6E,0xAE,0x36,0xC0,0xCD,0x53,0x08,0x28,0x30,0x4C,0x03,0xAB,0x6E,0x2A,0x54,0x4B,0x57,0xAF,0xAE,0x98,0x30,0x6F,0x5B,0xB2,0xBA,0xE2,0x5B,0xB5,0x75,0xF5,0x58,0x8B,0x1F,0x93,0xD6,0x55,0x63,0xAB,0x7A,0x83,0x46,0xD6,0x8C,0xB3,0xD8,0x35,0x6E,0x59,0xD2,0xCE,0xA2,0xD7,0x69,0x74,0x4D,0x79,0x92,0x1F,0xF3,0xD2,0x39,0xE1,0x8D,0x7E,0xCC,0x5A,0xE7,0xB8,0x3F,0x8C,0xD0,0xC8,0x98,0xE2,0x7E,0xD7,0xDA,0xC3,0x23,0x96,0xF9,0x7D,0x6C,0x0B,0x8B,0x5A,0xE6,0xCF,0x46,0xAC,0x3C,0x1D,0xBB,0xBF,0x3A,0xD5,0xD4,0xB0,0xFD,0xFF};
//const uint8_t spSQUALK[] PROGMEM = {0x0C,0x78,0xC6,0x95,0x01,0x3F,0xA5,0x28,0xE0,0xB7,0x52,0x0B,0x04,0xE0,0xB7,0x54,0x04,0x4E,0x51,0xAA,0x42,0x35,0x00,0x10,0xE0,0xC3,0x4B,0xCA,0xBC,0x3B,0x72,0x73,0x4F,0xAB,0x0E,0x6E,0xC2,0x82,0xB2,0xAD,0x2A,0x9A,0x69,0x0F,0xF6,0xB6,0x8A,0xE0,0xB6,0xD2,0x39,0xCB,0xC8,0x42,0xDA,0x70,0xB5,0x9E,0x23,0x8D,0x75,0xDC,0x54,0x3B,0xBA,0x2C,0xB5,0x65,0x15,0x76,0x8D,0xC0,0xA2,0x4A,0x55,0xA8,0x06,0x80,0x02,0x7A,0x73,0x65,0x40,0xF3,0x22,0x0C,0x68,0xC5,0x18,0x01,0x35,0xB2,0xFC,0x3F};
//const uint8_t spELEVATION[] PROGMEM = {0x23,0x69,0xC1,0x25,0xAD,0x6A,0xAF,0xAA,0xCA,0x51,0x4F,0xDB,0xBC,0xAA,0x42,0xAE,0x22,0x64,0x75,0x2B,0x0B,0xBC,0x11,0xD5,0xB6,0xA3,0x28,0xE8,0x5A,0x4D,0x63,0xAF,0x22,0xF3,0x2D,0x17,0xED,0xBC,0xCA,0xCC,0xBB,0xDC,0x34,0xF3,0xA8,0xB2,0x4E,0xF7,0x90,0x44,0xA1,0xCD,0x3A,0xDD,0x9D,0x12,0x85,0xBE,0x8A,0x52,0x0D,0x72,0xB2,0xFA,0x1A,0x42,0xCD,0x74,0xF5,0xAA,0xBA,0x6B,0x15,0x97,0xCD,0xAB,0x9E,0xBA,0x15,0x53,0xB7,0xAC,0x7A,0x9A,0x62,0x2C,0xDF,0xBC,0xBA,0xEE,0x02,0xA5,0x62,0xF3,0xE8,0x67,0x1C,0x45,0xD1,0x2C,0x09,0x98,0x79,0x2B,0x01,0x27,0x75,0x27,0x60,0x96,0xED,0x04,0x8C,0xD8,0x36,0xEA,0x16,0x44,0xCC,0x7D,0xD5,0x9A,0xBA,0x4B,0xE1,0xD0,0xBD,0x63,0x9F,0x2A,0x9D,0x43,0xFB,0xB5,0x63,0xA9,0x36,0x71,0xEC,0x57,0xCE,0xA6,0x45,0xCA,0x35,0x5E,0xB9,0xBA,0x52,0x49,0xD7,0x68,0xE5,0xEE,0x56,0x35,0xD4,0x9D,0x96,0xA7,0x19,0x09,0x37,0x73,0x12,0x9E,0x6C,0x5B,0xCC,0xB2,0x76,0x78,0x8B,0xB1,0x30,0xCD,0x3A,0xFF,0x0F};
//const uint8_t spCLIMB[] PROGMEM = {0x06,0xC8,0x39,0x29,0x00,0x8D,0x45,0x06,0x60,0xF2,0xC8,0x96,0x35,0x50,0x39,0x41,0x6E,0x46,0x56,0xD8,0x8C,0x19,0xAF,0x19,0x45,0xA5,0xB3,0x1A,0xB2,0x66,0x55,0x45,0x5C,0x49,0xDA,0x9A,0x55,0x17,0xB5,0x25,0x65,0x6B,0x56,0x5D,0xF4,0x25,0xB7,0xB5,0x5E,0x75,0x35,0x17,0xDC,0xD6,0x66,0x35,0x4D,0xAF,0x4B,0x69,0xEB,0xD5,0x34,0xDF,0xAA,0x69,0xAB,0x57,0x55,0x9C,0x69,0x74,0x2C,0x1A,0x65,0x33,0xA2,0xA5,0x9E,0xBA,0x14,0xCD,0x88,0x16,0x47,0x92,0x52,0x54,0x2D,0x5A,0x1C,0x49,0x4A,0x5E,0x35,0x47,0x52,0xB8,0xAE,0x79,0xCA,0x72,0x0E,0x17,0x89,0x86,0x29,0x4B,0xC9,0xD4,0xBC,0x43,0xFE,0x3F};
//const uint8_t spBANK[] PROGMEM = {0xA9,0x1A,0xCA,0xCD,0xDD,0x92,0xAE,0xAC,0xD8,0x16,0x69,0x79,0xBD,0xEA,0x62,0x4A,0x7C,0xF4,0xF5,0xAA,0xAA,0x2B,0xB1,0xB6,0xC7,0xAB,0xAA,0x2E,0xC5,0xDB,0x66,0xAF,0xBA,0xF9,0x14,0x6F,0x5B,0xBC,0x86,0xEE,0x92,0xBD,0x7D,0xD1,0x1A,0xBB,0x2B,0xB6,0xF1,0x45,0x6B,0x1B,0x3A,0xD9,0x36,0x56,0xED,0xAD,0x1D,0xD3,0x36,0xF1,0xFA,0xC2,0x7E,0x98,0x33,0x08,0xC9,0x31,0xAD,0x6C,0x4F,0x04,0x16,0x55,0xAA,0x42,0x35,0x00,0x14,0xD0,0x9B,0x2B,0x03,0x9A,0x17,0x61,0x40,0x2B,0xC6,0x08,0xA8,0x91,0xE5,0xFF,0x01};
//const uint8_t spACCELERATED[] PROGMEM = {0x6D,0xAA,0xA6,0xD5,0x3B,0x1E,0xB7,0xB1,0xD9,0x56,0x6B,0x7F,0xB3,0x86,0xE6,0x47,0xBC,0xFC,0xF5,0x18,0x6A,0x4F,0x2A,0x89,0xD9,0x08,0x9C,0xA2,0x54,0x85,0x6A,0x00,0x10,0x20,0x2A,0xF7,0x00,0x7C,0xD5,0x15,0x80,0xEF,0x3D,0x1D,0xF0,0x43,0x44,0x00,0xFE,0x88,0x58,0xF9,0xA0,0xA9,0xEA,0x9E,0x69,0xE5,0xD5,0xB4,0x9A,0xDB,0xEB,0x55,0x64,0xD7,0xE6,0xAE,0x8F,0x57,0x91,0xCC,0xB9,0x9B,0xAC,0x6E,0x79,0xB0,0x13,0xC3,0xD2,0xAC,0x14,0x21,0xEB,0xA8,0xB4,0xB6,0x52,0xF8,0x2E,0x59,0x5C,0xEA,0x52,0x19,0x1A,0x57,0xB8,0x6B,0x69,0x55,0x2C,0x5C,0x16,0xE6,0x67,0x55,0x39,0xBA,0x59,0x58,0xDE,0x55,0x35,0x53,0x6C,0xA9,0x9B,0x57,0xD5,0x6C,0x92,0x87,0x6F,0x1E,0x75,0x8B,0xCE,0x4E,0xB1,0x38,0x0D,0xDB,0x95,0x29,0xA9,0xE2,0x55,0x77,0x9D,0x64,0x1A,0x8B,0x57,0xDD,0x54,0xB0,0x45,0x2C,0x5E,0x4D,0xD3,0x49,0x92,0xF1,0xB8,0xB5,0x4D,0x27,0x8B,0xEA,0x63,0x37,0x34,0x66,0x64,0x2E,0xAB,0xFF,0x1F};
//const uint8_t spTRIM[] PROGMEM = {0x0E,0x68,0xCE,0xD4,0x01,0x57,0x9A,0x06,0x60,0x2A,0xB3,0x56,0xE6,0xA2,0x66,0x66,0x4E,0x57,0x95,0x9B,0x9A,0xA5,0x34,0x5F,0x55,0x49,0x26,0x56,0xD2,0x7D,0x55,0xCD,0x07,0x6B,0x4B,0x9B,0x55,0x57,0xEB,0x1A,0xA9,0x73,0x46,0x53,0x85,0x4B,0xB8,0xC4,0x6D,0x5D,0x93,0x2E,0xE9,0x1C,0xB7,0xF5,0x55,0xB8,0xA5,0x71,0xDC,0xD6,0x35,0xE1,0x5A,0x4E,0x71,0x4B,0x9B,0x69,0x68,0x3B,0x35,0x2D,0x7D,0x50,0xE1,0x45,0xE2,0xE6,0xFF,0x01};
//const uint8_t spUNICOM[] PROGMEM = {0x6A,0xA8,0x40,0xBD,0x2E,0x4D,0xBA,0xB6,0x22,0xB1,0x9C,0xA8,0xDD,0xCA,0xEE,0x84,0xB8,0x63,0xD5,0x2A,0xBA,0x55,0x91,0x94,0x37,0xA3,0x68,0x46,0xCC,0x83,0x9E,0x94,0xB2,0x2A,0xEC,0x34,0x49,0x5A,0xEA,0xAA,0xB0,0xD2,0x25,0xDE,0xEA,0xAA,0x49,0x17,0x93,0x35,0xAB,0xAF,0xD2,0xD5,0x53,0x1F,0x95,0xB5,0x4B,0x67,0x2B,0xFE,0x82,0xC0,0x29,0x4A,0x55,0xA8,0x06,0x80,0x01,0x72,0x50,0x51,0x40,0xC9,0x8A,0xA3,0x4B,0xC5,0x2D,0x8A,0x5B,0xAD,0x36,0xC7,0x76,0x2F,0xDE,0xB2,0xE6,0xA2,0xA6,0x64,0xA4,0xCD,0x5A,0x8A,0x9C,0x96,0x96,0x36,0x6B,0x6B,0x7C,0x86,0x5B,0xBA,0x8E,0xBB,0xB1,0x19,0x69,0x69,0xDB,0xEE,0xCA,0x77,0xB8,0xB4,0x6B,0xF9,0xB3,0xBE,0xA2,0xD6,0x35,0xE5,0x8F,0x69,0xC2,0x42,0xE6,0x94,0x3F,0xEB,0xF2,0x12,0xB4,0x5A,0xBE,0x22,0xCA,0x4B,0xD1,0x6C,0xF9,0x8A,0x8B,0x2C,0x35,0x29,0xE5,0x6B,0xDA,0xBD,0x4C,0xCC,0x84,0x2F,0xBA,0x8A,0x34,0xAB,0xFB,0xFF};
//const uint8_t spSLOKE[] PROGMEM = {0x02,0xF8,0x56,0xC4,0x00,0x3F,0xBA,0x28,0xE0,0x07,0x0B,0x03,0xFC,0x60,0x66,0x80,0x5F,0xD4,0x0C,0xF0,0x4B,0xA8,0x02,0x7E,0x31,0x29,0xFD,0x10,0xEA,0x96,0xEC,0xAE,0xF5,0x95,0x7A,0xA6,0xC3,0xD6,0xD5,0x17,0x61,0x55,0x4C,0xAD,0x57,0x5B,0x58,0x76,0x29,0xF6,0x5D,0x55,0x61,0x31,0xA1,0xD4,0x77,0x15,0x89,0xF7,0x98,0x4A,0x9F,0x92,0x79,0xB5,0xA5,0x6C,0xBD,0x11,0x38,0x45,0xA9,0x0A,0xD5,0x00,0x10,0x40,0x32,0x26,0x02,0x48,0x41,0x85,0x00,0xCE,0x2B,0xFE,0x3F};
//const uint8_t spNINER[] PROGMEM = {0x66,0xAA,0x1A,0xB5,0xDC,0x9A,0x84,0x35,0x4B,0xCA,0xD4,0x68,0x1C,0xD6,0x24,0x29,0x53,0xA3,0x4E,0x59,0xAA,0x22,0x2F,0xB3,0xBA,0x6D,0x6A,0x9A,0xAC,0x4D,0xE3,0xAE,0xB1,0xB8,0x36,0x33,0x7B,0xBC,0xDA,0x6A,0xC7,0x2D,0x64,0xF5,0xAA,0x9B,0xD9,0x90,0x94,0x2D,0xAB,0xEA,0xAA,0x4D,0x47,0x57,0xAF,0xA2,0xB9,0xA4,0x18,0x5F,0xB4,0xCA,0xE6,0x9D,0xAA,0x63,0x52,0x6B,0xAA,0xC5,0x72,0x0B,0xC7,0x63,0x68,0x85,0x9D,0x33,0x13,0x8D,0xA5,0x66,0xC7,0x2C,0xDD,0xD4,0xD6,0x66,0x4F,0xF0,0x38,0x6F,0xDB,0x6B,0x5C,0xE2,0xA5,0xBC,0xE1,0x2C,0xF1,0x88,0x8E,0xFA,0xA6,0xAF,0xD9,0x67,0x3C,0xCE,0x5B,0xFE,0x1A,0x17,0x7C,0x35,0xB7,0xFB,0xCB,0x36,0x5A,0x97,0x59,0xF0,0xFF};
//const uint8_t spGALLEY[] PROGMEM = {0x04,0x68,0x41,0x7D,0xB4,0x3D,0x18,0x49,0xFA,0xEA,0x55,0xB5,0x28,0xEC,0x1D,0x4F,0x56,0x5D,0x7D,0x70,0xB4,0x3F,0x59,0x75,0xF5,0x25,0x95,0xF6,0x78,0x55,0xC5,0xAE,0x95,0xDB,0xAD,0x51,0xC6,0x38,0xD6,0x58,0x53,0x4A,0x11,0xF9,0xBB,0x05,0x2D,0x5A,0x65,0x2C,0xA9,0x29,0x33,0x67,0x35,0x45,0x35,0x8D,0xE5,0xED,0xD5,0x0D,0x5D,0x10,0xE1,0x8F,0xD6,0xD0,0x8D,0x83,0x57,0x3E,0x6A,0x63,0xB3,0x82,0x59,0xF9,0xC8,0x65,0xCD,0x10,0xA5,0x7B,0xCB,0xFF,0x07};
//const uint8_t spFREEDOM[] PROGMEM = {0x04,0x18,0xB6,0x82,0x00,0xD3,0x57,0x08,0x60,0xBA,0x74,0x05,0x34,0x5B,0xD6,0xB2,0x54,0xA8,0x29,0x2D,0xFD,0xCA,0x6A,0x62,0x75,0xD7,0xA5,0x2B,0xEF,0xD5,0x48,0xDC,0x37,0xAF,0x7C,0x44,0x43,0x8E,0x58,0xDD,0xCA,0x9E,0x04,0xC5,0xED,0xF1,0x18,0xB6,0x4D,0x53,0x56,0x3B,0x63,0xEA,0xD6,0x85,0x43,0x57,0xAF,0xB1,0x28,0x13,0xAF,0x78,0x3D,0xE6,0x6C,0xD5,0xD2,0x7D,0x73,0x39,0x72,0x70,0x0F,0xD7,0x57,0xE5,0x4A,0x26,0x3D,0x55,0x9B,0x96,0x27,0xEB,0xD0,0x24,0xB1,0x53,0x9E,0xAA,0xCD,0x82,0xCD,0x4E,0x79,0x8A,0x31,0x0F,0x32,0x39,0xE9,0x49,0x26,0x34,0xC5,0xE2,0xA4,0xA7,0x44,0x4F,0x57,0x6B,0x92,0xDE,0x12,0xD4,0x5C,0x3D,0xF2,0xFF,0x03};
//const uint8_t spFLIGHT[] PROGMEM = {0x02,0x28,0xC6,0x55,0x00,0xDD,0xA4,0x2B,0x60,0xB8,0x32,0x05,0x0C,0x13,0x5C,0x86,0xA2,0x39,0x3A,0x55,0x6E,0xE8,0xA3,0xD0,0x33,0x96,0xB6,0xAB,0xAF,0x64,0xC6,0x8D,0xD6,0xAC,0x36,0xEB,0x0D,0xF7,0xB8,0xBD,0xEA,0x6A,0x5A,0x22,0x63,0xF6,0xAA,0x5A,0x30,0x2E,0x9F,0xD9,0xA3,0x6C,0x8E,0xB9,0xA3,0x23,0xBB,0x3E,0x08,0xD5,0x8D,0x8A,0x6C,0xEE,0x61,0x93,0xA9,0x62,0x8B,0xBD,0x11,0x38,0x45,0xA9,0x0A,0xD5,0x00,0x30,0xC0,0x53,0x66,0x06,0x78,0xBE,0xE2,0xFF,0x01};
//const uint8_t spDEGREE[] PROGMEM = {0x0C,0x28,0x30,0x2C,0x45,0x43,0x9A,0x72,0xD8,0xEB,0x9D,0xAD,0xBA,0x0B,0x67,0x6E,0x7F,0x3D,0x9A,0xA1,0x1D,0xB9,0xF5,0x0B,0x02,0xA7,0x28,0x55,0xA1,0x1A,0x10,0xD6,0x5C,0x3A,0x35,0x2C,0x66,0x1A,0xA2,0x75,0x73,0x33,0xA7,0xA9,0x0F,0x51,0xD2,0x54,0xDD,0xB6,0x3A,0x27,0x6A,0x4A,0xCB,0xB6,0xCA,0x92,0xC8,0x2C,0x6C,0xED,0x2A,0x7B,0x54,0xD4,0xF2,0xD7,0xA3,0x1A,0xDE,0x50,0x26,0x1E,0xB7,0x7A,0x04,0x05,0x99,0x7C,0xDC,0xEA,0x19,0x0D,0xA8,0xEB,0x76,0xAB,0x66,0x30,0xA0,0xAA,0x59,0xAD,0x1A,0x41,0x40,0xAA,0x67,0xA5,0xAA,0x79,0x14,0xAB,0x9E,0xFD,0xFF};
//const uint8_t spAIRPORT[] PROGMEM = {0x63,0xEC,0xC1,0xB0,0x2A,0x1E,0x9D,0xA6,0xA7,0x46,0x29,0x5D,0x7D,0xEA,0xBA,0x02,0x4B,0x75,0xD5,0xA8,0xCB,0x13,0x5A,0xB2,0x55,0xAD,0xCA,0x4B,0x70,0x9D,0x37,0xA5,0x2A,0xB4,0xC0,0x4D,0xEC,0x82,0xC0,0x29,0x4A,0x55,0xA8,0x06,0x00,0x03,0x82,0x77,0xE7,0x00,0x02,0x68,0x19,0x2E,0xBD,0x77,0x17,0x12,0x9C,0xB9,0xCD,0x41,0x5D,0xB3,0x9B,0xDE,0xB6,0x44,0x7D,0x29,0x25,0xFA,0xCA,0x1E,0xC2,0xA8,0x0F,0xFB,0x6B,0x77,0x0A,0x43,0xBE,0xE2,0xA7,0x5C,0xA5,0x0C,0x78,0x8B,0x7E,0x04,0x4E,0x51,0xAA,0x42,0x35,0x00,0x40,0x01,0x53,0xA8,0x2B,0xE0,0xF9,0x8A,0xFF,0x07};
//const uint8_t spAIRSPEED[] PROGMEM = {0x2A,0xEB,0x29,0x59,0xD3,0x9A,0xAC,0xBD,0x87,0x24,0x69,0x5F,0xBC,0xC6,0xE1,0x86,0xA1,0x6D,0xF3,0x1A,0xBA,0x3F,0xC1,0xE1,0x3E,0xAB,0x69,0xF6,0x05,0x96,0xFB,0xAC,0xAA,0xBA,0x23,0x3C,0xF1,0x33,0xCA,0xDA,0x02,0x86,0xA2,0x73,0xAB,0x96,0x9E,0x14,0x52,0xB5,0x0E,0xF8,0x49,0xD8,0x01,0xBF,0x5A,0x1A,0xE0,0xAF,0x70,0x01,0x24,0xA0,0x81,0x00,0x8F,0x55,0x08,0x10,0xB9,0xD5,0xC8,0x5A,0x52,0x61,0xD7,0xD7,0xAB,0x9C,0x31,0x18,0xD3,0xB6,0xAE,0x6A,0xC6,0x40,0xE8,0x5C,0x32,0xAA,0x99,0x02,0xA1,0x6B,0x76,0xAB,0x66,0x34,0xA0,0xA9,0x59,0xAD,0x9A,0x49,0x41,0xA6,0x26,0xB5,0x62,0x46,0x01,0xE9,0x9A,0xD5,0x8A,0xAE,0x19,0x3D,0x73,0x31,0x2B,0x99,0xDE,0x4C,0x37,0xCB,0xAE,0x1E,0x46,0x94,0xCC,0xD2,0x94,0xA1,0x6A,0x55,0xB5,0x5C,0xF5,0xFF};
//const uint8_t spCLEARANCE[] PROGMEM = {0x0E,0xC8,0x21,0x3D,0x00,0x53,0x99,0xA5,0xEC,0x45,0xB7,0x08,0x89,0x32,0x8A,0x4C,0xA3,0x4D,0xB4,0xED,0x29,0xAA,0x77,0x37,0xB1,0x35,0x27,0x6F,0x31,0x4C,0x5C,0xB6,0x9C,0xBC,0x99,0x56,0x6C,0xED,0xB2,0xCA,0x1C,0x5D,0xAD,0xA4,0x5D,0xAB,0x63,0x91,0x8A,0x74,0xF7,0xAD,0x8B,0x45,0x23,0x32,0xD4,0x8F,0x35,0x65,0xC9,0x88,0xF0,0xB6,0xD6,0xEC,0x43,0x33,0x6C,0x73,0xDB,0x8B,0x4E,0xCD,0xF0,0x5D,0x69,0xAF,0x4A,0x74,0xD4,0x12,0xA9,0xA3,0x58,0x35,0x65,0x5F,0x88,0x80,0x42,0xC2,0x19,0xF0,0x8C,0xAB,0x02,0x7E,0x4A,0x31,0xC0,0x6F,0xA5,0x1E,0x30,0xC0,0x6F,0xA9,0x0A,0xF8,0xA5,0xEC,0xFF,0x01};
//const uint8_t spALTITUDE[] PROGMEM = {0xAD,0xAE,0xA6,0xB4,0xD2,0x6F,0x8D,0xA5,0xA9,0x0D,0x2D,0x5D,0xBD,0xBA,0x26,0xB6,0xA4,0x6C,0xF5,0xAA,0x2B,0xBB,0xD1,0xF0,0xCE,0xAB,0x48,0xEA,0xD3,0xCC,0x3B,0xAF,0x22,0xBA,0xCE,0x60,0xEB,0x8C,0xC0,0x29,0x4A,0x55,0xA8,0x06,0x38,0x60,0x72,0x8B,0x92,0x5C,0x16,0x2A,0x6A,0xB9,0x56,0x3E,0x68,0x1A,0x87,0x6F,0x5E,0x55,0xA7,0xA9,0x9C,0xB6,0x1A,0x81,0x53,0x94,0xAA,0x50,0x0D,0x08,0xC0,0x12,0x16,0x09,0xF8,0xBA,0x6B,0x14,0xC7,0x4E,0xA7,0x3B,0xE3,0x52,0x65,0x6D,0xE4,0x95,0xAB,0x46,0x55,0xB9,0x89,0x96,0x6C,0x19,0x4D,0xA5,0xA6,0xD6,0xB4,0xA5,0x34,0x85,0xB8,0x79,0xD3,0xE7,0x52,0x67,0x1C,0x6E,0xCD,0x6F,0x5A,0x9D,0x49,0x98,0x37,0xBF,0x0E,0x75,0x50,0x29,0x5E,0xF6,0x84,0x95,0x4C,0x6F,0xA6,0x9B,0x65,0x57,0x0F,0x23,0x4A,0x66,0x69,0x04,0x50,0x60,0x58,0x19,0xAA,0x56,0x55,0xCB,0x55,0xFF,0x0F};
//const uint8_t spRADIAL[] PROGMEM = {0x6A,0x12,0xC3,0xB4,0x52,0x95,0xAA,0x49,0x74,0xD7,0x0C,0x53,0xE2,0x26,0xD3,0xD4,0xD2,0x4C,0x5D,0xE9,0x62,0xA1,0x56,0x8D,0xDC,0xAB,0x2B,0x21,0x54,0x93,0x57,0xAF,0xA6,0xA5,0x60,0x0D,0x79,0xB3,0x9A,0xDE,0x94,0xD4,0xFD,0xF1,0xAA,0x47,0x56,0xD4,0x8C,0x25,0xAD,0x6E,0x54,0x54,0x26,0x13,0xB2,0x51,0x89,0x8A,0x09,0xB5,0x55,0x96,0x2D,0x13,0x29,0xBC,0x57,0x19,0x7A,0x60,0xB4,0xEA,0xD9,0x6D,0x1C,0x4E,0x50,0xA7,0x16,0x8D,0x79,0x58,0x27,0x9C,0x58,0xBD,0xE6,0x6E,0x9C,0xA4,0x6D,0xF3,0xD8,0xB2,0x2A,0xB1,0xB6,0x2D,0xE3,0xCA,0xA2,0x33,0x92,0x7B,0x97,0x3B,0xCA,0x6D,0x73,0xC9,0x5B,0xEE,0x24,0xB6,0x43,0xB9,0x6B,0x79,0xA2,0xB8,0x71,0xE5,0xB4,0xE9,0x0D,0xE6,0xDA,0x44,0xBA,0xA5,0x37,0xAA,0x9A,0x30,0x4A,0x9B,0xBE,0xA8,0x72,0x22,0x28,0x4D,0xFA,0xA3,0x8C,0x4E,0xA7,0x34,0xFF,0x0F};
//const uint8_t spREMARK[] PROGMEM = {0x2C,0xD0,0xA9,0xD8,0xCB,0xAD,0xA9,0x4D,0x76,0xE3,0x74,0x57,0x62,0x56,0x59,0x5D,0x22,0xCC,0x89,0x5B,0x54,0x53,0x2B,0x73,0x67,0x69,0x8C,0x15,0xCB,0xD2,0xBD,0xAD,0xA6,0x26,0x76,0x31,0x6B,0xBB,0xAA,0x9E,0x9C,0x38,0xED,0xCB,0xCA,0x66,0x08,0x84,0x8A,0x35,0x2D,0xEB,0x56,0x40,0xAF,0x16,0xB7,0xA4,0x18,0xD4,0x2A,0x9F,0xEC,0x32,0x6D,0x74,0x8A,0xBC,0x49,0x2A,0x83,0xE4,0x1C,0xF6,0x38,0xA5,0xCA,0x9A,0xDA,0xD9,0x9D,0xAC,0xAA,0x68,0xCD,0x36,0xB1,0xB3,0xAA,0x10,0x2E,0xB5,0xA8,0xED,0xAA,0xA2,0xB9,0xD4,0xA1,0x26,0xAB,0xCE,0xFA,0x42,0x97,0xDB,0xEC,0x7A,0xB5,0x45,0x9D,0xE9,0x51,0x97,0x31,0x14,0x7B,0xAA,0x47,0x9B,0xC7,0x50,0xFD,0xB2,0x2E,0xF5,0x46,0xE0,0x14,0xA5,0x2A,0x54,0x03,0x00,0xC0,0x01,0xBD,0xB9,0x2A,0xA0,0x79,0x11,0x06,0xB4,0x62,0x8C,0x80,0x1A,0x59,0xFE,0x1F};
//const uint8_t spREFUELLING[] PROGMEM = {0xAE,0x37,0xD5,0xB4,0x42,0xEC,0xB9,0x5E,0x17,0xD7,0x0C,0x56,0x96,0xFA,0x98,0xB1,0xD5,0xC2,0xDD,0xA8,0x6B,0xC6,0x60,0x8B,0xB5,0xA3,0xEE,0xCA,0x50,0x26,0x57,0xB7,0x6A,0x72,0x23,0x9E,0x9A,0x55,0xEA,0x66,0x04,0x6C,0x6A,0x16,0x02,0x94,0x14,0x31,0x40,0x77,0x65,0x06,0x18,0xAE,0xDD,0x00,0x23,0x4C,0x3A,0x60,0xA4,0xCD,0x11,0x0E,0x6F,0x44,0x69,0x5B,0x56,0x3E,0x7C,0x30,0xA4,0xAE,0x5D,0x79,0x57,0xA6,0x54,0xBC,0xB6,0xE5,0x91,0x67,0x5A,0x73,0x97,0x94,0x27,0x5A,0xA3,0x85,0xD9,0x5A,0x55,0x98,0xB5,0x27,0xA6,0x2F,0x43,0xD4,0xBA,0xC6,0x96,0x2E,0x2D,0x09,0xD7,0x9A,0x71,0x9F,0xB6,0x66,0x56,0xE5,0xA1,0x7D,0xC6,0x5A,0x65,0xBA,0xA4,0x6E,0x1E,0x7B,0xB5,0x29,0x1A,0xFA,0xB9,0x9C,0x3D,0x87,0x70,0xEA,0xED,0x76,0xF7,0x14,0xCC,0x63,0x8F,0xDA,0xDB,0xB3,0x88,0x97,0xD6,0x6E,0x7F,0xF7,0x6C,0xD6,0x56,0xA7,0x7D,0xCD,0x70,0x78,0x5A,0xEC,0xF1,0x35,0xAD,0xEE,0x16,0x75,0xEA,0x53,0x9E,0xAA,0x34,0x4A,0x23,0xCE,0xFF,0x03};
//const uint8_t spOUTER[] PROGMEM = {0xA9,0x4B,0x39,0x23,0x6C,0x12,0x8D,0xA9,0xA8,0xB3,0xB4,0x5C,0xB2,0xC6,0x2A,0x3E,0x22,0x62,0xC9,0xEA,0x1A,0xFD,0x88,0xF0,0x35,0xAB,0x29,0xF2,0xBC,0xCC,0x3B,0xAF,0x32,0xFA,0xB5,0x62,0xDF,0xB4,0x8A,0xE4,0xC6,0x8A,0xAD,0x63,0xE8,0xAB,0x55,0x17,0x0B,0x5B,0x01,0xE8,0x3A,0xAC,0x54,0x2D,0x6D,0xB8,0x2A,0x9D,0x52,0xA4,0x24,0x5C,0xE9,0xAD,0x47,0x51,0x4A,0x83,0x2E,0xF6,0x6E,0x55,0x4E,0x83,0xF4,0x94,0xBB,0x54,0x25,0x2C,0xE2,0x51,0x9E,0x54,0xA7,0x18,0x18,0x43,0xB9,0xFF,0x1F};
//const uint8_t spMIDDLE[] PROGMEM = {0x69,0x2E,0x92,0xF4,0x9C,0xAB,0x96,0xB9,0x1A,0xB4,0x52,0x4F,0x1A,0xA6,0xA0,0x24,0x8B,0x23,0x4A,0x9A,0xB2,0x22,0x6F,0xB3,0x38,0x6D,0xC8,0x8A,0xAD,0x43,0xEA,0xAC,0xA6,0xCB,0x74,0x76,0xDD,0xB3,0xAA,0xCE,0xDC,0x2C,0xED,0xCB,0x2A,0x86,0x08,0x53,0xE3,0x2D,0xA2,0xE2,0xAA,0x3D,0x22,0x66,0x97,0x76,0xD9,0x08,0x53,0xB3,0xBD,0x8A,0xC2,0x22,0xC2,0x39,0xEB,0x2A,0x0B,0xAB,0x0A,0xA1,0xAE,0xAD,0xCA,0xB8,0x27,0x84,0xBA,0xB6,0x2A,0xB1,0x9A,0x64,0x6A,0x93,0xAA,0x20,0x6A,0x92,0xB8,0x73,0x69,0x33,0x9D,0x2A,0x91,0x36,0xFF,0x0F};
//const uint8_t spINNER[] PROGMEM = {0xA5,0x6A,0x52,0xA9,0x37,0x2B,0xAD,0x6A,0xD8,0x40,0xEB,0x98,0xB5,0x8A,0xEE,0x9D,0x3C,0xE2,0xF6,0x2A,0xBB,0x0D,0x0E,0xD7,0xC7,0xAB,0x6A,0x1E,0x3D,0xDD,0xED,0xAE,0xAA,0x37,0x09,0x15,0x49,0xBB,0xEA,0xD2,0x45,0xC3,0xAD,0xCD,0x68,0x4A,0x1B,0x92,0xC1,0xBC,0xAD,0x2E,0xFE,0x04,0x5E,0xFC,0xB5,0xAA,0xDA,0x17,0x38,0xD1,0xD7,0xEA,0x92,0x0E,0xE4,0xD4,0x4F,0x69,0x4B,0x5C,0xD0,0x16,0xDD,0xFF,0x0F};
//const uint8_t spINSTRUMENTS[] PROGMEM = {0xA2,0x8F,0xDA,0x63,0xB7,0x23,0xA6,0xA1,0x6A,0xB1,0xCB,0x8E,0x34,0xC6,0xA6,0x9D,0xAA,0xB3,0xD2,0xEA,0xBB,0x37,0xF2,0x88,0x45,0xA3,0x6D,0x46,0x34,0x25,0x6B,0x97,0x36,0x49,0xEA,0x94,0x70,0x12,0xBA,0x28,0x69,0x82,0x2B,0x71,0x08,0x5E,0x12,0x52,0x55,0xA5,0x0E,0x78,0x4E,0xC8,0x01,0x4F,0x93,0x1B,0xE0,0xE5,0x76,0x06,0x34,0xCF,0x2E,0x80,0x5E,0xCB,0x02,0xD0,0x8C,0x53,0x1B,0x52,0xE1,0xB0,0x88,0xAC,0x6D,0x88,0x45,0x22,0x52,0xD7,0xA4,0x39,0x1A,0xE3,0x2A,0x4E,0x9A,0x8E,0xCA,0x83,0xAC,0xB9,0x6E,0x3B,0x8B,0x2E,0x0D,0xE3,0xB6,0xE3,0x2C,0x3E,0xD5,0xC3,0xF6,0xB4,0xAB,0x99,0x34,0x4B,0x59,0x5D,0xAE,0x26,0x53,0xBD,0x64,0x73,0x79,0xAA,0x21,0x6B,0x77,0xAB,0xE9,0x89,0x4A,0xA2,0x25,0x12,0x23,0x70,0x8A,0x52,0x15,0xAA,0x01,0x00,0x0A,0x98,0x42,0x5D,0x00,0xCF,0x57,0x30,0xE0,0x3B,0x41,0x05,0xFC,0x12,0xA6,0x80,0x9F,0xDD,0x14,0xF0,0x8C,0x2B,0x03,0x7E,0x4A,0xF9,0x7F};
//const uint8_t spFLIGHT[] PROGMEM = {0x04,0x68,0x2A,0x42,0x00,0xC5,0xB8,0x0A,0xA0,0x9B,0x74,0x05,0x0C,0x57,0xA6,0x80,0x61,0x82,0xCB,0x50,0x34,0x47,0xA7,0xCA,0x0D,0x7D,0x14,0x7A,0xC6,0xD2,0x76,0xF5,0x95,0xCC,0xB8,0xD1,0x9A,0xD5,0x66,0xBD,0xE1,0x1E,0xB7,0x57,0x5D,0x4D,0x4B,0x64,0xCC,0x5E,0x55,0x0B,0xC6,0xE5,0x33,0x7B,0x94,0xCD,0x31,0x77,0x74,0x64,0xD7,0x07,0xA1,0xBA,0x51,0x91,0x11,0x38,0x45,0xA9,0x0A,0xD5,0x00,0x00,0x03,0x0C,0xE9,0x26,0x80,0xCD,0xD5,0x10,0x38,0x45,0xA9,0x0A,0xD5,0xF8,0x7F};
//const uint8_t spAPPROACHES[] PROGMEM = {0x63,0xCD,0x66,0x24,0x32,0x1B,0xAD,0xA5,0x98,0x55,0xF3,0xD8,0x75,0x86,0xCA,0x27,0xDC,0xB5,0xCF,0x19,0x92,0x9C,0x88,0xB0,0x5D,0x65,0x08,0x61,0xCC,0xDC,0x76,0x21,0x70,0x8A,0x52,0x15,0xAA,0x01,0xA0,0x80,0x94,0xCD,0x15,0x90,0xB3,0x47,0xC9,0x42,0x93,0x32,0xF1,0x2C,0x35,0x5B,0x79,0xB2,0x99,0x66,0xD2,0x7C,0x65,0x95,0x44,0x6B,0x51,0xB6,0x91,0x66,0x9E,0xC5,0xCE,0xD9,0x52,0x11,0x0B,0xAB,0x59,0xC4,0x46,0x7E,0xE3,0xCA,0x26,0xEE,0x9A,0x00,0x4D,0x92,0x06,0x60,0xB7,0xB0,0x04,0xEC,0xD4,0xBD,0xAA,0x19,0x9C,0xD9,0x34,0xEF,0x6A,0xAB,0x75,0x16,0x8F,0xCD,0xAB,0xAB,0x2A,0x44,0x33,0x37,0xAF,0xB1,0x89,0x10,0x73,0xDF,0x3C,0xC6,0x2E,0x4D,0xC2,0xB4,0x77,0x9B,0x9B,0x54,0x75,0xD5,0xDE,0x6D,0xEE,0x24,0x9C,0x34,0xFB,0xB6,0x79,0x61,0x75,0x53,0xCF,0x5A,0xFE,0x17,0xD4,0x86,0xC9,0x89,0x02,0x7E,0x2B,0x55,0xC0,0xAF,0xEE,0x02,0xF8,0x29,0xFD,0xFF,0x01};
//const uint8_t spGEAR[] PROGMEM = {0x6D,0xDC,0x21,0x39,0x34,0x92,0xB4,0xAE,0x09,0xA6,0x9A,0x8E,0xBD,0x9A,0xEE,0x19,0xA3,0x6B,0xC9,0x6A,0x7A,0x31,0x54,0x8F,0xC7,0xAB,0xED,0xB1,0x40,0x52,0x5F,0xAD,0xB6,0xDB,0x41,0x1A,0xDE,0x3C,0xDA,0xEA,0x06,0x79,0x69,0x77,0x6B,0x4A,0x5E,0x90,0xC5,0x5E,0xAD,0x2E,0x71,0x41,0x8E,0x7A,0xB7,0x2A,0x87,0x01,0x3F,0xEA,0x55,0xAA,0x5C,0x13,0x6A,0xA8,0x67,0x68,0x52,0x71,0x98,0xE2,0x5C,0xAC,0xCC,0xC4,0xDC,0x22,0x14,0xFD,0x3F};
//const uint8_t spBOOST[] PROGMEM = {0x0C,0x50,0xD6,0xAC,0x94,0x51,0xAB,0x67,0x60,0x9F,0x5A,0xD6,0xB6,0x0E,0x69,0xB4,0xAA,0x52,0x93,0xBA,0xE4,0xC5,0xAF,0x06,0x78,0xC6,0x55,0x01,0x3F,0xA5,0x28,0xE0,0xB7,0x52,0x0D,0x18,0xE0,0xB7,0x54,0x03,0xFC,0x52,0xA6,0x80,0x9F,0xCB,0x10,0x38,0x45,0xA9,0x0A,0xD5,0x00,0x30,0xC0,0x90,0x6E,0x02,0xD8,0x5C,0xED,0xFF,0x01};
//const uint8_t spTELEPHONE[] PROGMEM = {0x0C,0x98,0xD6,0xDC,0x01,0x47,0x9A,0x16,0x7F,0xFA,0x14,0x13,0x4A,0xB5,0xEA,0x6A,0x52,0x53,0x75,0xF5,0xAA,0x1B,0x9B,0xB4,0xE0,0x3E,0xAB,0xEE,0xA0,0x2A,0x93,0xFC,0xAC,0xBA,0xF0,0x8E,0x11,0xCA,0xBD,0x9A,0x62,0xB2,0x52,0xA8,0x75,0xE9,0x92,0xD5,0x74,0x92,0xC6,0x02,0x18,0xB6,0xC2,0x03,0x06,0x98,0xBE,0x42,0x02,0xA3,0x0E,0x7E,0xCC,0x95,0x3B,0xAE,0x29,0x86,0xF6,0x30,0x5A,0xB5,0xD6,0xE8,0x27,0xCC,0xA8,0x4E,0xDB,0xA2,0xAD,0x0A,0xE1,0xAA,0x65,0x8F,0x3E,0x46,0x45,0x9D,0x96,0x23,0xC6,0x68,0x55,0x75,0x92,0xCE,0xE8,0xBC,0x4D,0x4C,0x4E,0x3A,0x93,0xB1,0x51,0x57,0x25,0xE9,0x6C,0x86,0xD3,0xDD,0xE4,0x84,0xAB,0x69,0xAC,0x72,0x55,0x12,0xAE,0xA2,0x28,0xD3,0x42,0x51,0xB8,0x9B,0x66,0x2F,0x75,0x3B,0xF1,0x0E,0x77,0xD3,0x6A,0x69,0x9E,0xE8,0xFF,0x01};
void setup() {
CircuitPlayground.begin();
CircuitPlayground.speaker.say(spWIND);
CircuitPlayground.speaker.say(spNORTHEAST);
CircuitPlayground.speaker.say(spGUSTING_TO);
CircuitPlayground.speaker.say(spFOURTY);
CircuitPlayground.speaker.say(spMILES);
CircuitPlayground.speaker.say(spPER);
CircuitPlayground.speaker.say(spHOUR);
// Calling speaker.end() after playing a sound is optional -- this
// will turn off the pin 13 LED (it's connected to a microcontroller
// pin that's also related to the speaker), but there's a small
// audible click when it turns off. Tradeoffs!
CircuitPlayground.speaker.end();
}
void loop() {
}

243
arduino-cli/libraries/Adafruit_Circuit_Playground/examples/Speech_Demos/Talk_US_Male/Talk_US_Male.ino Normal file
View File

@@ -0,0 +1,243 @@
// Talkie library
// Copyright 2011 Peter Knight
// This code is released under GPLv2 license.
//
// The following phrases are derived from VM61002 ROM
//
// A male voice with a US accent.
//
// These phrases have a very military bias
// with lots of very useful engineering words.
// They also have good expression.
//
#include <Adafruit_CircuitPlayground.h>
#include <Wire.h>
#include <SPI.h>
//const uint8_t spZERO[] PROGMEM = {0x69,0xFB,0x59,0xDD,0x51,0xD5,0xD7,0xB5,0x6F,0x0A,0x78,0xC0,0x52,0x01,0x0F,0x50,0xAC,0xF6,0xA8,0x16,0x15,0xF2,0x7B,0xEA,0x19,0x47,0xD0,0x64,0xEB,0xAD,0x76,0xB5,0xEB,0xD1,0x96,0x24,0x6E,0x62,0x6D,0x5B,0x1F,0x0A,0xA7,0xB9,0xC5,0xAB,0xFD,0x1A,0x62,0xF0,0xF0,0xE2,0x6C,0x73,0x1C,0x73,0x52,0x1D,0x19,0x94,0x6F,0xCE,0x7D,0xED,0x6B,0xD9,0x82,0xDC,0x48,0xC7,0x2E,0x71,0x8B,0xBB,0xDF,0xFF,0x1F};
//const uint8_t spFOUR[] PROGMEM = {0x08,0x68,0x21,0x0D,0x03,0x04,0x28,0xCE,0x92,0x03,0x23,0x4A,0xCA,0xA6,0x1C,0xDA,0xAD,0xB4,0x70,0xED,0x19,0x64,0xB7,0xD3,0x91,0x45,0x51,0x35,0x89,0xEA,0x66,0xDE,0xEA,0xE0,0xAB,0xD3,0x29,0x4F,0x1F,0xFA,0x52,0xF6,0x90,0x52,0x3B,0x25,0x7F,0xDD,0xCB,0x9D,0x72,0x72,0x8C,0x79,0xCB,0x6F,0xFA,0xD2,0x10,0x9E,0xB4,0x2C,0xE1,0x4F,0x25,0x70,0x3A,0xDC,0xBA,0x2F,0x6F,0xC1,0x75,0xCB,0xF2,0xFF};
//const uint8_t spEIGHT[] PROGMEM = {0x65,0x69,0x89,0xC5,0x73,0x66,0xDF,0xE9,0x8C,0x33,0x0E,0x41,0xC6,0xEA,0x5B,0xEF,0x7A,0xF5,0x33,0x25,0x50,0xE5,0xEA,0x39,0xD7,0xC5,0x6E,0x08,0x14,0xC1,0xDD,0x45,0x64,0x03,0x00,0x80,0x00,0xAE,0x70,0x33,0xC0,0x73,0x33,0x1A,0x10,0x40,0x8F,0x2B,0x14,0xF8,0x7F};
//const uint8_t spTWELVE[] PROGMEM = {0x09,0x98,0xDA,0x22,0x01,0x37,0x78,0x1A,0x20,0x85,0xD1,0x50,0x3A,0x33,0x11,0x81,0x5D,0x5B,0x95,0xD4,0x44,0x04,0x76,0x9D,0xD5,0xA9,0x3A,0xAB,0xF0,0xA1,0x3E,0xB7,0xBA,0xD5,0xA9,0x2B,0xEB,0xCC,0xA0,0x3E,0xB7,0xBD,0xC3,0x5A,0x3B,0xC8,0x69,0x67,0xBD,0xFB,0xE8,0x67,0xBF,0xCA,0x9D,0xE9,0x74,0x08,0xE7,0xCE,0x77,0x78,0x06,0x89,0x32,0x57,0xD6,0xF1,0xF1,0x8F,0x7D,0xFE,0x1F};
//const uint8_t spTWENTY[] PROGMEM = {0x0A,0xE8,0x4A,0xCD,0x01,0xDB,0xB9,0x33,0xC0,0xA6,0x54,0x0C,0xA4,0x34,0xD9,0xF2,0x0A,0x6C,0xBB,0xB3,0x53,0x0E,0x5D,0xA6,0x25,0x9B,0x6F,0x75,0xCA,0x61,0x52,0xDC,0x74,0x49,0xA9,0x8A,0xC4,0x76,0x4D,0xD7,0xB1,0x76,0xC0,0x55,0xA6,0x65,0xD8,0x26,0x99,0x5C,0x56,0xAD,0xB9,0x25,0x23,0xD5,0x7C,0x32,0x96,0xE9,0x9B,0x20,0x7D,0xCB,0x3C,0xFA,0x55,0xAE,0x99,0x1A,0x30,0xFC,0x4B,0x3C,0xFF,0x1F};
//const uint8_t spONE[] PROGMEM = {0x66,0x4E,0xA8,0x7A,0x8D,0xED,0xC4,0xB5,0xCD,0x89,0xD4,0xBC,0xA2,0xDB,0xD1,0x27,0xBE,0x33,0x4C,0xD9,0x4F,0x9B,0x4D,0x57,0x8A,0x76,0xBE,0xF5,0xA9,0xAA,0x2E,0x4F,0xD5,0xCD,0xB7,0xD9,0x43,0x5B,0x87,0x13,0x4C,0x0D,0xA7,0x75,0xAB,0x7B,0x3E,0xE3,0x19,0x6F,0x7F,0xA7,0xA7,0xF9,0xD0,0x30,0x5B,0x1D,0x9E,0x9A,0x34,0x44,0xBC,0xB6,0x7D,0xFE,0x1F};
//const uint8_t spFIVE[] PROGMEM = {0x08,0x68,0x4E,0x9D,0x02,0x1C,0x60,0xC0,0x8C,0x69,0x12,0xB0,0xC0,0x28,0xAB,0x8C,0x9C,0xC0,0x2D,0xBB,0x38,0x79,0x31,0x15,0xA3,0xB6,0xE4,0x16,0xB7,0xDC,0xF5,0x6E,0x57,0xDF,0x54,0x5B,0x85,0xBE,0xD9,0xE3,0x5C,0xC6,0xD6,0x6D,0xB1,0xA5,0xBF,0x99,0x5B,0x3B,0x5A,0x30,0x09,0xAF,0x2F,0xED,0xEC,0x31,0xC4,0x5C,0xBE,0xD6,0x33,0xDD,0xAD,0x88,0x87,0xE2,0xD2,0xF2,0xF4,0xE0,0x16,0x2A,0xB2,0xE3,0x63,0x1F,0xF9,0xF0,0xE7,0xFF,0x01};
//const uint8_t spNINE[] PROGMEM = {0xE6,0xA8,0x1A,0x35,0x5D,0xD6,0x9A,0x35,0x4B,0x8C,0x4E,0x6B,0x1A,0xD6,0xA6,0x51,0xB2,0xB5,0xEE,0x58,0x9A,0x13,0x4F,0xB5,0x35,0x67,0x68,0x26,0x3D,0x4D,0x97,0x9C,0xBE,0xC9,0x75,0x2F,0x6D,0x7B,0xBB,0x5B,0xDF,0xFA,0x36,0xA7,0xEF,0xBA,0x25,0xDA,0x16,0xDF,0x69,0xAC,0x23,0x05,0x45,0xF9,0xAC,0xB9,0x8F,0xA3,0x97,0x20,0x73,0x9F,0x54,0xCE,0x1E,0x45,0xC2,0xA2,0x4E,0x3E,0xD3,0xD5,0x3D,0xB1,0x79,0x24,0x0D,0xD7,0x48,0x4C,0x6E,0xE1,0x2C,0xDE,0xFF,0x0F};
//const uint8_t spTHIR_[] PROGMEM = {0x04,0xA8,0xBE,0x5C,0x00,0xDD,0xA5,0x11,0xA0,0xFA,0x72,0x02,0x74,0x97,0xC6,0x01,0x09,0x9C,0xA6,0xAB,0x30,0x0D,0xCE,0x7A,0xEA,0x6A,0x4A,0x39,0x35,0xFB,0xAA,0x8B,0x1B,0xC6,0x76,0xF7,0xAB,0x2E,0x79,0x19,0xCA,0xD5,0xEF,0xCA,0x57,0x08,0x14,0xA1,0xDC,0x45,0x64,0x03,0x00,0xC0,0xFF,0x03};
//const uint8_t spHUNDRED[] PROGMEM = {0x04,0xC8,0x7E,0x5C,0x02,0x0A,0xA8,0x62,0x43,0x03,0xA7,0xA8,0x62,0x43,0x4B,0x97,0xDC,0xF2,0x14,0xC5,0xA7,0x9B,0x7A,0xD3,0x95,0x37,0xC3,0x1E,0x16,0x4A,0x66,0x36,0xF3,0x5A,0x89,0x6E,0xD4,0x30,0x55,0xB5,0x32,0xB7,0x31,0xB5,0xC1,0x69,0x2C,0xE9,0xF7,0xBC,0x96,0x12,0x39,0xD4,0xB5,0xFD,0xDA,0x9B,0x0F,0xD1,0x90,0xEE,0xF5,0xE4,0x17,0x02,0x45,0x28,0x77,0x11,0xD9,0x40,0x9E,0x45,0xDD,0x2B,0x33,0x71,0x7A,0xBA,0x0B,0x13,0x95,0x2D,0xF9,0xF9,0x7F};
//const uint8_t spTWO[] PROGMEM = {0x06,0xB8,0x59,0x34,0x00,0x27,0xD6,0x38,0x60,0x58,0xD3,0x91,0x55,0x2D,0xAA,0x65,0x9D,0x4F,0xD1,0xB8,0x39,0x17,0x67,0xBF,0xC5,0xAE,0x5A,0x1D,0xB5,0x7A,0x06,0xF6,0xA9,0x7D,0x9D,0xD2,0x6C,0x55,0xA5,0x26,0x75,0xC9,0x9B,0xDF,0xFC,0x6E,0x0E,0x63,0x3A,0x34,0x70,0xAF,0x3E,0xFF,0x1F};
//const uint8_t spSIX[] PROGMEM = {0x04,0xF8,0xAD,0x4C,0x02,0x16,0xB0,0x80,0x06,0x56,0x35,0x5D,0xA8,0x2A,0x6D,0xB9,0xCD,0x69,0xBB,0x2B,0x55,0xB5,0x2D,0xB7,0xDB,0xFD,0x9C,0x0D,0xD8,0x32,0x8A,0x7B,0xBC,0x02,0x00,0x03,0x0C,0xB1,0x2E,0x80,0xDF,0xD2,0x35,0x20,0x01,0x0E,0x60,0xE0,0xFF,0x01};
//const uint8_t spTEN[] PROGMEM = {0x0E,0x38,0x3C,0x2D,0x00,0x5F,0xB6,0x19,0x60,0xA8,0x90,0x93,0x36,0x2B,0xE2,0x99,0xB3,0x4E,0xD9,0x7D,0x89,0x85,0x2F,0xBE,0xD5,0xAD,0x4F,0x3F,0x64,0xAB,0xA4,0x3E,0xBA,0xD3,0x59,0x9A,0x2E,0x75,0xD5,0x39,0x6D,0x6B,0x0A,0x2D,0x3C,0xEC,0xE5,0xDD,0x1F,0xFE,0xB0,0xE7,0xFF,0x03};
//const uint8_t spFIF_[] PROGMEM = {0x08,0x98,0x31,0x93,0x02,0x1C,0xE0,0x80,0x07,0x5A,0xD6,0x1C,0x6B,0x78,0x2E,0xBD,0xE5,0x2D,0x4F,0xDD,0xAD,0xAB,0xAA,0x6D,0xC9,0x23,0x02,0x56,0x4C,0x93,0x00,0x05,0x10,0x90,0x89,0x31,0xFC,0x3F};
//const uint8_t spTHOUSAND[] PROGMEM = {0x0C,0xE8,0x2E,0xD4,0x02,0x06,0x98,0xD2,0x55,0x03,0x16,0x68,0x7D,0x17,0xE9,0x6E,0xBC,0x65,0x8C,0x45,0x6D,0xA6,0xE9,0x96,0xDD,0xDE,0xF6,0xB6,0xB7,0x5E,0x75,0xD4,0x93,0xA5,0x9C,0x7B,0x57,0xB3,0x6E,0x7D,0x12,0x19,0xAD,0xDC,0x29,0x8D,0x4F,0x93,0xB4,0x87,0xD2,0xB6,0xFC,0xDD,0xAC,0x22,0x56,0x02,0x70,0x18,0xCA,0x18,0x26,0xB5,0x90,0xD4,0xDE,0x6B,0x29,0xDA,0x2D,0x25,0x17,0x8D,0x79,0x88,0xD4,0x48,0x79,0x5D,0xF7,0x74,0x75,0xA1,0x94,0xA9,0xD1,0xF2,0xED,0x9E,0xAA,0x51,0xA6,0xD4,0x9E,0x7F,0xED,0x6F,0xFE,0x2B,0xD1,0xC7,0x3D,0x89,0xFA,0xB7,0x0D,0x57,0xD3,0xB4,0xF5,0x37,0x55,0x37,0x2E,0xE6,0xB2,0xD7,0x57,0xFF,0x0F};
//const uint8_t spTHREE[] PROGMEM = {0x0C,0xE8,0x2E,0x94,0x01,0x4D,0xBA,0x4A,0x40,0x03,0x16,0x68,0x69,0x36,0x1C,0xE9,0xBA,0xB8,0xE5,0x39,0x70,0x72,0x84,0xDB,0x51,0xA4,0xA8,0x4E,0xA3,0xC9,0x77,0xB1,0xCA,0xD6,0x52,0xA8,0x71,0xED,0x2A,0x7B,0x4B,0xA6,0xE0,0x37,0xB7,0x5A,0xDD,0x48,0x8E,0x94,0xF1,0x64,0xCE,0x6D,0x19,0x55,0x91,0xBC,0x6E,0xD7,0xAD,0x1E,0xF5,0xAA,0x77,0x7A,0xC6,0x70,0x22,0xCD,0xC7,0xF9,0x89,0xCF,0xFF,0x03};
//const uint8_t spSEVEN[] PROGMEM = {0x0C,0xF8,0x5E,0x4C,0x01,0xBF,0x95,0x7B,0xC0,0x02,0x16,0xB0,0xC0,0xC8,0xBA,0x36,0x4D,0xB7,0x27,0x37,0xBB,0xC5,0x29,0xBA,0x71,0x6D,0xB7,0xB5,0xAB,0xA8,0xCE,0xBD,0xD4,0xDE,0xA6,0xB2,0x5A,0xB1,0x34,0x6A,0x1D,0xA7,0x35,0x37,0xE5,0x5A,0xAE,0x6B,0xEE,0xD2,0xB6,0x26,0x4C,0x37,0xF5,0x4D,0xB9,0x9A,0x34,0x39,0xB7,0xC6,0xE1,0x1E,0x81,0xD8,0xA2,0xEC,0xE6,0xC7,0x7F,0xFE,0xFB,0x7F};
//const uint8_t spELEVEN[] PROGMEM = {0xA5,0xEF,0xD6,0x50,0x3B,0x67,0x8F,0xB9,0x3B,0x23,0x49,0x7F,0x33,0x87,0x31,0x0C,0xE9,0x22,0x49,0x7D,0x56,0xDF,0x69,0xAA,0x39,0x6D,0x59,0xDD,0x82,0x56,0x92,0xDA,0xE5,0x74,0x9D,0xA7,0xA6,0xD3,0x9A,0x53,0x37,0x99,0x56,0xA6,0x6F,0x4F,0x59,0x9D,0x7B,0x89,0x2F,0xDD,0xC5,0x28,0xAA,0x15,0x4B,0xA3,0xD6,0xAE,0x8C,0x8A,0xAD,0x54,0x3B,0xA7,0xA9,0x3B,0xB3,0x54,0x5D,0x33,0xE6,0xA6,0x5C,0xCB,0x75,0xCD,0x5E,0xC6,0xDA,0xA4,0xCA,0xB9,0x35,0xAE,0x67,0xB8,0x46,0x40,0xB6,0x28,0xBB,0xF1,0xF6,0xB7,0xB9,0x47,0x20,0xB6,0x28,0xBB,0xFF,0x0F};
//const uint8_t sp_TEEN[] PROGMEM = {0x09,0x58,0x2A,0x25,0x00,0xCB,0x9F,0x95,0x6C,0x14,0x21,0x89,0xA9,0x78,0xB3,0x5B,0xEC,0xBA,0xB5,0x23,0x13,0x46,0x97,0x99,0x3E,0xD6,0xB9,0x2E,0x79,0xC9,0x5B,0xD8,0x47,0x41,0x53,0x1F,0xC7,0xE1,0x9C,0x85,0x54,0x22,0xEC,0xFA,0xDB,0xDD,0x23,0x93,0x49,0xB8,0xE6,0x78,0xFF,0x3F};
//const uint8_t spA[] PROGMEM = {0x65,0x2C,0x96,0xAD,0x7B,0x6A,0x9F,0x66,0xE4,0x20,0x8D,0x9C,0x73,0xAB,0x5B,0xDC,0xE2,0x96,0xB7,0xBA,0xF5,0x6A,0x66,0x28,0xA0,0xCE,0xD5,0xBB,0xDB,0xFD,0x1E,0xE6,0x38,0xA7,0x36,0xCF,0x9C,0x80,0x51,0x8B,0xEB,0x52,0xD7,0xBC,0xFF,0x3F};
//const uint8_t spB[] PROGMEM = {0xA6,0x2F,0xAA,0x05,0x5C,0xD6,0x8C,0xBC,0xC7,0x16,0x70,0x59,0x33,0xB2,0x95,0x0B,0xC1,0xFD,0xCD,0xCC,0x66,0x3A,0xF3,0x51,0xAD,0x98,0x00,0x55,0x8B,0x67,0xDB,0xC7,0x3E,0xD5,0xAD,0xEE,0x75,0x2F,0xE7,0x2C,0x4D,0x60,0xBE,0x26,0xDF,0xF1,0x89,0xEF,0xFF,0x03};
//const uint8_t spC[] PROGMEM = {0x04,0xF8,0xA5,0x83,0x03,0x12,0xB0,0x80,0x07,0x22,0xB0,0xC2,0xEE,0x8D,0x45,0x7D,0xC9,0xCA,0x67,0x29,0x42,0xF5,0x35,0x3B,0xDF,0xF9,0x28,0x66,0x0D,0x40,0xCF,0xD7,0xB3,0x1C,0xCD,0xAC,0x06,0x14,0xB5,0x68,0x0E,0x7D,0xEE,0x4B,0xDF,0xD2,0x39,0x5B,0x02,0x44,0xBD,0xCE,0x57,0xBE,0xF2,0x9D,0xEE,0x55,0x0A,0xC1,0x73,0x4D,0x7E,0xF2,0xF3,0xFF};
//const uint8_t spD[] PROGMEM = {0x06,0x98,0x30,0x68,0xE4,0x6B,0x84,0xA0,0xE8,0xD3,0x93,0x8D,0xEC,0x84,0x9E,0x4B,0x6E,0x36,0x8A,0x19,0x0D,0xA8,0xEA,0x71,0xAF,0x7A,0xDF,0xE7,0xB2,0xAD,0xE0,0x00,0xD3,0x8B,0xEB,0x9E,0x8F,0x7C,0xA6,0x73,0xE5,0x40,0xA8,0x5A,0x1C,0xAF,0x78,0xC5,0xDB,0xDF,0xFF,0x0F};
//const uint8_t spE[] PROGMEM = {0xA2,0x59,0x95,0x51,0xBA,0x17,0xF7,0x6A,0x95,0xAB,0x38,0x42,0xE4,0x92,0x5D,0xEE,0x62,0x15,0x33,0x3B,0x50,0xD6,0x92,0x5D,0xAE,0x6A,0xC5,0x04,0xA8,0x5A,0xBC,0xEB,0xDD,0xEC,0x76,0x77,0xBB,0xDF,0xD3,0x9E,0xF6,0x32,0x97,0xBE,0xF5,0xAD,0xED,0xB3,0x34,0x81,0xF9,0x9A,0xFF,0x07};
//const uint8_t spF[] PROGMEM = {0xAB,0x1B,0x61,0x94,0xDD,0xD6,0xDC,0xF1,0x74,0xDD,0x37,0xB9,0xE7,0xEA,0xD3,0x35,0xB3,0x1C,0xE1,0xAF,0x6F,0x77,0xC7,0xB5,0xD4,0xE0,0x56,0x9C,0x77,0xDB,0x5A,0x9D,0xEB,0x98,0x8C,0x61,0xC0,0x30,0xE9,0x1A,0xB0,0x80,0x05,0x14,0x30,0x6D,0xBB,0x06,0x24,0x20,0x01,0x0E,0x10,0xA0,0x06,0xB5,0xFF,0x07};
//const uint8_t spG[] PROGMEM = {0x6E,0x3F,0x29,0x8D,0x98,0x95,0xCD,0x3D,0x00,0xAB,0x38,0x95,0xE2,0xD4,0xEB,0x34,0x81,0x7A,0xF2,0x51,0x53,0x50,0x75,0xEB,0xCE,0x76,0xB6,0xD3,0x95,0x8D,0x92,0x48,0x99,0xAB,0x77,0xBE,0xCB,0xDD,0x8E,0x71,0x96,0x04,0x8C,0x5A,0x3C,0xE7,0x39,0xF7,0xAD,0x6E,0xF5,0x2A,0xD7,0x2A,0x85,0xE0,0xB9,0x26,0x3E,0xF1,0xF9,0x7F};
//const uint8_t spH[] PROGMEM = {0x65,0x18,0x6D,0x90,0x2D,0xD6,0xEC,0xF6,0x56,0xB7,0xBC,0xC5,0xAE,0xC7,0x30,0xA3,0x01,0x6D,0x2D,0xCE,0x8B,0x3D,0xDC,0xD6,0x3C,0x61,0x76,0xC5,0x25,0x9B,0x08,0xE5,0x2E,0x22,0x1B,0x00,0x80,0x01,0x2B,0x87,0x38,0x60,0xE5,0xED,0x08,0x58,0xC0,0x02,0x16,0xB0,0x80,0x06,0x34,0x40,0x80,0x76,0xD3,0xFE,0x1F};
//const uint8_t spI[] PROGMEM = {0xAA,0x8D,0x63,0xA8,0xAA,0x66,0xAD,0xB9,0xA8,0xCB,0x08,0xDD,0x7C,0xFB,0x5B,0xDF,0xFA,0x36,0xB7,0x39,0x6D,0xB5,0xA3,0x15,0xBA,0xF8,0x76,0xBB,0xDF,0xD3,0x9E,0xD7,0xDA,0x5C,0x49,0xA5,0x2D,0xDE,0x7B,0xDB,0x6B,0x76,0x29,0xAF,0xC7,0x6D,0xEF,0x31,0xD8,0x5C,0x1E,0xF7,0xBD,0x1E,0xF5,0x48,0xE7,0x28,0x89,0xE2,0xF2,0x38,0x5F,0xF9,0xFE,0x7F};
//const uint8_t spL[] PROGMEM = {0x6B,0x68,0x2E,0xD8,0x2A,0x37,0xDF,0xFE,0xF6,0xA7,0xAF,0x21,0xBC,0xC4,0x17,0xDF,0xFE,0xF6,0x67,0xC8,0x6A,0xC3,0x4D,0x3A,0xDF,0x61,0x4D,0x95,0x6C,0xA6,0x71,0x9E,0xB1,0x36,0x98,0x53,0x49,0x5E,0xFB,0x5A,0x8E,0x0A,0x7A,0x43,0xD9,0x4F,0x3C,0xC2,0x59,0xE0,0xF4,0x08,0xF9,0x09,0x67,0x03,0x31,0x19,0xA2,0x25,0x9E,0xFF,0x0F};
//const uint8_t spJ[] PROGMEM = {0x6E,0x5A,0xC1,0x99,0x54,0xB2,0x09,0x60,0x49,0x22,0x07,0xEC,0xA8,0x16,0x80,0x5D,0x26,0xC7,0xD0,0xA3,0x92,0x78,0x74,0x3E,0x55,0x2F,0x21,0x6A,0xB1,0xFA,0x56,0xB7,0xBA,0xD5,0xAD,0x6F,0x7D,0xBB,0x3D,0x8E,0x75,0xB4,0x22,0x36,0x7F,0x53,0xCF,0x7E,0xB5,0x67,0x96,0x61,0x34,0xDB,0x52,0x9F,0xF4,0x8E,0xDC,0x88,0xE1,0x5F,0xF2,0x9D,0xEF,0xFF,0x07};
//const uint8_t spK[] PROGMEM = {0x01,0x18,0x91,0xB9,0x00,0x4D,0x91,0x46,0x60,0x65,0x2D,0xB3,0xB8,0x67,0xED,0x53,0xF4,0x14,0x64,0x11,0x4B,0x6E,0x79,0x8B,0x5B,0xDE,0xF2,0x74,0xC3,0x05,0x6A,0xE7,0xEA,0x3D,0xEC,0x71,0x2F,0x6D,0x1F,0xB1,0x00,0x2B,0xDF,0xF4,0xA3,0x1D,0xB3,0x24,0x60,0xD4,0xE2,0x7A,0xE5,0x2B,0xDF,0xE9,0x1E,0x43,0x48,0xA3,0xEB,0xE4,0xFB,0xFF,0x01};
//const uint8_t spM[] PROGMEM = {0xA9,0xE8,0xC5,0xD8,0x73,0x16,0xCF,0xE2,0x0E,0xB7,0xBB,0xCD,0xA9,0xBB,0x6F,0xF1,0xF0,0xD5,0xB7,0xBE,0xCD,0xEE,0xC6,0x50,0x63,0x72,0x98,0x58,0xEE,0x73,0x5F,0xDB,0xD6,0x62,0x72,0x98,0x58,0xAE,0x7B,0xDD,0xD3,0x5E,0x45,0x72,0x93,0xD8,0x8D,0x87,0x3D,0xEC,0x61,0xCF,0x70,0x96,0x58,0xE1,0xA2,0x4D,0xE2,0x15,0xEF,0xFF,0x07};
//const uint8_t spN[] PROGMEM = {0x41,0xEE,0xD1,0xC8,0xB3,0x16,0xEF,0xEE,0xD4,0xC3,0x35,0x59,0xC4,0xE3,0x5B,0xDD,0xEA,0x56,0xBB,0x59,0xED,0x92,0xCD,0x91,0xB4,0x78,0x4F,0x63,0x19,0x9E,0x38,0x2C,0x9C,0xCE,0xA5,0xAF,0xF5,0x08,0xC7,0xB0,0xC2,0x61,0x1E,0x35,0x1E,0xF1,0x8C,0x57,0xBC,0xD3,0xDD,0x4D,0x49,0xB8,0xCE,0x0E,0xF7,0x34,0xAD,0x16,0xBC,0xF9,0xFF,0x01};
//const uint8_t spO[] PROGMEM = {0xA3,0x6D,0xB4,0xBA,0x8D,0xBC,0xAD,0xA6,0x92,0xEC,0x0E,0xF2,0xB6,0xAB,0x5D,0x8C,0xA2,0xE0,0xEE,0x16,0xF6,0x3F,0xCB,0x39,0xCC,0xB1,0xAC,0x91,0xE5,0x0C,0x8B,0xBF,0xB0,0x3B,0xD3,0x1D,0x28,0x59,0xE2,0xE9,0x4F,0x7B,0xF9,0xE7,0xFF,0x01};
//const uint8_t spP[] PROGMEM = {0x02,0x88,0x26,0xD4,0x00,0x6D,0x96,0xB5,0xB8,0x25,0x05,0x89,0x6C,0x3D,0xD2,0xE6,0x51,0xB3,0xA6,0xF4,0x48,0x67,0x09,0xA0,0x8C,0xC7,0x33,0x9B,0x79,0xCB,0x67,0x0E,0x80,0xCA,0xD7,0xBD,0x6A,0xD5,0x72,0x06,0xB4,0xB5,0xBA,0xB7,0xBD,0xAF,0x73,0x5D,0xF3,0x91,0x8F,0x78,0xFE,0x3F};
//const uint8_t spQ[] PROGMEM = {0x0E,0x98,0xD5,0x28,0x02,0x11,0x18,0xE9,0xCC,0x46,0x98,0xF1,0x66,0xA7,0x27,0x1D,0x21,0x99,0x92,0xB6,0xDC,0x7C,0x17,0xAB,0x2C,0xD2,0x2D,0x13,0x3B,0xEF,0xAA,0x75,0xCE,0x94,0x47,0xD0,0xEE,0x3A,0xC4,0x29,0x2F,0x61,0x35,0x31,0xA2,0x50,0xB6,0xF8,0xCD,0x1F,0xFF,0x0F};
//const uint8_t spR[] PROGMEM = {0xAB,0xC8,0x72,0x33,0x93,0xBB,0xDC,0xEE,0xB6,0xB7,0xB9,0xF5,0x68,0x53,0x5C,0xA9,0xA6,0x4D,0xB3,0x6B,0x73,0x0A,0xCB,0x71,0xD8,0xBB,0xAF,0x7D,0x2F,0x47,0xB6,0xC7,0xF4,0x94,0x37,0x9D,0xA9,0x34,0xF8,0x53,0x97,0x78,0xFD,0x3F};
//const uint8_t spS[] PROGMEM = {0x6B,0x6E,0xD9,0x34,0x6C,0xE6,0xDC,0xF6,0x36,0xB7,0xBE,0xF5,0x19,0xAA,0x0F,0x2D,0xDA,0x25,0x7B,0x19,0x5B,0x4D,0x9A,0xA2,0xE7,0xB8,0x1D,0x23,0xA5,0x26,0x71,0x2A,0x03,0xFC,0x94,0xE6,0x01,0x0F,0x68,0x40,0x03,0x12,0xE0,0x00,0x07,0x30,0xF0,0xFF};
//const uint8_t spT[] PROGMEM = {0x01,0xD8,0xB6,0xDD,0x01,0x2F,0xF4,0x38,0x60,0xD5,0xD1,0x91,0x4D,0x97,0x84,0xE6,0x4B,0x4E,0x36,0xB2,0x10,0x67,0xCD,0x19,0xD9,0x2C,0x01,0x94,0xF1,0x78,0x66,0x33,0xEB,0x79,0xAF,0x7B,0x57,0x87,0x36,0xAF,0x52,0x08,0x9E,0x6B,0xEA,0x5A,0xB7,0x7A,0x94,0x73,0x45,0x47,0xAC,0x5A,0x9C,0xAF,0xFF,0x07};
//const uint8_t spU[] PROGMEM = {0xA1,0x9F,0x9C,0x94,0x72,0x26,0x8D,0x76,0x07,0x55,0x90,0x78,0x3C,0xEB,0x59,0x9D,0xA2,0x87,0x60,0x76,0xDA,0x72,0x8B,0x53,0x36,0xA5,0x64,0x2D,0x7B,0x6E,0xB5,0xFA,0x24,0xDC,0x32,0xB1,0x73,0x1F,0xFA,0x1C,0x16,0xAB,0xC6,0xCA,0xE0,0xB5,0xDF,0xCD,0xA1,0xD4,0x78,0x1B,0xB6,0x53,0x97,0x74,0xA7,0x21,0xBC,0xE4,0xFF,0x01};
//const uint8_t spV[] PROGMEM = {0x66,0xF3,0xD2,0x38,0x43,0xB3,0xD8,0x2D,0xAC,0x4D,0xBB,0x70,0xB0,0xDB,0xB0,0x0E,0x17,0x2C,0x26,0xAE,0xD3,0x32,0x6C,0xBB,0x32,0xAB,0x19,0x63,0xF7,0x21,0x6C,0x9C,0xE5,0xD4,0x33,0xB6,0x80,0xCB,0x9A,0x9B,0xAF,0x6C,0xE5,0x42,0x70,0x7F,0xB3,0xB3,0x9D,0xEE,0x7C,0x55,0x2B,0x26,0x40,0xD5,0xE2,0xD9,0xF6,0xB1,0x4F,0x75,0xAB,0x7B,0x3D,0xCA,0x35,0x4B,0x13,0x98,0xAF,0xA9,0x57,0x7E,0xF3,0x97,0xBE,0x19,0x0B,0x31,0xF3,0xCD,0xFF,0x03};
//const uint8_t spW[] PROGMEM = {0xA1,0xDE,0xC2,0x44,0xC2,0xFC,0x9C,0x6A,0x88,0x70,0x09,0x59,0x7B,0x8A,0xCA,0x3B,0x3D,0xA4,0xCF,0xCD,0x56,0x96,0xC4,0xA6,0xBB,0xF4,0x6E,0x59,0xE2,0x9D,0xEA,0xE2,0x4A,0xD5,0x12,0x65,0xBB,0xB3,0xEB,0x51,0x57,0x12,0x99,0xC1,0xD9,0x6E,0xB7,0xC7,0x31,0x35,0x92,0x6A,0xC9,0x9B,0xC7,0x34,0x4C,0x12,0x46,0x6C,0x99,0x73,0x5F,0xDA,0xD2,0x92,0x92,0x64,0x6C,0xEE,0x6B,0xD9,0x6A,0x22,0x71,0x8F,0xCF,0xE5,0x2C,0x41,0xD4,0xDD,0x36,0xA5,0x3B,0x19,0xF5,0x0C,0xEE,0x13,0xEF,0xFC,0x9A,0xD7,0x85,0xC8,0x62,0xEE,0x6D,0xBF,0xFF,0x07};
//const uint8_t spX[] PROGMEM = {0xAD,0x68,0xC9,0xC5,0x32,0x56,0xDF,0xFA,0x54,0x2D,0x35,0x7B,0xF8,0xEA,0x5B,0xDD,0xE6,0x4C,0x6D,0x04,0xA6,0xC5,0xEA,0xB9,0x84,0xB5,0x75,0x23,0x37,0x4F,0x83,0x40,0x11,0xCA,0x5D,0x44,0x36,0x00,0x28,0xA0,0xE6,0x31,0x0F,0x68,0xC0,0x00,0xBF,0x8D,0x79,0xC0,0x03,0x16,0xD0,0x00,0x07,0xFE,0x1F};
//const uint8_t spY[] PROGMEM = {0x6A,0xB1,0xA2,0xA7,0x95,0xD2,0xD8,0x25,0x0F,0xA3,0x2D,0xB2,0x7A,0x1C,0xB3,0xDE,0xE6,0xD4,0x45,0x6D,0x56,0xCA,0x9A,0x5B,0xDF,0xFA,0xB6,0xBB,0xDB,0xFD,0x1A,0x8A,0x6F,0x2B,0xF3,0x37,0x7B,0x19,0x4B,0xD3,0x25,0x39,0xFA,0xB9,0x6F,0x6D,0xEB,0x31,0xC4,0x5C,0x1E,0xF7,0xAD,0x1F,0xE5,0x1C,0xA5,0x48,0x5C,0x1E,0xD7,0x2B,0x5F,0xF9,0xFA,0x7F};
//const uint8_t spZ[] PROGMEM = {0x6D,0xFD,0xC6,0x5C,0x95,0xD5,0xF5,0xD5,0x02,0x7B,0x5D,0xFD,0x51,0x2D,0x2A,0xE4,0x77,0x75,0xA3,0x3A,0xB1,0xFA,0x9B,0x5D,0xEF,0x6A,0x55,0x33,0x27,0x60,0xD4,0xE2,0xD9,0xCC,0x76,0x4E,0x73,0x9D,0x7B,0x3F,0xFB,0x59,0xAE,0x55,0x0A,0xC1,0x73,0x4D,0xBD,0xEA,0x9D,0x9E,0x15,0x12,0xA0,0x6B,0x75,0x7E,0xFE,0x1F};
//const uint8_t spALPHA[] PROGMEM = {0xAD,0xED,0x6A,0xDC,0x4B,0x57,0xEF,0xF6,0xB4,0x53,0x6C,0x6A,0x4B,0x97,0x53,0x77,0x7E,0x19,0xC9,0x9B,0x57,0x99,0xCC,0x7B,0x9A,0x6E,0x9E,0x45,0x2B,0xA2,0xA9,0x0A,0x91,0xCC,0xB5,0x00,0x02,0x14,0x67,0xA1,0x80,0x16,0x2C,0x3C,0x60,0x80,0xE6,0x2C,0x4A,0x51,0x54,0x47,0x38,0x6F,0xDE,0xC3,0x5D,0xF6,0x36,0xF7,0x7A,0xE5,0xFB,0xFF,0x01};
//const uint8_t spBRAVO[] PROGMEM = {0x61,0x5A,0xBA,0xC2,0xDD,0x62,0x85,0xD6,0xE8,0x15,0x59,0xB1,0x97,0x9A,0x30,0xD5,0xBC,0x85,0xDF,0xA8,0x63,0x0F,0xE9,0x50,0xE5,0xA7,0xCA,0x6E,0x22,0x5D,0x57,0xEF,0x72,0x97,0xB3,0x2A,0x6D,0x74,0x15,0xE9,0xBA,0x3A,0xF6,0x66,0xE8,0x3E,0xD4,0x5C,0x65,0xD7,0x31,0x2D,0x95,0x54,0xBB,0x8B,0xDF,0xD9,0xAE,0xB1,0xA1,0xAC,0x0E,0x51,0x3F,0xE7,0xB6,0x14,0xD2,0x35,0x4E,0xEE,0xFB,0x5E,0x77,0xB3,0x7B,0xDF,0x19,0x2C,0x7D,0xEC,0xE9,0x2F,0x73,0x05,0xDF,0x19,0x2C,0x7D,0xF8,0xF3,0xFF};
//const uint8_t spCHARLIE[] PROGMEM = {0x06,0xD8,0x2D,0x2C,0x01,0x33,0xB7,0x67,0x60,0xC4,0x35,0x94,0xAA,0x5A,0xEA,0x93,0x15,0xD7,0xAA,0x23,0xEE,0x56,0x9E,0xD3,0xAA,0x2E,0xE5,0xDB,0xF9,0xC8,0x4B,0x6A,0x8E,0xE3,0x3E,0x33,0x2F,0x45,0x6E,0x62,0x39,0x9A,0x76,0x74,0x4D,0xA5,0xA5,0x73,0xD2,0x3B,0xAC,0xA9,0xD9,0x61,0x0D,0xDF,0x32,0xE6,0xEE,0x0A,0x39,0xE3,0xF3,0x58,0x97,0x2D,0xC2,0x8C,0x2D,0x7D,0x4D,0xE7,0xCC,0x09,0x18,0xB5,0x38,0x5E,0xFE,0xFE,0x7F};
//const uint8_t spDELTA[] PROGMEM = {0x02,0xE8,0x54,0x6D,0xB5,0x35,0x84,0xB9,0xDA,0x9A,0x5B,0x9F,0xAA,0x98,0x71,0x77,0xDB,0x7C,0x8A,0x64,0x2F,0x5C,0xBD,0xF7,0xCA,0x33,0x9F,0x4A,0x95,0x2C,0x2D,0xCB,0xD2,0xAA,0x95,0xDD,0x9A,0x7C,0x7B,0x15,0xD2,0x48,0x8C,0x40,0x11,0xCA,0x5D,0x44,0x36,0x28,0xE0,0x47,0x73,0x01,0x24,0xEA,0xB2,0xBA,0x6A,0xC2,0xC3,0x7C,0xCB,0x1D,0xCF,0xD6,0x54,0xA5,0x87,0x74,0xDD,0xE7,0xBA,0xAB,0x1A,0xF3,0x94,0xCE,0xFD,0xC9,0xEF,0xFF,0x03};
//const uint8_t spECHO[] PROGMEM = {0x2B,0x6F,0xB1,0xD9,0xD3,0x36,0xDF,0xF6,0x36,0xB7,0x26,0x85,0x08,0xE5,0x2E,0x22,0x1B,0x20,0x00,0x25,0xAC,0x2A,0x20,0xCF,0xD3,0x52,0x45,0x53,0x6A,0xA9,0x9E,0x4F,0x9B,0x54,0x47,0xB9,0xE4,0xDF,0xC3,0x1C,0xC6,0x98,0x45,0x65,0xBB,0x78,0x9F,0xCB,0x5C,0xD2,0xEA,0x43,0x67,0xB0,0xE5,0xCD,0x7B,0x38,0x9D,0xAD,0x2C,0x15,0x37,0xF1,0xFC,0x7F};
//const uint8_t spFOXTROT[] PROGMEM = {0x08,0x98,0xB1,0x53,0x02,0x1E,0x88,0xC0,0xCA,0x8B,0xDA,0x4A,0x97,0x2E,0xB7,0xBA,0xD5,0x2A,0x73,0xE8,0x48,0xD3,0xCD,0xAD,0xA8,0x35,0xA2,0xC5,0xAA,0x90,0x42,0x84,0x72,0x17,0x91,0x0D,0x0A,0xA8,0xA1,0xC5,0x01,0xAF,0xF8,0x78,0x40,0x01,0x6F,0xB5,0x23,0xA0,0x47,0x53,0x0C,0x44,0xC0,0x03,0xAD,0x49,0x85,0x53,0x53,0xDD,0x8D,0x26,0x56,0xCB,0x70,0xCD,0xB7,0xA6,0x64,0xC7,0x2B,0x39,0xEF,0x5A,0xAA,0xB8,0xF4,0xE2,0x3E,0xF3,0x1C,0x57,0x0E,0x1D,0x69,0xBA,0xD9,0x5F,0x08,0x14,0xA1,0xDC,0x45,0x64,0x03,0x80,0x00,0x8E,0xE0,0x30,0xC0,0xB2,0x53,0x04,0xA8,0xCA,0xE5,0xFF,0x01};
//const uint8_t spGOLF[] PROGMEM = {0x0A,0x88,0xA1,0x71,0x15,0x85,0x76,0x45,0x8A,0xFF,0x9B,0xDF,0x6C,0x65,0x99,0x5C,0xB7,0x72,0xDE,0x9D,0xED,0x72,0x77,0x73,0x6C,0x4B,0x54,0x35,0x63,0xE4,0xA6,0xEE,0xF9,0x34,0x57,0x94,0x39,0x63,0xE4,0x86,0x5F,0x04,0x98,0x34,0xDD,0x02,0x0E,0x98,0x32,0x5D,0x03,0x12,0xE0,0xC0,0xFF,0x03};
//const uint8_t spHENRY[] PROGMEM = {0x08,0xC8,0x4A,0x8C,0x03,0x1A,0x68,0x49,0x0B,0xAC,0xE5,0x11,0xFA,0x14,0xCD,0x35,0x59,0xC4,0xE3,0x5B,0xEC,0xBC,0xA5,0xD5,0x88,0x96,0x99,0xBD,0x9E,0x95,0x3C,0x1B,0xB3,0x64,0x69,0x1A,0xEB,0xD2,0xA7,0xA9,0x1C,0xE6,0xD1,0xDB,0x98,0x07,0xA7,0x5A,0xAA,0x5F,0x53,0x4D,0xAA,0x61,0x9E,0x7D,0xAC,0xDD,0x8E,0x48,0xC8,0x9E,0xB1,0x77,0x5B,0x44,0x95,0xAB,0xEB,0x15,0xAE,0x1E,0x0D,0x2D,0xF3,0x4D,0x7C,0xFC,0xF3,0xFF};
//const uint8_t spINDIA[] PROGMEM = {0xA3,0x9D,0xD6,0x99,0x32,0x17,0xAF,0x66,0x86,0x16,0x74,0x5F,0x73,0x9A,0xE1,0x4A,0xC4,0xF4,0xCE,0xAD,0x46,0xD1,0x1D,0x5A,0x46,0x3A,0x99,0x45,0x2B,0xAA,0x82,0xAC,0x08,0x27,0xBE,0x5A,0xDD,0x0C,0x25,0x42,0xBC,0xFB,0xF4,0xD3,0x17,0x61,0xF8,0x96,0x3B,0xDC,0xF1,0x4C,0xDD,0x26,0x4B,0xD9,0x9E,0xBB,0xAC,0xB5,0xBB,0x36,0x0D,0xDA,0x7B,0xF6,0xA6,0xD3,0x3A,0xA5,0xF7,0x7E,0xE7,0x3B,0xBF,0xF2,0x55,0x17,0xD6,0xCE,0xAB,0xFD,0xFF,0xFF};
//const uint8_t spJULIET[] PROGMEM = {0x61,0x5D,0x96,0x49,0x34,0xD2,0x06,0x60,0xC7,0x90,0x0C,0x8C,0x66,0xF6,0x15,0x22,0x4D,0x37,0xAA,0x6A,0xC8,0x2C,0x6D,0xCD,0x28,0xB2,0x15,0x8B,0xE4,0x35,0xB3,0x68,0x79,0x51,0xE6,0xDA,0x9C,0xBE,0x15,0x43,0x89,0xF0,0xA2,0xDB,0x95,0x77,0xA7,0xA6,0x66,0x49,0x77,0xB1,0x9A,0x9E,0x0A,0xD5,0x75,0xEB,0xEE,0xF6,0xB0,0xC6,0xE6,0x83,0xD2,0xE3,0xEB,0x5E,0xD7,0xDA,0x5C,0x48,0x87,0x6D,0x9E,0x7B,0xDF,0xF3,0x89,0x40,0x11,0xCA,0x5D,0x44,0x36,0x00,0x38,0x60,0xEA,0x8C,0x00,0x2C,0xB3,0x6D,0x01,0x01,0x14,0x5F,0x8E,0x81,0xFF,0x07};
//const uint8_t spLIMA[] PROGMEM = {0x61,0x5A,0x90,0xBA,0xC0,0xD7,0xA6,0x69,0x00,0x19,0x85,0x6A,0xDA,0x9A,0xCD,0x24,0xD9,0xCC,0xCB,0x29,0x46,0x76,0x66,0xF5,0x37,0x3B,0x9B,0xC9,0x48,0x7B,0x50,0xD4,0x8E,0xD9,0xBD,0xA8,0x75,0x6B,0xB3,0x62,0xEE,0xF4,0xB8,0xB5,0xAD,0xFD,0x98,0x8A,0x51,0x0E,0x91,0xB4,0xA3,0x6F,0xBC,0x32,0x8B,0x3A,0xDF,0xE1,0xEE,0xE3,0xCC,0x6A,0x23,0x43,0x57,0xF5,0xA7,0xBE,0xF5,0xFD,0x7F};
//const uint8_t spMIKE[] PROGMEM = {0x66,0x31,0x3C,0x7C,0x52,0xE3,0xC4,0x69,0xF5,0x85,0x57,0x86,0x51,0xAA,0xD3,0x56,0x75,0xA1,0x69,0x9D,0x6F,0x7D,0xCA,0x6A,0x57,0x23,0x6D,0xF5,0xCD,0x57,0xD1,0x4B,0x50,0x78,0x2C,0xDA,0x75,0x69,0x46,0x77,0xB4,0xCE,0xDB,0xB1,0x45,0xAD,0x08,0xE5,0x2E,0x22,0x1B,0x00,0x18,0xD0,0x3C,0x91,0x03,0x5A,0x09,0xB1,0x80,0x00,0xB2,0x13,0xFE,0x7F};
//const uint8_t spNOVEMBER[] PROGMEM = {0x6A,0x2B,0x02,0x62,0x4B,0xE3,0xDA,0x75,0x2C,0x5D,0x87,0xB8,0x73,0x9B,0xD5,0x66,0x1D,0x16,0x66,0x7D,0x57,0x9B,0x45,0x59,0x07,0xB7,0x6B,0x55,0xB0,0x99,0xCD,0x9C,0xAD,0x56,0xA1,0x88,0xCE,0x3A,0x99,0x33,0xFB,0xC5,0xCC,0xD5,0xA8,0xA5,0xA9,0x1B,0xDF,0x8E,0xBA,0x05,0xB3,0x34,0xED,0x7C,0xCB,0x9B,0x8F,0xAC,0x38,0xCB,0x0C,0x6D,0x5C,0xB2,0xA2,0x94,0xDA,0xCD,0x4D,0x2C,0x55,0x2B,0x75,0x4A,0xA7,0xBB,0xD5,0x3D,0xA4,0x2D,0x77,0xE5,0x2A,0xEE,0x9C,0xD7,0xB4,0x65,0x77,0xA0,0x9B,0xFA,0xE2,0x9E,0xAE,0x5C,0x0B,0xAA,0xD4,0xB7,0xBF,0xFD,0x6D,0x9E,0xE2,0x1A,0x7C,0x43,0xAF,0x7A,0xCB,0x30,0xCA,0xE6,0x2D,0xFF,0x0F};
//const uint8_t spOSCAR[] PROGMEM = {0x6B,0xC8,0xE2,0xB2,0x42,0x3A,0xDF,0xFA,0x16,0x27,0x4F,0xAE,0x7D,0xC4,0x17,0xB7,0x2C,0x45,0xAF,0xA4,0xB6,0x6D,0x80,0x03,0xD8,0x0C,0xF0,0xA7,0x9B,0x07,0x3C,0xE0,0x80,0xEB,0xB5,0xC1,0x6C,0x4D,0x5D,0x45,0x69,0xDC,0xD4,0x17,0x37,0x49,0x26,0x4A,0x5B,0x9B,0x53,0x91,0x0D,0xE7,0x9D,0xFD,0x1C,0xDB,0x92,0x9B,0x61,0xB5,0xF4,0x9E,0x5B,0xDD,0xEB,0x99,0xEE,0x12,0x07,0x75,0x52,0x6F,0xFE,0xC2,0x5F,0x5A,0x91,0x0E,0x67,0xF9,0x7F};
//const uint8_t spPAPA[] PROGMEM = {0x0A,0x70,0x4A,0xB5,0xA5,0x45,0x55,0x84,0x49,0xCC,0x93,0x66,0xD7,0x19,0x26,0x4B,0x4E,0x96,0xDD,0x44,0xBA,0xAE,0xBE,0xD9,0xCC,0x10,0x28,0x42,0xB9,0x8B,0xC8,0x06,0x60,0x80,0xF1,0xE9,0xAB,0xCA,0xA6,0x23,0xD4,0x36,0xDF,0xE1,0x8C,0x55,0x74,0x86,0x6B,0x9F,0xB1,0x67,0xBD,0xE1,0xE6,0xBB,0xDB,0x97,0x53,0x45,0x88,0xCF,0xAE,0xDF,0xFF,0x03};
//const uint8_t spQUEBEC[] PROGMEM = {0x0C,0x88,0x7E,0x8C,0x02,0xA5,0x0A,0x31,0xDD,0x5C,0xB2,0xAC,0x26,0x5B,0xCF,0x4C,0xEE,0xBB,0xBB,0xDE,0xA7,0xCD,0xA8,0xB4,0x75,0x4D,0x1C,0xB7,0xD1,0xD5,0x28,0xEE,0xE6,0x5B,0x76,0x7B,0x9A,0x1A,0xC4,0x33,0xF3,0xF1,0x6D,0x76,0x3F,0xE7,0xB6,0xB6,0xEC,0x12,0x91,0x9B,0xF2,0x8E,0x40,0x11,0xCA,0x5D,0x44,0x36,0x80,0x00,0x7A,0x2F,0x53,0x40,0x2D,0x24,0x14,0xF8,0x7F};
//const uint8_t spROMEO[] PROGMEM = {0xA2,0xD5,0x39,0x38,0xCA,0xEC,0xDB,0xA5,0x4C,0xA1,0x98,0x5A,0xB9,0xF2,0xD3,0x47,0x6F,0xE9,0x69,0xCA,0x4E,0xDD,0x89,0x57,0x0E,0x69,0x3F,0x45,0x61,0xD9,0x95,0x98,0x65,0x67,0x25,0x6B,0x86,0x64,0x4C,0xAC,0xF5,0xE2,0x54,0xCD,0x86,0x7A,0xD0,0xE6,0x35,0x4C,0xD7,0x02,0xA5,0x7B,0xF6,0xB0,0xA7,0xBD,0xAC,0xB5,0xAA,0x54,0x1D,0xDB,0xB2,0xF6,0xEC,0xC3,0xD3,0x64,0x73,0xD9,0x63,0xC8,0x2C,0xD5,0xDF,0xE9,0x0C,0xA1,0x33,0xD8,0xF2,0xE6,0x33,0x5E,0xEE,0x09,0xB6,0xB2,0x54,0xDC,0xF8,0xE7,0xFF,0x01};
//const uint8_t spSIERRA[] PROGMEM = {0x0C,0xF8,0xAD,0xDC,0x02,0x1E,0xB0,0x80,0x06,0x4A,0xDE,0x7D,0x90,0xB8,0xBD,0x1E,0xD5,0xC8,0x45,0xE8,0xF6,0x76,0x56,0xB3,0xDE,0xF5,0xAD,0x4F,0x35,0x72,0xB1,0xB8,0xAE,0x39,0x65,0x0F,0x45,0x56,0xFA,0xE5,0xE4,0x25,0x24,0xE5,0xC8,0xE6,0x91,0xC6,0xC9,0x99,0x6E,0x69,0x7B,0xDA,0xF3,0xD5,0xA4,0xA4,0x95,0x6E,0x5D,0xF6,0xB0,0xB7,0xB5,0x17,0x5B,0xD6,0x2A,0x9B,0xC7,0x9D,0x5D,0x5B,0x9B,0xEF,0xEA,0x77,0x7D,0xCA,0x5F,0x55,0xD9,0x94,0xF4,0xFE,0x7F};
//const uint8_t spTANGO[] PROGMEM = {0x0E,0x58,0x5A,0xC3,0x02,0x27,0xEB,0xA1,0xC4,0x2B,0x97,0xDC,0xF2,0x16,0x27,0xEF,0x51,0xB9,0x2A,0x2B,0xEF,0xAC,0x64,0x3D,0x60,0x79,0x99,0xE2,0x52,0x74,0x8F,0x9E,0x56,0xAA,0x43,0x99,0x24,0x75,0x5A,0x3A,0x0E,0x4D,0x31,0xC1,0xAC,0x96,0x24,0xCD,0x35,0x96,0x38,0xC9,0xAA,0xD6,0x25,0x17,0x96,0xA6,0xBB,0xE7,0xB0,0xA6,0x2C,0x2A,0xDB,0xC5,0xFB,0x9E,0xE6,0x92,0x76,0x1F,0x3A,0x83,0x2D,0x6F,0x3C,0xC3,0xE5,0x6C,0x65,0xA9,0xB8,0xF1,0xB7,0xBD,0xFF,0x1F};
//const uint8_t spUNIFORM[] PROGMEM = {0x61,0x3D,0x56,0x98,0xD4,0xB6,0xE6,0xA5,0x8D,0xC7,0xA8,0x01,0xC5,0xDA,0x33,0x2C,0x97,0x06,0x12,0xD9,0x4F,0xD9,0x6D,0x30,0xA6,0x65,0xDF,0x79,0x4B,0x8B,0x11,0xCF,0xE0,0xAE,0x29,0xCD,0x4E,0x5D,0x38,0xEA,0xF5,0xF4,0x64,0x45,0x47,0x84,0xCA,0xE6,0x5D,0xF5,0x96,0x01,0xCD,0x97,0x6A,0x40,0x03,0x1A,0x28,0x5D,0xD0,0xDB,0x61,0xEC,0x7D,0xF7,0x7B,0x3C,0x53,0x16,0xDB,0x9A,0xEA,0xF5,0x2E,0x6B,0x2D,0x6A,0x43,0x46,0xBC,0xCD,0xB3,0x3D,0xD9,0xB5,0xDA,0x70,0xDF,0x72,0xE7,0x94,0xEA,0xCD,0x9D,0xDD,0x9D,0xBC,0x73,0xA9,0x28,0x35,0x4F,0x12,0x41,0xE1,0x96,0xD4,0x3D,0x4D,0x24,0xA7,0x8A,0x94,0xF8,0xFA,0x37,0x7C,0xCD,0x76,0x78,0x50,0xEA,0xF8,0xFD,0x3F};
//const uint8_t spVICTOR[] PROGMEM = {0x6E,0x2D,0xCA,0xD8,0x43,0xD5,0x99,0xBD,0x58,0xE6,0x70,0xF1,0x9A,0x97,0xD5,0xB6,0x54,0xAA,0x26,0x7D,0x6E,0xB5,0xB2,0xD6,0x8D,0x4D,0x74,0xCB,0x4E,0x4D,0x3C,0xB2,0xAA,0x8B,0x38,0x16,0x40,0xE5,0x8C,0x18,0x40,0xA0,0x08,0xE5,0x2E,0x22,0x1B,0x0C,0xB0,0xED,0xA4,0x02,0xAA,0x15,0x5A,0x43,0xF5,0x21,0x54,0x96,0x6D,0x2C,0xA5,0x26,0x7A,0xB9,0xB7,0xBE,0xA5,0x27,0x57,0x87,0x2E,0xF7,0x1F,0xFE,0xDC,0x49,0xBB,0xBC,0x6F,0xFC,0xFD,0xEF,0xFF,0xFF,0x07};
//const uint8_t spWHISKY[] PROGMEM = {0x04,0x88,0xAE,0x8C,0x03,0x12,0x08,0x51,0x74,0x65,0xE9,0xEC,0x68,0x24,0x59,0x46,0x78,0x41,0xD7,0x13,0x37,0x6D,0x62,0xC3,0x5B,0x6F,0xDC,0xD2,0xEA,0x54,0xD2,0xE3,0x89,0x01,0x7E,0x2B,0xF7,0x80,0x07,0x14,0xD0,0xE5,0x15,0x38,0x60,0x8C,0x70,0x03,0x04,0x29,0x36,0xBA,0x5E,0x14,0x34,0x72,0xF6,0xE8,0xA7,0x6F,0x82,0xF4,0x2D,0x73,0xEA,0x47,0x3A,0x67,0x6A,0xC0,0xF0,0x2F,0xF1,0x4E,0xCF,0xA8,0x8A,0x1C,0xB9,0xD8,0xFF,0xEE,0x1F,0xBB,0x59,0xD0,0xD6,0xFE,0x3F};
//const uint8_t spXRAY[] PROGMEM = {0x69,0xAE,0xDE,0x34,0x3A,0x6B,0x9F,0xAC,0xA5,0x66,0x0F,0x5F,0x7D,0x8B,0x5B,0xAD,0xAA,0x8D,0xC0,0xB4,0x58,0xDD,0xDB,0xD0,0xB6,0x6E,0xE4,0xE6,0x69,0x10,0x28,0x42,0xB9,0x8B,0xC8,0x06,0x10,0x40,0xCD,0x63,0x1A,0x60,0xC0,0x6F,0x63,0x1C,0xA0,0x00,0x5B,0xFD,0x54,0xEA,0x54,0xE7,0x66,0x4E,0x8D,0xC3,0xD3,0xF4,0xE6,0xA9,0x4F,0x6B,0xAE,0x2E,0x39,0x42,0xFB,0xEE,0x6D,0x1C,0xCD,0x24,0x45,0xF9,0xE7,0x7E,0xF6,0x33,0x5F,0xF9,0x0A,0xCF,0xB4,0x4B,0x94,0xBE,0x27,0x3E,0xF1,0x75,0xEF,0xCC,0x09,0x18,0xB5,0xF8,0xFF,0x01};
//const uint8_t spYANKEE[] PROGMEM = {0x6E,0xEF,0x42,0x58,0xB6,0x6B,0xA7,0x7D,0x68,0x25,0xCC,0x59,0xB4,0xF6,0x11,0x82,0xC8,0x6A,0xF1,0x1A,0x46,0x2E,0x12,0x8D,0x37,0xA7,0xEF,0xC9,0xC9,0xA3,0x6E,0x9F,0x76,0xD4,0x22,0x73,0x7F,0xB4,0xEA,0x51,0x0B,0x2D,0x62,0xE2,0xA8,0x47,0x43,0xD7,0x2E,0x29,0xAE,0x4D,0x92,0xAA,0x28,0x5C,0x8B,0xB9,0x6A,0xEB,0x24,0x95,0xE3,0x80,0x1D,0x93,0x35,0x90,0xBA,0x59,0x03,0x45,0xB3,0x75,0x19,0x46,0x27,0x96,0x98,0xC5,0x65,0x1F,0xCD,0x88,0xBC,0x16,0xD7,0x3D,0x3D,0x63,0x10,0x49,0x6E,0xED,0xF8,0xFA,0xEF,0xFF,0x01};
//const uint8_t spZULU[] PROGMEM = {0x6D,0xFE,0xDE,0xC4,0xC4,0xE8,0x29,0x60,0x00,0x2E,0x0F,0x9C,0x6C,0x29,0x71,0x2A,0x4E,0x77,0x93,0x15,0x77,0x2A,0xAE,0xC3,0xCE,0x76,0x3C,0x92,0xA5,0x44,0x78,0xD1,0x6D,0xCF,0x47,0x3B,0xB8,0xBB,0x07,0xF6,0x5B,0x43,0x91,0x6E,0xA9,0xF2,0x65,0x4C,0xC9,0x98,0x97,0x69,0x9F,0xBA,0xE5,0x33,0x9C,0xC1,0x9A,0x8F,0xCA,0xDE,0x70,0x07,0x9D,0xEE,0xC9,0x79,0xE2,0xED,0xFF,0xFF,0x07};
//const uint8_t spTHE[] PROGMEM = {0x6E,0xAD,0xCC,0x34,0x9C,0x97,0xE8,0x23,0xED,0x5D,0xA4,0xBB,0xF1,0x96,0xD9,0xEE,0xFA,0xD4,0x45,0x75,0xA6,0xC9,0xE6,0x5B,0xDF,0xE6,0x0E,0x67,0xAE,0x7C,0xD3,0x43,0xFB,0xEC,0x7D,0x9E,0xFD,0xFE,0x7F};
//const uint8_t spWATTS[] PROGMEM = {0xAA,0x15,0x7A,0x23,0x5C,0x12,0xE9,0xD1,0x0D,0x5A,0x76,0x75,0xB2,0xAA,0xD0,0x3B,0xD9,0xED,0x81,0x99,0x4A,0x1B,0xD5,0x8C,0x25,0xFA,0xDD,0xF5,0xA9,0xA3,0x9F,0x2C,0xE3,0x2E,0xB7,0xBE,0xCD,0xEE,0xD6,0x9C,0xDC,0x44,0xAB,0xAD,0x6E,0x67,0x0E,0xE9,0xCD,0x7D,0xBB,0x1E,0x0C,0x1C,0x24,0xCA,0x5C,0x59,0x03,0x00,0x01,0xB6,0x2A,0x15,0xC0,0x2F,0x19,0x1A,0xB0,0x80,0x05,0x2C,0x60,0x80,0xAF,0xA2,0x24,0xF0,0xFF};
//const uint8_t spMETER[] PROGMEM = {0xA1,0x8F,0x5C,0xB5,0x56,0x92,0xE4,0xE1,0xF4,0xDD,0x0B,0x59,0x6B,0xE3,0x53,0x8C,0x14,0x44,0x15,0x8B,0x46,0x3A,0xB3,0x03,0x7B,0xBE,0x99,0x89,0x49,0xB7,0x72,0xC4,0xEA,0x4C,0x01,0xD8,0x2E,0xC8,0x03,0xA3,0xAB,0x91,0x39,0x2C,0x17,0x8D,0xAE,0x36,0xE6,0x34,0x7F,0x3D,0xE6,0xEA,0x13,0x6C,0x79,0x73,0x3B,0xAA,0x1B,0xB0,0xD3,0x3C,0xFD,0x6A,0x4F,0xF1,0x09,0x35,0x9E,0xA5,0xBE,0xFF,0x0F};
const uint8_t spDANGER[] PROGMEM = {0x2D,0xBF,0x21,0x92,0x59,0xB4,0x9F,0xA2,0x87,0x10,0x8E,0xDC,0x72,0xAB,0x5B,0x9D,0x62,0xA6,0x42,0x9E,0x9C,0xB8,0xB3,0x95,0x0D,0xAF,0x14,0x15,0xA5,0x47,0xDE,0x1D,0x7A,0x78,0x3A,0x49,0x65,0x55,0xD0,0x5E,0xAE,0x3A,0xB5,0x53,0x93,0x88,0x65,0xE2,0x00,0xEC,0x9A,0xEA,0x80,0x65,0x82,0xC7,0xD8,0x63,0x0A,0x9A,0x65,0x5D,0x53,0xC9,0x49,0x5C,0xE1,0x7D,0x2F,0x73,0x2F,0x47,0x59,0xC2,0xDE,0x9A,0x27,0x5F,0xF1,0x8B,0xDF,0xFF,0x03};
//const uint8_t spPRESSURE[] PROGMEM = {0x06,0x28,0xC1,0x4C,0x03,0x2D,0x49,0x59,0x4A,0x9A,0x3D,0x9F,0xAC,0x04,0x2D,0x2D,0x69,0x73,0xB2,0x56,0x4C,0x43,0x6D,0xF5,0xCD,0x5A,0x3E,0x6A,0x89,0x09,0x65,0x71,0xC0,0xAA,0xDB,0x1E,0x88,0x40,0x04,0x46,0xDF,0x63,0x0A,0x9A,0x65,0x1D,0x43,0xC9,0x49,0x5C,0xE1,0x7D,0xCF,0x7B,0x9F,0x47,0xB9,0xCA,0x12,0xF6,0xD6,0x3C,0xF9,0x8B,0x9F,0xFD,0xFF,0x1F};
//const uint8_t spCHANGE[] PROGMEM = {0x06,0x58,0xD5,0xC3,0x01,0x73,0x6E,0x64,0xC0,0x03,0x2B,0x1B,0xB9,0x95,0xDC,0xFB,0xDE,0xE2,0x14,0xA3,0x06,0x4B,0xE5,0xA2,0x9B,0xEF,0x7C,0x95,0xC3,0x1B,0xCA,0x64,0xA5,0x5D,0xED,0x76,0xCE,0x7D,0x2D,0x6B,0xB3,0x24,0x19,0x11,0x3A,0x1D,0xDD,0x93,0x94,0x7A,0x54,0x7F,0xBA,0xBB,0x4B,0xC5,0x08,0xAD,0x1A,0x9E,0xEE,0x85,0x43,0x2D,0x9E,0x79,0xAA,0x10,0xCA,0xD2,0x2A,0xEA,0xC9,0x82,0xAC,0xC3,0x6B,0xCB,0x87,0x3D,0x51,0xB2,0x75,0x74,0x2D,0xF4,0xCE,0x30,0x2C,0x62,0x76,0x14,0x30,0x94,0x92,0x02,0xC6,0x5C,0xB7,0x00,0x02,0x5A,0x17,0xF9,0x7F};
//const uint8_t spMINUS[] PROGMEM = {0xE6,0x28,0xC4,0xF8,0x44,0x9A,0xFB,0xCD,0xAD,0x8D,0x2A,0x4E,0x4A,0xBC,0xB8,0x8C,0xB9,0x8A,0xA9,0x48,0xED,0x72,0x87,0xD3,0x74,0x3B,0x1A,0xA9,0x9D,0x6F,0xB3,0xCA,0x5E,0x8C,0xC3,0x7B,0xF2,0xCE,0x5A,0x5E,0x35,0x66,0x5A,0x3A,0xAE,0x55,0xEB,0x9A,0x57,0x75,0xA9,0x29,0x6B,0xEE,0xB6,0xD5,0x4D,0x37,0xEF,0xB5,0x5D,0xC5,0x95,0x84,0xE5,0xA6,0xFC,0x30,0xE0,0x97,0x0C,0x0D,0x58,0x40,0x03,0x1C,0xA0,0xC0,0xFF,0x03};
//const uint8_t spNOT[] PROGMEM = {0x66,0x6B,0x1A,0x25,0x5B,0xEB,0xFA,0x35,0x2D,0xCD,0x89,0xA7,0xDA,0x9A,0x31,0x34,0x93,0x9E,0xA6,0x4B,0x4E,0x57,0xE5,0x86,0x85,0x6C,0xBE,0xED,0x6D,0x57,0x93,0xFC,0xB9,0x96,0x2D,0x1E,0x4D,0xCE,0xAD,0xE9,0x3E,0x7B,0xF7,0x7D,0x66,0xB3,0x08,0xE5,0x2E,0x22,0x1B,0x00,0x40,0x01,0x4B,0xB8,0x2B,0xE0,0x87,0x68,0x05,0x74,0x9D,0x82,0x80,0x62,0x55,0xFE,0x1F};
//const uint8_t spSTART[] PROGMEM = {0x04,0xF8,0xC5,0x9C,0x03,0x1A,0xD0,0x80,0x04,0x38,0x00,0x06,0x58,0x22,0x7D,0x65,0x9D,0x87,0x8B,0x5B,0xD7,0x53,0x67,0x37,0x96,0x21,0x79,0x6F,0x7D,0xEB,0xD5,0x64,0xB7,0x92,0x43,0x9B,0xC7,0x50,0xDD,0x92,0x1D,0xF7,0x9E,0x53,0xDF,0xDD,0x59,0xCB,0x21,0xAD,0xF6,0x46,0xA0,0x08,0xE5,0x2E,0x22,0x1B,0x40,0x01,0xDD,0xB2,0x2A,0xE0,0xB7,0x0C,0x03,0x4C,0x9D,0x4A,0x80,0xEA,0x54,0xFE,0x1F};
//const uint8_t spLINE[] PROGMEM = {0x61,0xED,0x40,0xC7,0xCD,0xD2,0x96,0x65,0x01,0x9E,0x50,0x73,0x5B,0x96,0x83,0x70,0x87,0x2D,0xD9,0x9A,0x3B,0xA9,0x49,0x97,0x2E,0xB7,0xBF,0xDD,0x6D,0x4F,0x5B,0xD5,0xBA,0x95,0x75,0xD9,0xFD,0x1A,0x86,0x6B,0xD6,0x8A,0xC5,0x7B,0x9A,0xF3,0x3C,0xFA,0x51,0xAE,0x9E,0x59,0x55,0x2A,0x72,0xBE,0xC2,0x35,0x12,0xB9,0x88,0xBB,0x89,0x57,0xB8,0x7A,0x72,0x77,0xB0,0x3A,0xE9,0xEF,0x2E,0xC5,0xDD,0x1F,0x87,0xBF,0x8A,0xD0,0xEA,0x68,0xF8,0xFF};
//const uint8_t spOFF[] PROGMEM = {0x6B,0x4A,0xE2,0xBA,0x8D,0xBC,0xED,0x66,0xD7,0xBB,0x9E,0xC3,0x98,0x93,0xB9,0x18,0xB2,0xDE,0x7D,0x73,0x67,0x88,0xDD,0xC5,0xF6,0x59,0x15,0x55,0x44,0x56,0x71,0x6B,0x06,0x74,0x53,0xA6,0x01,0x0D,0x68,0x80,0x03,0x1C,0xF8,0x7F};
//const uint8_t spTIME[] PROGMEM = {0x0E,0xD8,0x5A,0x2D,0x00,0x37,0xA6,0x39,0xA0,0x9B,0xB0,0x95,0x17,0x9B,0x1E,0x21,0x2D,0x4F,0x51,0xF4,0x86,0x25,0x6F,0xB9,0xD5,0xA9,0xBB,0x9E,0xE0,0xD6,0x36,0xB7,0xBE,0xED,0x1E,0xD6,0xDC,0x5D,0x29,0xB7,0xAF,0xDE,0x6B,0xDD,0xCB,0xDE,0xB4,0xB1,0xAB,0xD6,0xC9,0x67,0x3C,0xDD,0x35,0x85,0x73,0x98,0xD8,0xFD,0x7F};
//const uint8_t spAUTOMATIC[] PROGMEM = {0x6B,0xAC,0xA4,0xA7,0x82,0xFD,0xDD,0xF1,0x0E,0x67,0x68,0xB2,0xA2,0x83,0x72,0x1B,0xA0,0x52,0x65,0x03,0xFC,0x24,0x3A,0xEA,0xAD,0xCD,0xD5,0x4C,0xDB,0xA9,0xAB,0x76,0x4B,0x93,0x2D,0x67,0x28,0xA2,0xCC,0xC2,0xF3,0x8C,0x21,0x2B,0xD7,0x70,0xC9,0xD8,0x86,0x4A,0x8D,0xC6,0x35,0x49,0xE9,0x8B,0x54,0x29,0x76,0x37,0x63,0xC8,0xCE,0xDD,0x54,0x6A,0x9D,0xBA,0xC6,0xD2,0xD2,0x58,0x72,0xAB,0x5B,0xDE,0x72,0x35,0x35,0x5B,0x84,0x54,0x6D,0xD3,0xEE,0x90,0x11,0xEA,0x4E,0x5A,0x5B,0x53,0xAA,0xB3,0x2F,0xB9,0xD3,0x59,0xBB,0x6B,0xE5,0x94,0x35,0x7B,0x6F,0xE7,0x34,0xAD,0xD8,0xBA,0x17,0x81,0x22,0x94,0xBB,0x88,0x6C,0x00,0x03,0xB4,0x12,0x22,0x01,0x0E,0xFC,0x3F};
//const uint8_t spWEIGHT[] PROGMEM = {0x62,0x13,0x7E,0x23,0x4C,0x22,0xEB,0x4D,0xAD,0x46,0x7F,0x5A,0xB0,0x95,0xB4,0x38,0xF3,0xA1,0x4E,0x6D,0xD6,0x94,0xCC,0x9A,0x3B,0x6D,0x39,0x7D,0xF3,0xC1,0x99,0xF2,0xE6,0xB4,0x23,0x0E,0x51,0xF8,0x9A,0xDB,0x8E,0x6E,0xE4,0x04,0xC9,0x7C,0xDC,0x17,0x75,0x8C,0x26,0xA8,0x56,0x8B,0x11,0x28,0x42,0xB9,0x8B,0xC8,0x06,0x00,0x00,0x01,0xBC,0xC0,0x66,0x80,0x1F,0x73,0x04,0xB0,0xDD,0x34,0x02,0x46,0xE9,0xF8,0x7F};
//const uint8_t spSMOKE[] PROGMEM = {0x08,0xF8,0xBB,0x4D,0x02,0x0A,0x78,0x33,0xCC,0x03,0x1E,0x40,0x40,0x53,0x1A,0x22,0xC8,0x92,0x35,0x87,0x92,0xD4,0x74,0x95,0x99,0x55,0x7B,0x52,0xB7,0x5D,0xEE,0x72,0x57,0xAD,0xF7,0x6E,0xA2,0x84,0xFB,0xD6,0xD1,0x6D,0x4E,0x6E,0x84,0xA3,0x37,0x84,0x8B,0x50,0xEE,0x22,0xB2,0x01,0x80,0x01,0x75,0x14,0x7B,0x80,0x01,0x39,0x98,0xFC,0x3F};
//const uint8_t spABORT[] PROGMEM = {0x63,0xC9,0xA6,0x2A,0x54,0xD7,0x9C,0xA5,0xF0,0xEC,0x0A,0xCA,0xBB,0x67,0xB6,0x1B,0xD9,0xA6,0xAA,0x59,0xE9,0x46,0x8E,0x20,0xC2,0x83,0x25,0x0B,0x39,0x1D,0x4D,0x4D,0x77,0x37,0x76,0x1A,0x55,0x54,0x53,0xA9,0x94,0x65,0x17,0xAB,0xC8,0xAC,0xDA,0x53,0xB9,0xEF,0x72,0x35,0x51,0x5E,0x58,0xAB,0xFE,0xD5,0x66,0xB5,0x12,0x23,0xFA,0xD7,0x94,0x63,0x53,0x95,0xF8,0x69,0x6B,0xEE,0x4E,0x51,0xE2,0x2F,0x6C,0xB9,0x13,0x57,0x59,0x7F,0x04,0x8A,0x50,0xEE,0x22,0xB2,0x01,0x1C,0xB0,0x9D,0xBA,0x03,0x7E,0x0F,0x53,0xC0,0x48,0x53,0x08,0x88,0xD2,0xEC,0xFF,0x01};
//const uint8_t spCALL[] PROGMEM = {0x02,0x48,0xA5,0xD8,0x02,0x1A,0x18,0x71,0x16,0x15,0x95,0xA4,0x7A,0x65,0x95,0xD5,0x44,0x88,0xFB,0x5B,0xDC,0x62,0x95,0x49,0x4E,0xA7,0x49,0xB6,0x5D,0xED,0x76,0x76,0x73,0x9A,0x4B,0xD9,0x83,0xBD,0x2A,0xB4,0xCE,0xF5,0x0A,0x77,0x50,0xB9,0x25,0x92,0x25,0xDE,0xE1,0x49,0xC2,0x77,0x44,0x5D,0xFB,0xEF,0xFF,0x01};
//const uint8_t spCYCLE[] PROGMEM = {0x08,0xF8,0xB3,0x5C,0x03,0x16,0xB0,0x80,0x06,0x56,0x55,0x64,0xB9,0xBB,0xB7,0x39,0x4D,0x71,0xA5,0x15,0xBA,0xF8,0x36,0xBB,0x19,0x75,0xCB,0x8A,0xED,0x35,0xB1,0xB7,0xAC,0x15,0xA1,0xDC,0x45,0x64,0x03,0x03,0xE2,0x10,0x2A,0x53,0x54,0xE3,0x69,0xDC,0x79,0xAD,0x1D,0x67,0x57,0xB0,0xB7,0x76,0x6C,0xAC,0xDD,0xC9,0xEC,0xDB,0xD5,0x70,0x4C,0x07,0x69,0xCD,0x8F,0x7B,0x13,0x9B,0x49,0xA1,0xBC,0xFE,0xFB,0x7F};
//const uint8_t spDISPLAY[] PROGMEM = {0x04,0x88,0xD0,0x63,0x2C,0x53,0xB5,0xB1,0x52,0x9F,0x3B,0xDF,0x79,0x4F,0x65,0xF8,0xCE,0x5D,0x4D,0xB9,0x29,0xE0,0xCF,0x52,0x0B,0x78,0x40,0x03,0x08,0xC8,0xDC,0x15,0x40,0x02,0xA9,0x2D,0x4A,0x6A,0x45,0xEC,0xB5,0xB6,0xA0,0xCA,0x71,0x4C,0x73,0xEA,0xCA,0x3B,0xC2,0xA5,0xCB,0xAD,0x6E,0x75,0x9A,0xA6,0x93,0xAD,0x62,0xF3,0xED,0xEE,0xB4,0x96,0x1E,0x13,0x25,0x7D,0xF3,0xDE,0xFB,0xDE,0xCE,0xE6,0x15,0xA3,0x6A,0x55,0x7D,0xCA,0x3B,0x62,0x22,0x67,0x6C,0xCE,0xDF,0xFF,0x03};
//const uint8_t spEQUAL[] PROGMEM = {0x6D,0x18,0x49,0x91,0xBC,0x17,0xEF,0x6E,0x15,0xA3,0x15,0xA2,0xE5,0x93,0x9D,0xB5,0x7C,0x6C,0x07,0xB6,0x7C,0x1C,0xF2,0x11,0x19,0xAC,0xB2,0x0E,0x02,0x45,0x28,0x77,0x11,0xD9,0x00,0x04,0xF0,0xA3,0x88,0x01,0xBE,0x65,0xB4,0x36,0xC8,0x8D,0x08,0xF4,0x33,0xBB,0x39,0xB4,0xB5,0xE2,0xAE,0x0E,0xF2,0xDB,0xD7,0x7A,0xA4,0x33,0xD3,0xEA,0x0E,0xF0,0x9B,0xCE,0xC8,0xAE,0x92,0x24,0x77,0xB8,0x33,0xF8,0x68,0xE6,0xD6,0xF1,0xFE,0x7F};
//const uint8_t spFAST[] PROGMEM = {0x08,0x68,0xD6,0x55,0x02,0x0A,0x18,0x22,0x5D,0x02,0x1A,0x58,0x45,0x75,0xA3,0x5E,0xFA,0xE6,0x96,0xB7,0x39,0x6D,0xD3,0xA3,0xD6,0xBA,0xFA,0xF6,0x6B,0xAE,0xAE,0xA4,0xCA,0xEE,0xAC,0xAD,0x99,0xD1,0x28,0x5B,0x5C,0x8E,0xE2,0x4A,0x2B,0xFD,0x4E,0xBE,0xE2,0x85,0x80,0x25,0x5B,0x39,0xC0,0x80,0xDF,0x32,0x24,0xA0,0x01,0x0B,0x58,0x80,0x02,0xC0,0x80,0x3B,0x4C,0x14,0xF0,0xBC,0x38,0x03,0x96,0xDD,0xF9,0x7F};
//const uint8_t spABOUT[] PROGMEM = {0x63,0xCF,0xA6,0x2A,0x54,0xD7,0xDC,0x6D,0xAD,0x85,0x67,0x57,0x50,0x5E,0x76,0x1A,0xD9,0xA6,0xAA,0x59,0xF9,0x26,0xB6,0x20,0xC2,0x83,0x25,0x0B,0x5B,0x1C,0x4D,0x4D,0x77,0x37,0xA1,0x6F,0xD4,0x45,0xCD,0xB2,0xAC,0xBE,0x98,0xCD,0x34,0xDD,0x72,0xDA,0xAA,0xDA,0x2B,0x79,0xCD,0x6D,0x6F,0x77,0xC7,0xBD,0x94,0x23,0xA4,0xCE,0x22,0xDB,0x15,0x8F,0xF0,0x45,0xEB,0x55,0xC2,0x79,0xC4,0x2F,0x42,0xB9,0x8B,0xC8,0x06,0x00,0x03,0x4C,0xA7,0xEE,0x80,0xD7,0x53,0x09,0x50,0x83,0xCB,0xFF,0x03};
//const uint8_t spGO[] PROGMEM = {0x06,0x08,0xDA,0x75,0xB5,0x8D,0x87,0x4B,0x4B,0xBA,0x5B,0xDD,0xE2,0xE4,0x49,0x4E,0xA6,0x73,0xBE,0x9B,0xEF,0x62,0x37,0xBB,0x9B,0x4B,0xDB,0x82,0x1A,0x5F,0xC1,0x7C,0x79,0xF7,0xA7,0xBF,0xFE,0x1F};
//const uint8_t spINCH[] PROGMEM = {0x23,0x1B,0xD6,0x48,0x2A,0x67,0x9F,0x76,0xC4,0x20,0x89,0xBC,0x7D,0xEB,0x53,0x8F,0x90,0xEC,0x12,0xB7,0x77,0xBB,0xC6,0xEE,0x55,0x92,0x6B,0x72,0x59,0xAA,0x82,0x28,0x4F,0x35,0xE9,0x68,0x0A,0xB9,0xD3,0x6D,0x93,0xA6,0x28,0xC8,0xB1,0xB0,0x85,0x40,0x11,0xCA,0x5D,0x44,0x36,0x00,0x02,0xD6,0xDC,0xD2,0x80,0x05,0x32,0xE0,0x01,0x0F,0x10,0xA0,0x26,0xA1,0xFF,0x07};
//const uint8_t spLOW[] PROGMEM = {0x65,0xDF,0x98,0xA3,0x4A,0xB4,0xE5,0x65,0x4E,0xAB,0x9F,0xD4,0xA2,0x92,0xBC,0x9E,0xB6,0xF2,0xC8,0x71,0xEA,0x7B,0x9B,0xD5,0x24,0x5E,0x3D,0xCC,0x79,0x77,0x3B,0xFB,0xB9,0xF4,0xBD,0xEE,0xF5,0x0C,0x97,0x37,0x5D,0x0B,0x92,0xC7,0xDF,0xFE,0xFD,0x7F};
const uint8_t spMOTOR[] PROGMEM = {0x66,0xAA,0x8C,0x69,0x53,0x92,0xC4,0x2D,0x2F,0x6B,0x2A,0x74,0xDA,0x9D,0xB2,0xDD,0xF6,0x36,0xAB,0xCE,0x78,0xDA,0x9D,0xB2,0xD5,0x9A,0x01,0xDB,0x77,0x45,0xA0,0x75,0xC5,0xB8,0x71,0x59,0xDA,0x31,0xE5,0x6A,0x22,0x63,0xDE,0xDA,0x9A,0xBB,0xA3,0x75,0x68,0xAF,0x7B,0x3E,0xC3,0x9D,0x97,0x60,0x87,0xE6,0x8B,0x4F,0x78,0x4B,0x76,0xB2,0x09,0xAF,0xFE,0xFD,0x7F};
//const uint8_t spOPEN[] PROGMEM = {0x61,0xCC,0xB8,0x7B,0x8C,0xB2,0xF5,0x61,0x8F,0xAB,0xA9,0x30,0xA7,0x83,0xBC,0xCD,0xBA,0x95,0x19,0x57,0x97,0xB1,0x6B,0xD2,0x58,0x12,0x31,0x11,0x89,0x01,0x01,0x2E,0x9A,0x48,0x60,0x94,0xC5,0x86,0xBB,0xC9,0xA6,0x35,0x36,0x95,0x1A,0xA6,0x7B,0xF6,0x3E,0x8E,0x26,0x42,0x3D,0x78,0xF1,0x3C,0xCB,0xD5,0x0D,0x71,0x78,0x24,0xAB,0x77,0xBA,0x47,0x12,0x73,0xB1,0xB8,0xF9,0xFE,0x7F};
//const uint8_t spPERCENT[] PROGMEM = {0x02,0xC8,0xD9,0x5C,0x03,0x2D,0x8A,0xB1,0x30,0x46,0x52,0xAF,0xBA,0x86,0x26,0x1A,0xF6,0x77,0x9B,0xD3,0xD5,0x18,0x68,0x69,0x59,0x63,0xEF,0x80,0x5F,0x5A,0x2D,0x60,0x01,0x0B,0x68,0xC0,0x03,0xAB,0x6E,0xDE,0x25,0x2D,0x17,0xDF,0xFA,0x36,0xBB,0x1D,0x53,0xB1,0x6E,0x23,0x5D,0xA7,0x5D,0x23,0x92,0xB9,0xA7,0x62,0x7F,0x20,0x50,0x84,0x72,0x17,0x91,0x0D,0x00,0xA0,0x80,0xA5,0x33,0x0C,0xF0,0xB3,0x27,0x02,0x5A,0x4A,0xFD,0x7F};
//const uint8_t spPROBE[] PROGMEM = {0x02,0xC8,0x29,0x5D,0x03,0x2E,0x0A,0x83,0xCB,0x5D,0x33,0xF7,0xFC,0x94,0xD1,0x96,0x57,0x71,0xF2,0x53,0x66,0xDE,0xE9,0x8D,0xDE,0x76,0x3D,0xDB,0x3E,0x95,0xDD,0xBB,0x8E,0x54,0xEA,0x13,0x0F,0x73,0x19,0x95,0x91,0x46,0x9E,0xD8,0x23,0x68,0x47,0x47,0x24,0xE1,0x1F,0xFF,0xC3,0xEF,0x4D,0x6A,0x99,0x25,0x49,0x67,0xF4,0x96,0x69,0xBA,0x24,0x5E,0xEE,0xAA,0x91,0x2B,0x59,0xD7,0xFE,0x3F};
//const uint8_t spREADY[] PROGMEM = {0x6A,0xB4,0xD9,0x25,0x4A,0xE5,0xDB,0xD9,0x8D,0xB1,0xB2,0x45,0x9A,0xF6,0xD8,0x9F,0xAE,0x26,0xD7,0x30,0xED,0x72,0xDA,0x9E,0xCD,0x9C,0x6D,0xC9,0x6D,0x76,0xED,0xFA,0xE1,0x93,0x8D,0xAD,0x51,0x1F,0xC7,0xD8,0x13,0x8B,0x5A,0x3F,0x99,0x4B,0x39,0x7A,0x13,0xE2,0xE8,0x3B,0xF5,0xCA,0x77,0x7E,0xC2,0xDB,0x2B,0x8A,0xC7,0xD6,0xFA,0x7F};
//const uint8_t spSET[] PROGMEM = {0x08,0xF8,0x35,0x95,0x03,0x02,0xF8,0xC5,0x58,0x03,0x16,0xB0,0xC0,0x2A,0xA6,0x08,0x13,0xD7,0xCE,0xA7,0xEC,0xAE,0xD5,0xCC,0xD6,0xDC,0xEA,0x54,0x35,0xA6,0xA4,0xE5,0x9A,0x3D,0xCC,0x25,0x2E,0x08,0x14,0xA1,0xDC,0x45,0x64,0x03,0x00,0x30,0x60,0x88,0x30,0x05,0xFC,0x1C,0x25,0x80,0x65,0xB6,0x10,0x50,0xA2,0xD0,0xFF,0x03};
//const uint8_t spSPEED[] PROGMEM = {0x04,0xF8,0xBD,0x5C,0x02,0x1A,0xD0,0x80,0x04,0x30,0x40,0x00,0x6E,0x55,0x59,0xCB,0x75,0x7A,0x7A,0xA5,0x59,0xC5,0xC8,0x41,0x64,0xBA,0x66,0xE5,0x33,0x95,0x82,0xEB,0xD6,0x9B,0xEE,0x6C,0xE5,0x33,0x8D,0x82,0xEB,0xD6,0x5D,0xAD,0x7E,0xC5,0x22,0x48,0xDF,0xB2,0xC7,0xBD,0xCC,0x6D,0x1E,0xF5,0x60,0xA7,0x65,0x1E,0x95,0x91,0x88,0x9F,0xF4,0x2A,0xD7,0xD0,0x4D,0x64,0xBE,0xE5,0xFF,0x01};
//const uint8_t spUNDER[] PROGMEM = {0xA7,0x6B,0xA4,0x3B,0x4A,0xB3,0x9C,0xAE,0xF1,0xF6,0x48,0xE9,0x7C,0xDB,0x55,0x56,0x13,0x56,0x62,0x8D,0x5B,0x56,0x15,0xFA,0x68,0x68,0xA9,0x79,0x28,0xA2,0xE0,0x31,0x4D,0x8D,0xA6,0x36,0x52,0x27,0x39,0x13,0x85,0x7E,0x7A,0x35,0x56,0x4D,0xB2,0xD6,0xE6,0x4D,0x55,0xAD,0xD5,0x58,0x6B,0x0E,0xB2,0x92,0x3C,0x73,0x2F,0x47,0xE9,0x4A,0x99,0xBC,0x25,0x9F,0xE1,0xCA,0x43,0xB0,0x53,0x7A,0x85,0xBB,0x1C,0xE1,0x56,0xCB,0xEC,0xEF,0xFF,0x07};
//const uint8_t spOPERATOR[] PROGMEM = {0xB0,0x9A,0xAC,0xB6,0xC2,0xAD,0xCD,0xA9,0x3B,0x9D,0xCE,0x94,0x2C,0xB7,0x5A,0x65,0xB6,0x9B,0x61,0xBA,0x66,0x15,0xC5,0x65,0x8C,0xF3,0x62,0x94,0x89,0x50,0xEE,0x22,0xB2,0x01,0x5A,0x95,0x7C,0xB9,0xAB,0x25,0x29,0x55,0x5C,0xC2,0xD3,0x94,0xB5,0x37,0xA9,0x0B,0x9B,0x2C,0x4B,0xB9,0xE6,0xA1,0x8E,0x63,0xCE,0x83,0x53,0xD2,0xFC,0xAE,0xA5,0x16,0x97,0x70,0xCD,0x3B,0xD6,0x11,0x4F,0x30,0xB4,0x4F,0xDB,0x46,0x3C,0x62,0xE3,0x3D,0xF9,0x00,0x07,0xCC,0xD4,0x29,0x81,0xB6,0xD5,0x3A,0x28,0x2D,0x7E,0xDB,0x51,0xFD,0x09,0x2C,0xFB,0xCF,0x77,0x7A,0x4A,0x2C,0x94,0x93,0xBC,0xE1,0xA9,0xE1,0x04,0x46,0xFD,0xC5,0x37,0xFC,0x65,0x19,0x56,0x72,0x96,0xFF,0x07};
//const uint8_t spAMPS[] PROGMEM = {0x69,0xEA,0xA5,0x45,0xD2,0x57,0xEF,0xF1,0x0E,0x77,0xB8,0xDD,0x6D,0x4F,0x53,0x43,0x49,0x79,0xCC,0xDE,0x5D,0x19,0x9B,0x08,0x2C,0x31,0xA7,0x6E,0x49,0x3C,0x39,0xC5,0xBC,0xEA,0x07,0x81,0x22,0x94,0xBB,0x88,0x6C,0x00,0x06,0x44,0x16,0xC6,0x80,0x5F,0xD3,0x39,0xC0,0x01,0x0E,0x50,0x00,0x03,0x18,0xF8,0x7F};
//const uint8_t spMEGA[] PROGMEM = {0x66,0x31,0x3C,0x7C,0x52,0xE3,0xF8,0xC5,0xCF,0x6B,0x2A,0x5E,0x3C,0x34,0x96,0x9C,0xBE,0xC7,0x10,0x77,0x7F,0x7D,0x9B,0x51,0xF5,0xA1,0x6C,0xE2,0x8F,0x53,0xDD,0x1A,0x52,0x68,0x4D,0x0E,0x43,0xF5,0x48,0xE3,0x55,0xBA,0xCD,0x7D,0xA4,0x28,0x6B,0x93,0x35,0xB7,0xC2,0x12,0x9A,0x4F,0xCE,0x5A,0x5D,0x68,0xBA,0x6E,0xDE,0xDB,0x3C,0xC7,0x59,0xA2,0x66,0x6A,0xCC,0xE9,0x6F,0x7D,0xFF,0x1F};
//const uint8_t spPICO[] PROGMEM = {0x08,0xC8,0x8E,0x48,0x03,0x2B,0xEA,0xC1,0x48,0xD2,0x57,0x9F,0x6C,0xE6,0x25,0x08,0x5B,0x73,0xB3,0x54,0x8C,0xC1,0xE0,0x56,0xB3,0x75,0x15,0x80,0xE6,0x47,0x3D,0x30,0x86,0xE2,0x82,0x35,0xB4,0xF7,0x1A,0xB2,0x71,0xF3,0xD6,0xBC,0x6B,0xA9,0xA2,0x2C,0x8A,0xBD,0x8F,0x23,0x89,0xF5,0x34,0xC9,0xDF,0xCF,0x76,0x45,0x57,0x51,0x22,0x79,0xD3,0xED,0xFD,0x6A,0xA8,0x75,0x8D,0x8F,0x79,0x6C,0xCD,0x74,0xB6,0xDD,0xEA,0xB5,0x65,0xD4,0xCD,0xFA,0xFC,0x3F};
const uint8_t spFIRE[] PROGMEM = {0x04,0x18,0xCE,0x4D,0x02,0x1A,0xD0,0x80,0x04,0x46,0x91,0x55,0x57,0x07,0x6D,0xD9,0xCD,0xAE,0x4F,0x55,0x5D,0x59,0x87,0xAE,0xB9,0xD5,0x6D,0x5B,0xDB,0x7D,0x93,0xB6,0xED,0xEE,0xE3,0x5A,0x6B,0x6A,0xF4,0x91,0xD5,0x73,0x6B,0x67,0xF5,0x47,0xBC,0xD4,0xA7,0x9C,0xA5,0x34,0xE4,0xD0,0xA6,0xF0,0xE4,0xAA,0xB8,0x2D,0xAB,0xC3,0x9B,0x62,0xC2,0xAC,0x74,0xF6,0x9F,0xFB,0x72,0x0B,0xEC,0x92,0xCD,0xEE,0xCF,0x43,0x69,0x4C,0x5B,0xFF,0x3F};
//const uint8_t spPOWER[] PROGMEM = {0x0C,0xF0,0xDC,0x4C,0x03,0x2B,0xCD,0x36,0xAB,0x85,0x1B,0x9F,0xBC,0xB1,0xAE,0x6A,0xEA,0x7A,0xB3,0x95,0x15,0xD5,0x39,0x85,0x5D,0x46,0x96,0x7C,0x57,0x3B,0xB6,0x19,0x79,0x30,0x93,0x55,0xA4,0xBB,0xD4,0x2E,0xAD,0x79,0xB1,0xDE,0x3E,0x8D,0x29,0x85,0x61,0x1F,0xF6,0x3B,0xB7,0x7E,0x94,0x33,0x97,0x46,0x5B,0xCE,0x9D,0x9F,0xF0,0x16,0x3F,0x48,0xE7,0x7E,0xC3,0x5B,0xE3,0xA2,0xAC,0xEB,0xF6,0xDF,0xFF,0x03};
//const uint8_t spCOMPLETE[] PROGMEM = {0x0E,0x68,0xA1,0x43,0x03,0xA7,0x2E,0xB2,0x22,0x0B,0xBB,0xDC,0x76,0x75,0x55,0x99,0xB7,0x53,0xB4,0xD1,0x77,0xA6,0x1C,0xA5,0xD6,0x7A,0x9F,0xFA,0x44,0x39,0x5A,0xDC,0x1E,0x9D,0x0C,0x50,0x94,0xB8,0x01,0x46,0x14,0x2F,0x69,0x97,0x9C,0x69,0xA6,0xE4,0x14,0x8D,0x85,0xBB,0x73,0xB3,0x93,0x75,0x6D,0xA2,0x29,0x6F,0x56,0xD6,0xB3,0xB2,0xA8,0x3F,0x59,0xF9,0x18,0x4E,0xA4,0xBE,0x66,0xB6,0x69,0x9F,0xB9,0x08,0xD2,0xDE,0xC4,0x1D,0x81,0x22,0x94,0xBB,0x88,0x6C,0x00,0x00,0x05,0x1C,0xD9,0x6E,0x80,0x65,0x7E,0x18,0xD0,0xEB,0x3A,0x02,0x6A,0x09,0xFC,0x7F};
//const uint8_t spREPAIR[] PROGMEM = {0x69,0x8E,0x8D,0xCD,0x22,0x95,0xB7,0xA9,0x74,0x09,0xB2,0x54,0x7F,0xC6,0x16,0x83,0xCD,0xB5,0xEF,0x1A,0x7A,0x18,0x22,0x97,0xBE,0x75,0x62,0x93,0x08,0xE5,0x2E,0x22,0x1B,0x00,0x04,0xE0,0x93,0x59,0xCB,0x92,0x53,0xCB,0x8C,0x9A,0xAB,0x68,0xD1,0xC5,0xC2,0x5E,0x9F,0xB2,0xA5,0x22,0x0F,0xD9,0x72,0xAB,0x5B,0xDF,0xE6,0x4E,0x63,0xA9,0x25,0xB0,0x4A,0x3B,0xCF,0xAD,0x1F,0xE9,0xAE,0x7A,0x85,0x4E,0xF2,0xE5,0x27,0xBF,0xF9,0xCD,0x5F,0xFA,0x4A,0x1C,0x92,0xE3,0xDC,0xE9,0x2B,0x35,0xA9,0x5A,0x72,0xFF,0x3F};
//const uint8_t spTEMPERATURE[] PROGMEM = {0x0E,0xF8,0x2E,0x2C,0x00,0xCB,0x8F,0x8F,0xA8,0x59,0x15,0xF7,0x58,0x79,0xD2,0x9A,0x5D,0x22,0xB5,0xF5,0x4D,0x47,0x96,0xAB,0x5A,0x87,0x69,0x0E,0x85,0xF7,0x46,0x1D,0xA1,0x0C,0x10,0xE0,0x32,0xBB,0x04,0x56,0x5E,0x62,0x91,0xA6,0x79,0xEF,0x7D,0xEC,0xC1,0x00,0x63,0x6C,0x46,0xC0,0x03,0x16,0x18,0x7D,0x8F,0x29,0x68,0x96,0xB5,0x4D,0x25,0x27,0x71,0x85,0xF7,0xBE,0xF6,0xBD,0x9F,0xF5,0x09,0x77,0x59,0xC2,0xDE,0x9A,0x27,0xBE,0xFE,0xFD,0x7F};
//const uint8_t spSTOP[] PROGMEM = {0x0C,0xF8,0xA5,0x4C,0x02,0x1A,0xD0,0x80,0x04,0x38,0x00,0x1A,0x58,0x59,0x95,0x13,0x51,0xDC,0xE7,0x16,0xB7,0x3A,0x75,0x95,0xE3,0x1D,0xB4,0xF9,0x8E,0x77,0xDD,0x7B,0x7F,0xD8,0x2E,0x42,0xB9,0x8B,0xC8,0x06,0x60,0x80,0x0B,0x16,0x18,0xF8,0x7F};
//const uint8_t spMACHINE[] PROGMEM = {0xC2,0x56,0x3C,0x7D,0xDC,0x12,0xDB,0x3E,0x8C,0x89,0xBA,0x4C,0x4A,0x96,0xD3,0x75,0x95,0x12,0x6E,0xBD,0x6F,0xB7,0xBA,0x16,0x5A,0x58,0x3D,0xB3,0x03,0xA6,0x14,0x76,0xC0,0xCC,0x37,0x11,0xC8,0x40,0x04,0x22,0xB0,0x92,0xD9,0x9A,0xC1,0x7D,0xF5,0xCD,0x6F,0x3E,0x8A,0x39,0x14,0xA5,0x72,0xD4,0x28,0x67,0x56,0xD4,0x89,0xD2,0xB3,0xE9,0x63,0x5D,0xD2,0xDA,0x03,0x49,0xA9,0xDB,0xCD,0x47,0x3C,0xE3,0xEB,0xBF,0xF4,0x75,0x57,0xEC,0xEE,0x9B,0xF2,0x9B,0xBE,0x56,0x34,0xCC,0xA2,0xF2,0xFF,0x03};
const uint8_t spON[] PROGMEM = {0x65,0x4A,0xEA,0x3A,0x5C,0xB2,0xCE,0x6E,0x57,0xA7,0x48,0xE6,0xD2,0x5D,0xBB,0xEC,0x62,0x17,0xBB,0xDE,0x7D,0x9F,0xDA,0x5C,0x5C,0x7A,0xAA,0xB5,0x6E,0xCB,0xD0,0x0E,0xAD,0x6E,0xAF,0xEE,0xF9,0x88,0x67,0xBC,0xDC,0x3D,0xAC,0x60,0xB8,0x45,0xF3,0xB7,0xBF,0xC3,0xDD,0xA2,0xBB,0xAB,0xCD,0x89,0x8F,0x7F,0xFE,0x1F};
//const uint8_t spCONTROL[] PROGMEM = {0x06,0x68,0xA5,0xCD,0x02,0x2B,0xA9,0x36,0xD5,0x43,0x5A,0x9F,0xA6,0xA9,0x36,0x4F,0xEE,0x73,0xDA,0xC1,0xDA,0x35,0x79,0x73,0x6B,0x9B,0x62,0xEA,0xB0,0x78,0xB3,0x4B,0x7D,0x91,0x18,0xED,0xE6,0x16,0x81,0x22,0x94,0xBB,0x88,0x6C,0x10,0x40,0x0B,0xE1,0x1E,0x88,0xC0,0x48,0x53,0xE2,0x0A,0x17,0x67,0x3B,0x3B,0x59,0xB2,0x11,0x95,0xA2,0x7C,0x64,0x91,0x4F,0x47,0x92,0xF7,0x99,0xAF,0xA2,0xE0,0xEE,0x76,0x56,0xBF,0x9B,0x39,0xB4,0x29,0xB1,0x9C,0x76,0xF4,0x56,0xD7,0xBA,0xE5,0x3B,0x3F,0xF1,0x29,0x77,0xE6,0x9D,0x63,0x9C,0xE7,0xFF,0x01};
//const uint8_t spELECTRICIAN[] PROGMEM = {0x6B,0x9D,0xA6,0x88,0xD3,0x36,0xDF,0xF1,0x8C,0x5B,0x84,0x93,0x79,0xBB,0x35,0x5C,0x26,0xA9,0xEC,0x6B,0xCF,0x70,0xB8,0x87,0xBA,0x68,0x3F,0x5D,0x4B,0xA1,0x29,0xB6,0xF9,0xB6,0xAD,0x69,0xB1,0x48,0x5B,0x1B,0x23,0x50,0x84,0x72,0x17,0x91,0x0D,0x00,0x06,0x38,0xAE,0xD2,0x03,0xA3,0xAC,0x59,0x4D,0xDD,0x9D,0xAE,0xA2,0x16,0x63,0x37,0xEB,0xBA,0x8B,0x51,0x36,0x63,0x1A,0x9E,0x6B,0x7A,0x65,0x80,0x55,0xB7,0x3D,0x10,0x81,0x0C,0x58,0x60,0x75,0xCD,0x98,0x84,0xF9,0xA6,0xBD,0xF4,0xAD,0x5C,0x43,0x19,0x46,0x58,0xB4,0x7C,0xE7,0x27,0x7D,0x3D,0x0A,0xBB,0x87,0xDD,0xF8,0xC7,0xFF,0xFF,0x01};
//const uint8_t spAT[] PROGMEM = {0xAD,0xA8,0xC9,0xB5,0xBC,0xA6,0xDC,0xFE,0x36,0xB7,0xB9,0xF5,0x6D,0xC7,0x58,0x9B,0x69,0xF9,0x4C,0x99,0x73,0xDD,0xC8,0x24,0x42,0xB9,0x8B,0xC8,0x06,0x00,0x50,0xC0,0x52,0x2E,0x0E,0xB8,0x66,0x8A,0x01,0xAD,0x95,0x20,0x20,0x3A,0xF2,0xFF,0x07};
//const uint8_t spRED[] PROGMEM = {0x6A,0xB5,0xD9,0x25,0x4A,0xE5,0xDB,0xC5,0x4F,0x6D,0x88,0x95,0x2D,0xD2,0xB4,0x8F,0x2E,0x37,0x0E,0x33,0xCF,0x7E,0xAA,0x9A,0x5C,0xC3,0xB4,0xCB,0xA9,0x86,0x69,0x76,0xD3,0x37,0xB7,0xBE,0xCD,0xED,0xEF,0xB4,0xB7,0xB0,0x35,0x69,0x94,0x22,0x6D,0x10,0x28,0x42,0xB9,0x8B,0xC8,0x06,0x00,0x50,0xCF,0x0E,0xEE,0x62,0xEA,0xA6,0xBC,0xC3,0x14,0xBB,0x4A,0x9F,0xFA,0xA5,0xAF,0x25,0x13,0x17,0xDF,0x9C,0xBF,0xFF,0x07};
//const uint8_t spALL[] PROGMEM = {0x65,0x0D,0xFA,0x3B,0x84,0xFB,0x8D,0x2E,0xB1,0x9D,0x34,0xCA,0xBA,0xAB,0x5D,0xEC,0x62,0x15,0x89,0x5F,0xA7,0x49,0xB6,0x5D,0xEF,0x6E,0x0E,0x73,0x99,0xEB,0x3C,0xCA,0x11,0x65,0xCE,0x18,0xB9,0x89,0x67,0xBC,0xDC,0x15,0xF8,0xE5,0xA0,0xE6,0x71,0x77,0x94,0x51,0x8F,0x96,0xE6,0xFF,0x01};
//const uint8_t spCANCEL[] PROGMEM = {0x01,0x98,0x29,0xC4,0x00,0xDD,0x29,0x9C,0xAC,0x25,0xD7,0xD2,0x9C,0x7C,0x8B,0x5B,0xAE,0xBC,0x26,0xB3,0x94,0x89,0x52,0xF2,0xE6,0x29,0x42,0x52,0x53,0x28,0xAA,0xC1,0xB6,0xB0,0xC4,0x0C,0xF8,0xDE,0xC2,0x02,0x1E,0xF0,0x80,0x05,0x46,0x5C,0x78,0x45,0x25,0xE5,0x19,0x53,0x45,0x93,0xE3,0xA2,0x77,0xAE,0x75,0x4B,0x67,0x92,0xD5,0x6D,0x98,0x25,0x3F,0xF9,0xFD,0x7F};
//const uint8_t spPHASE[] PROGMEM = {0x22,0x5E,0x2E,0xD5,0xC4,0x64,0xA5,0xF6,0x9A,0x52,0x26,0xF1,0xB6,0xDA,0xEA,0x54,0x2C,0x6B,0xCE,0x69,0x7A,0x0A,0x51,0x89,0xB7,0xA7,0x19,0xA9,0x98,0xCD,0xDE,0xDC,0xE6,0x36,0xAB,0x9B,0xA1,0x11,0x23,0x3E,0xCF,0xB1,0xAF,0x7D,0xAB,0x7B,0x3C,0xFC,0x19,0x9E,0xA6,0x55,0x9C,0x6D,0xB7,0x7F,0xEC,0xCB,0x80,0xEF,0xCB,0x39,0x40,0x81,0xFF,0x07};
//const uint8_t spNOR[] PROGMEM = {0xE9,0x38,0x5C,0x84,0x33,0xBD,0x8E,0xB6,0x9A,0x70,0x09,0x6B,0xBB,0x8B,0x93,0x66,0xDE,0x91,0xC9,0xFE,0x6E,0xBA,0xB2,0x24,0xAA,0x26,0x51,0xDD,0xCC,0x47,0x1D,0x7C,0x75,0x3A,0xE5,0x99,0xC3,0x5C,0xCA,0x1E,0x52,0x6A,0xA7,0xE4,0xCF,0x7B,0xB9,0x53,0x4E,0x8E,0x31,0x6F,0xFD,0x4C,0x77,0x1A,0xC2,0x93,0x96,0x25,0xDD,0xA9,0x04,0x4E,0x87,0xDB,0xF0,0xE4,0x2D,0xB4,0x6E,0x59,0xE2,0xE3,0xDF,0xFF,0x07};
//const uint8_t spEXIT[] PROGMEM = {0x6B,0x68,0xC1,0x24,0xAD,0xEE,0xAC,0xA6,0xE7,0x66,0x57,0x7F,0x73,0x9B,0x5B,0xB6,0xA2,0x1F,0x56,0xC5,0x69,0x6A,0xDA,0x96,0x94,0x02,0xB2,0x89,0x02,0x9A,0x1C,0x35,0xC0,0xCF,0x99,0x16,0xB0,0x80,0x04,0xDA,0x5C,0x83,0x4A,0xF0,0xDC,0x5E,0x5B,0x33,0x49,0xA1,0xFE,0xB9,0x9F,0xE1,0x6B,0x41,0x39,0xD8,0x1E,0x23,0x50,0x84,0x72,0x17,0x91,0x0D,0x00,0x02,0x38,0xCC,0xDC,0x02,0x04,0x18,0xF6,0xF3,0xFF,0x01};
//const uint8_t spFLOW[] PROGMEM = {0x04,0xE8,0x3E,0x83,0x02,0x1C,0xE0,0x80,0x04,0x3C,0x10,0xB2,0x24,0x75,0xD9,0xAC,0x4D,0xCD,0x5A,0x9D,0x85,0xAC,0x93,0x79,0x39,0x75,0xA3,0xDE,0x15,0x98,0xED,0x56,0xB7,0x5A,0x55,0xE2,0xD3,0xE9,0xE4,0x6F,0xD6,0xB3,0x9B,0x43,0x5F,0xEB,0x91,0x4F,0x77,0x5B,0xBB,0x15,0xC2,0x7E,0xFC,0x63,0x5E,0x1B,0xD7,0x0B,0xA5,0xB7,0x7E,0xFF,0x1F};
//const uint8_t spGAUGE[] PROGMEM = {0x0E,0x18,0xD5,0xB0,0xB5,0x2B,0x24,0x09,0x7B,0x92,0x55,0xF7,0x4C,0xA2,0xD1,0x8D,0x6F,0x7D,0x9A,0x91,0x83,0x34,0x72,0xCE,0x6D,0x6E,0x73,0xDB,0xD5,0xCD,0x50,0x40,0x9D,0xAB,0xF7,0xB8,0xE7,0xBD,0xB5,0x7D,0xA5,0x46,0x8C,0x58,0x5D,0x0F,0x76,0x15,0x05,0xBE,0x96,0x8D,0xD8,0x59,0x0D,0xE8,0x58,0xD5,0xA2,0x97,0x7A,0xC6,0x72,0x17,0x31,0x5B,0xB2,0x65,0xC0,0x9A,0xCE,0x12,0xB0,0x80,0x02,0xE6,0x50,0xF9,0x7F};
//const uint8_t spGREEN[] PROGMEM = {0xE1,0x6A,0xEA,0x2A,0x4A,0xE3,0xA6,0xA1,0xB8,0x49,0x32,0x51,0x9A,0xFA,0xE8,0xCC,0xAC,0x2C,0x59,0xED,0x5A,0x5B,0x3A,0x05,0x27,0x77,0x9D,0xF5,0x29,0xDA,0x70,0x91,0x90,0xB6,0xA7,0x18,0x35,0x90,0xD3,0x17,0xED,0x7C,0xE5,0x33,0x06,0xE2,0x54,0xA5,0x5D,0xCC,0xAA,0xF5,0xB3,0x07,0x50,0xD6,0xA8,0x36,0x8E,0xA0,0x68,0x6B,0x61,0xFA,0x52,0xB7,0xB2,0x8F,0x44,0x54,0x15,0x41,0xD2,0x31,0x12,0x86,0xB8,0xBB,0xCE,0x67,0xBA,0xAA,0x66,0x4B,0xF1,0xB8,0xE9,0xEA,0x91,0x43,0xCC,0x5C,0xC7,0x33,0x5E,0xE5,0x6A,0xD6,0x25,0xDC,0x67,0xA5,0xA7,0x55,0x0D,0xD5,0x98,0x9C,0xDF,0xFF,0x07};
//const uint8_t spINSPECTOR[] PROGMEM = {0x29,0xEB,0x5E,0xD9,0x32,0x27,0x9D,0x6E,0xFA,0x66,0x17,0x59,0x7D,0xDB,0xDB,0xB4,0xB6,0x7B,0xD0,0xCC,0x70,0xD2,0xDB,0xD6,0x0D,0xC7,0x38,0xAC,0x4D,0xD2,0xF0,0x0D,0xB3,0xA9,0xBB,0x73,0xC0,0x4F,0xE9,0x11,0xF0,0x80,0x02,0x86,0x52,0x01,0x03,0x44,0xEA,0x7A,0xA2,0x1A,0x43,0xD3,0x6C,0xF3,0x4D,0x6F,0xDA,0xB2,0x56,0x0C,0x82,0xAD,0x31,0x29,0x44,0x28,0x77,0x11,0xD9,0x00,0xE0,0x80,0xED,0x3C,0x46,0x5F,0xEB,0xA0,0xB4,0xF8,0x2D,0x53,0xF5,0x27,0xB0,0xEC,0x3F,0x6F,0x69,0x2F,0xB1,0x50,0x4E,0xF2,0x86,0xB3,0x86,0x13,0x18,0xF5,0x17,0xDF,0xF0,0x96,0x65,0x58,0xC9,0x59,0xFC,0xF7,0xFF};
//const uint8_t spMANUAL[] PROGMEM = {0x6E,0x8A,0x42,0x6C,0xD5,0x9A,0xA4,0xB1,0x72,0xA5,0x2A,0x49,0x5B,0x87,0xD3,0x75,0x5B,0x1A,0x2E,0xAB,0x6F,0x7D,0xAB,0x53,0x76,0xDF,0x12,0xE6,0xAF,0x6F,0x71,0x8A,0x1E,0x43,0x52,0x72,0xF1,0x2A,0x7A,0x24,0x4D,0x4E,0xD7,0xA5,0x6A,0x06,0x32,0x2D,0x34,0x8F,0x7A,0x24,0x12,0x97,0x4E,0xB8,0xFA,0xE1,0x1D,0xD5,0xB3,0xE1,0x1A,0x7A,0x0D,0x12,0xB5,0xD5,0x6B,0xAC,0x51,0x24,0xD4,0x56,0x97,0x25,0x5A,0xB3,0x32,0x59,0x93,0xB6,0xA8,0x27,0x3C,0x31,0x4F,0xDE,0xEB,0x5E,0xCF,0x72,0x26,0x3E,0xD5,0xC6,0xF9,0xCA,0x55,0x71,0x77,0x39,0x7B,0x2B,0xD7,0x40,0xD1,0x1D,0xAC,0xBD,0xDC,0x05,0x57,0x77,0x90,0xB7,0xFC,0xFC,0x3F};
//const uint8_t spMOVE[] PROGMEM = {0x6A,0xD7,0xC2,0xF2,0xD2,0xEC,0xB8,0x39,0x08,0xF6,0x4D,0x4D,0x1A,0xC6,0x24,0x31,0xB2,0xCC,0x69,0x1E,0x56,0x9D,0x85,0x7B,0x15,0xA4,0x3B,0x55,0x23,0x9E,0x3E,0xE0,0x6D,0xE7,0x23,0xAF,0x20,0xC6,0x0A,0xBC,0xCE,0xA2,0x34,0x91,0x6C,0x89,0x43,0xDF,0x3A,0x94,0x31,0x83,0x6E,0x4D,0xE8,0x9A,0x96,0x0C,0x3A,0x63,0x20,0x5B,0xD8,0xAC,0xEC,0xC8,0x20,0x37,0x7E,0xB7,0xA7,0x3D,0xCD,0xD9,0x8A,0x78,0x28,0x2E,0xB5,0x97,0xBD,0xED,0xCD,0x80,0x52,0x32,0x28,0x80,0x81,0xFF,0x07};
//const uint8_t spOVER[] PROGMEM = {0x63,0x6F,0xC4,0x7A,0x1D,0xB5,0xED,0x61,0x37,0xBB,0x6E,0x75,0x62,0xD9,0x2D,0xEC,0xBF,0x56,0xAD,0x09,0xBA,0x32,0x8C,0x13,0xC7,0xD6,0xED,0x4D,0x85,0x86,0x99,0xE3,0x3E,0xB7,0x29,0x86,0x90,0x2C,0x76,0xDB,0xE6,0x98,0x95,0xBB,0x38,0x4F,0x5B,0x72,0x29,0xB4,0x51,0x6F,0x7D,0xAF,0x47,0xB9,0x73,0x71,0x8C,0x31,0x3F,0xE1,0xC9,0xA9,0x50,0xD6,0xFD,0xBA,0x27,0x57,0xC5,0x6E,0xCD,0xFD,0xFF};
//const uint8_t spPLUS[] PROGMEM = {0x0A,0x18,0x4D,0x44,0x01,0x23,0x70,0x12,0x40,0x8B,0xD8,0x92,0x7A,0xD3,0x63,0x10,0xAD,0x57,0x91,0xC4,0xB5,0x8A,0xAE,0x39,0x45,0xE1,0x93,0xE9,0xBC,0xE5,0x96,0xB7,0x59,0x43,0x15,0x63,0xE9,0xBA,0x6B,0x6E,0xF5,0x64,0x40,0xF0,0xEE,0x0A,0xF8,0x25,0x43,0x03,0x1E,0xD0,0x80,0x04,0x38,0x40,0x01,0x0C,0xFC,0x3F};
//const uint8_t spPULL[] PROGMEM = {0x06,0xF0,0xB6,0x9C,0x01,0x2C,0xB7,0x8F,0x28,0xCA,0x1E,0x53,0x5A,0xBA,0x93,0x95,0x0C,0x2C,0xD3,0x81,0xDA,0x76,0xBA,0xB3,0x51,0x57,0x14,0xB3,0x8E,0xEE,0x67,0xDF,0x87,0x34,0x17,0xE2,0x3B,0x86,0x5E,0xEB,0x11,0xCE,0x24,0x62,0xD3,0xB0,0x69,0xBE,0xFD,0xE3,0xDE,0x20,0x67,0x54,0xA5,0xCD,0xFF,0x03};
//const uint8_t spREPEAT[] PROGMEM = {0x6E,0xF1,0x49,0x42,0x33,0xD8,0xC5,0xB9,0x8C,0xB9,0x62,0x8A,0x87,0xF6,0xD3,0xB7,0xCC,0xC6,0x1A,0xE9,0x4E,0x33,0x9C,0x23,0x79,0x7C,0xDE,0x4D,0x6B,0x5B,0x62,0xB0,0xF4,0x95,0x64,0x16,0xA1,0xDC,0x45,0x64,0x03,0x04,0xA0,0xB5,0x94,0x96,0xF6,0x14,0x4C,0x62,0xAF,0x4E,0xD6,0x13,0x93,0x66,0xCD,0x3E,0xD9,0x6C,0x89,0x64,0xB1,0xFA,0x66,0xBB,0x18,0xFD,0xAC,0x0A,0x92,0xB5,0xA8,0xAD,0xA3,0x10,0x8B,0x4D,0x6D,0x7B,0x21,0x50,0x84,0x72,0x17,0x91,0x0D,0x00,0x06,0xB8,0xDC,0xCD,0x01,0x33,0x6C,0x62,0x00,0x03,0xFF,0x0F};
//const uint8_t spSHUT[] PROGMEM = {0x04,0x58,0xE3,0x5A,0x03,0x16,0xF0,0x80,0x07,0x22,0x60,0x81,0x55,0xB4,0xE4,0xA2,0x61,0x5D,0x6E,0x71,0xCA,0x12,0x3C,0xCA,0x7C,0xCE,0xAD,0x76,0x31,0xD7,0xBC,0x23,0x50,0x84,0x72,0x17,0x91,0x0D,0x00,0x06,0xE8,0x44,0x5D,0x01,0x3F,0x66,0x11,0xE0,0x98,0x59,0x04,0xF4,0x38,0xFE,0xFF};
//const uint8_t spTEST[] PROGMEM = {0x0E,0x98,0x6A,0xC9,0x00,0x2B,0x37,0xAF,0xA4,0x45,0x91,0xB0,0x5A,0x72,0xEA,0x9A,0x9D,0x23,0xE3,0xCD,0x6D,0x56,0x57,0x93,0x5A,0x78,0x2D,0xD9,0xE3,0x9E,0xEB,0x4E,0x77,0x02,0x6C,0x95,0x4A,0x80,0xDF,0xD2,0x39,0xA0,0x01,0x0D,0x48,0x80,0x01,0x4F,0x2B,0x53,0x00,0x14,0x70,0x45,0x9A,0x06,0x10,0x50,0x73,0xC3,0xFF,0x03};
//const uint8_t spVOLTS[] PROGMEM = {0xA0,0xDA,0xA2,0xB2,0x3A,0x44,0x55,0x9C,0xFA,0xB0,0xBA,0x46,0x72,0xDA,0xD1,0xDB,0xAE,0x47,0x59,0x61,0xED,0x28,0x79,0xED,0x45,0xAF,0x5A,0xDF,0x60,0xF4,0x39,0x69,0xAB,0x63,0xD9,0x3B,0xD2,0xBC,0x24,0xA5,0xF5,0xB6,0x0F,0x80,0x01,0x3E,0x63,0x65,0xC0,0x5F,0x63,0x12,0x90,0x80,0x06,0x24,0x20,0x01,0x0E,0xFC,0x3F};
//const uint8_t spGALLONS[] PROGMEM = {0x0E,0x28,0x8A,0xE5,0xB4,0xAD,0x04,0x9B,0xF9,0x9A,0x5B,0x9F,0xBA,0xE9,0x91,0x4A,0x5D,0x7D,0xAB,0x53,0x15,0x35,0xBE,0xA2,0x8B,0x77,0x35,0xEA,0xCC,0xC6,0x4F,0xA9,0x6E,0x6B,0x07,0xC8,0xEC,0x45,0xCF,0x6B,0x2C,0xA2,0x7C,0x4D,0x36,0xCF,0x65,0xAC,0x8D,0x97,0xB6,0xE9,0xE2,0x7A,0x86,0x7B,0x44,0xD4,0xB0,0x54,0x1A,0xEE,0xA6,0x51,0x32,0xC2,0xA9,0x7F,0xCC,0xD3,0x2D,0xA3,0xA7,0xC4,0xB7,0xAF,0x7E,0xE4,0xE7,0xBE,0xAF,0x4D,0x54,0x53,0x19,0x03,0xBE,0x60,0x62,0xC0,0xAF,0xAE,0x12,0x90,0x00,0x02,0x6A,0x70,0xFE,0x7F};
//const uint8_t spHERTZ[] PROGMEM = {0x04,0xC8,0xA1,0xD8,0x02,0x1E,0x58,0x71,0x2E,0x81,0x31,0xDC,0x65,0x25,0xD5,0x9E,0xC2,0x9A,0xFE,0x9D,0xED,0x7A,0x8E,0x61,0xAD,0x25,0xC1,0x4A,0xF3,0x01,0x00,0x02,0xB6,0x09,0x65,0xC0,0x6F,0x65,0x1C,0xB0,0x80,0x05,0x34,0xE0,0x01,0x0D,0x10,0xA0,0x09,0x97,0xFF,0x07};
//const uint8_t spMICRO[] PROGMEM = {0x22,0x8B,0x44,0xF5,0x92,0x9B,0xDA,0xC5,0xCF,0x6B,0xA8,0xBC,0x2B,0x8B,0xB3,0xDC,0xEE,0xB6,0xA7,0x6E,0x3E,0xB9,0xC2,0x56,0x9F,0xA2,0x57,0x93,0xD0,0x9C,0x5D,0x8A,0x3E,0x88,0x52,0xA6,0x32,0x2B,0xAA,0x15,0x34,0xCB,0xD4,0xC0,0x80,0x12,0x23,0x22,0x60,0x81,0x30,0xC5,0xAA,0x61,0x25,0xF9,0x7A,0xDF,0x87,0x31,0x17,0xDE,0x1E,0xC5,0xFE,0xDB,0x96,0xD5,0xD8,0x38,0xF4,0xAB,0x47,0x78,0xBC,0xAB,0x18,0xE1,0x3C,0xFE,0xF5,0xDF,0xFF,0x03};
//const uint8_t spOHMS[] PROGMEM = {0xAD,0xC9,0x74,0x37,0x59,0xD2,0xED,0xE6,0xD4,0x95,0xF8,0x56,0xB0,0xD2,0x5D,0x9D,0xAA,0x12,0xAF,0x2D,0xB7,0xBA,0xDB,0xDE,0xB7,0x79,0x68,0x93,0x32,0x96,0xD2,0x97,0xBA,0xE6,0x3D,0x9F,0xEE,0x6A,0x92,0xB9,0x22,0x9C,0x98,0x2B,0x33,0x8E,0x16,0x8F,0xEB,0xEE,0x6E,0xD1,0x5A,0x3C,0x4D,0xB8,0x06,0x09,0x35,0xA5,0xDE,0xE1,0xFA,0xC5,0xD8,0x4D,0xE4,0x2A,0xE0,0x5B,0x15,0x05,0x7C,0x27,0xA4,0x01,0x0E,0x70,0x00,0x01,0xDE,0x6C,0xFE,0x3F};
//const uint8_t spAREA[] PROGMEM = {0x2D,0xEF,0xA1,0xC8,0x32,0x36,0xDF,0xE5,0x0C,0xDD,0x0D,0xCB,0x68,0xDF,0xDB,0xAC,0xBA,0x0C,0xB1,0x32,0xED,0x3A,0xAA,0xD4,0x39,0x2C,0x4D,0xEF,0xAC,0x67,0xB3,0xFA,0xD2,0x58,0xD3,0x3D,0xEF,0x1A,0xBA,0x2B,0xD0,0xF2,0xDD,0x73,0x1E,0x4B,0xF7,0x89,0xE6,0xF1,0x79,0xAF,0x63,0xED,0x3E,0xD8,0xDD,0x3E,0x8F,0xAD,0x3A,0xF7,0x76,0x5D,0xD3,0xB7,0xBE,0xB7,0xBB,0xE9,0xB4,0x4E,0xE9,0x5D,0x3F,0xF7,0xA7,0x1C,0x9E,0xEA,0x4B,0xFE,0x1F};
//const uint8_t spCIRCUIT[] PROGMEM = {0x02,0x78,0x2D,0x55,0x02,0x12,0xB0,0x80,0x01,0x5E,0x49,0x5D,0x49,0x35,0xAE,0x1A,0xD6,0xF6,0x94,0x25,0x05,0x5B,0x4A,0xD7,0x55,0x94,0x3C,0x28,0x2D,0xFE,0x76,0x11,0xCA,0xEA,0x06,0x25,0x35,0x29,0x02,0x45,0x28,0x77,0x11,0xD9,0x08,0x28,0x4E,0x15,0x1C,0x50,0x1C,0xD3,0xEA,0x6A,0x14,0x49,0xF7,0x4D,0x7B,0x19,0x67,0x53,0x45,0x65,0xB1,0xA7,0x3E,0x08,0x14,0xA1,0xDC,0x45,0x64,0x03,0x80,0x00,0x96,0x56,0x53,0xC0,0x1F,0xAD,0x02,0x78,0xAE,0x06,0x01,0xCB,0xB7,0xFF,0x3F};
//const uint8_t spCONNECT[] PROGMEM = {0x06,0xA8,0xD5,0x29,0x24,0x3D,0xAC,0xB3,0x52,0xE6,0x55,0x97,0xA0,0x56,0x12,0x8D,0x4F,0xDB,0x9C,0x6A,0x4B,0x2C,0x2D,0xDD,0xC8,0xA8,0xEE,0xE9,0xB4,0xF6,0xAB,0x6B,0x4E,0xB5,0x28,0x93,0xAC,0xB6,0xC5,0x66,0x4F,0xDB,0x7C,0xBB,0xDB,0xEF,0x69,0x9E,0xE5,0x69,0xA1,0x39,0x3C,0x96,0x20,0x50,0x84,0x72,0x17,0x91,0x0D,0x00,0x20,0x80,0xA5,0xC3,0x1C,0xB0,0xEC,0x97,0x05,0x18,0xD0,0xCB,0xDA,0xFF,0x03};
//const uint8_t spSECONDS[] PROGMEM = {0x04,0xF8,0xC5,0x51,0x01,0xBF,0xA6,0x6A,0x40,0x03,0x16,0xD0,0xC0,0xCA,0xAB,0x75,0x2D,0xCD,0x25,0x37,0xBB,0xD9,0xCA,0xDA,0x54,0x0F,0xEE,0xD9,0x29,0x6B,0x47,0x30,0xD8,0xE3,0x80,0x00,0x6A,0x26,0x6D,0x55,0xEB,0xCA,0x21,0xB9,0xE4,0xD4,0xDD,0x26,0xA5,0xF9,0xE3,0x3D,0xB6,0x75,0x38,0xA3,0x31,0x5B,0x9A,0xB6,0x11,0x51,0x32,0xD2,0xAA,0x3F,0xFC,0x21,0xCE,0x22,0xD1,0xD7,0x2D,0x9E,0x39,0x0B,0x37,0x4E,0xD7,0x26,0xE1,0xFA,0xC4,0x55,0x42,0xFD,0x85,0xFB,0x7B,0x77,0x13,0xA3,0x27,0x80,0x03,0xD0,0x25,0x20,0x01,0x0A,0x20,0x20,0x69,0xD6,0xFF,0x07};
//const uint8_t spUNIT[] PROGMEM = {0x61,0xB9,0x96,0x84,0xB9,0x56,0xE5,0xB9,0xCE,0x63,0xDE,0xCE,0x0D,0x30,0x36,0x9F,0x6E,0x86,0x36,0x60,0xE9,0x7B,0xCA,0x5E,0x93,0x45,0xA4,0xEB,0xC9,0xBB,0x77,0x72,0xE7,0x2D,0x2B,0xAB,0xD6,0x24,0x94,0x17,0x8F,0xA2,0x79,0x4C,0xD5,0x48,0x5D,0xAA,0xEE,0x21,0x23,0x42,0xF1,0x1A,0x66,0x54,0x15,0x97,0xD6,0x6B,0x19,0xD1,0xC5,0xC5,0x77,0xEF,0xB3,0x9F,0x7E,0x47,0xA0,0x08,0xE5,0x2E,0x22,0x1B,0x00,0x01,0xCB,0xBB,0x3B,0xE0,0xD7,0x0A,0x05,0x9C,0xD0,0x4D,0x80,0xE6,0x92,0xFE,0x1F};
//const uint8_t spTIMER[] PROGMEM = {0x0E,0xB8,0x36,0xC3,0x01,0xCD,0x98,0xB4,0x38,0x87,0x8C,0x0A,0x59,0x72,0x8B,0x5B,0x9D,0xAA,0x15,0x35,0x0B,0x9F,0x7D,0x8B,0x5D,0xB4,0xAA,0x78,0x96,0xB4,0xB0,0x5B,0xFB,0x32,0xE7,0xE8,0x9C,0x85,0x6D,0xDA,0x96,0xC3,0x10,0x9F,0x78,0x49,0x67,0x35,0xA7,0xF0,0xA6,0x2F,0xDD,0x39,0x2D,0xF2,0x89,0x9F,0xFC,0xC4,0xD7,0xFD,0xC5,0x1F,0xC3,0xBA,0x3F,0xF3,0x97,0x6D,0x54,0xC9,0xFD,0xFE,0x1F};
//const uint8_t spUP[] PROGMEM = {0x2D,0xCD,0x72,0xA2,0x55,0x77,0xDD,0xF6,0x36,0xB7,0xB9,0xD5,0xEA,0xB3,0xC9,0x6C,0xF1,0xD5,0xE9,0x4A,0xB6,0xBD,0x39,0x7F,0x21,0x50,0x84,0x72,0x17,0x91,0x0D,0x00,0x20,0x80,0x48,0xD3,0x08,0x90,0x54,0x28,0x06,0xFE,0x1F};
const uint8_t spIS[] PROGMEM = {0xAD,0xED,0xD5,0x58,0xA4,0x9E,0xCE,0x76,0xF5,0xDD,0xAB,0x29,0xF5,0xD2,0xDD,0xEF,0x7E,0x0C,0xC3,0xA9,0x06,0xFA,0xD3,0x32,0x0F,0x6E,0x94,0x22,0x8F,0xF3,0x92,0xF6,0x05,0x43,0xCC,0x74,0x77,0x3E,0xC3,0xF5,0x95,0x98,0xA9,0xBA,0x8B,0x8F,0x00,0x7E,0x73,0xE5,0x00,0x05,0x28,0xF0,0xFF};
//const uint8_t spALERT[] PROGMEM = {0xA5,0xCF,0xC6,0xAB,0x55,0x5B,0xAF,0x39,0xDA,0xC9,0x54,0xDD,0xBC,0xC6,0xC2,0x3C,0x27,0x20,0xCF,0x1C,0xD7,0x30,0xB0,0x45,0x16,0x69,0x1D,0xC3,0x11,0xE4,0x59,0x8A,0x7C,0xB5,0x9B,0x8B,0xD9,0x30,0xB7,0xD3,0x76,0x19,0x9A,0x25,0x59,0x57,0x59,0xEC,0x11,0xAF,0xE8,0xD9,0xF9,0x2A,0x8A,0x1D,0xF0,0x75,0x3F,0x73,0xAC,0x87,0x3B,0xA2,0x0B,0xAA,0x2B,0xCF,0xE4,0x10,0xA1,0xDC,0x45,0x64,0x03,0x00,0x80,0x01,0x66,0x36,0x33,0xC0,0xAB,0xD5,0x0A,0x68,0x25,0x85,0x02,0xFF,0x0F};
//const uint8_t spADJUST[] PROGMEM = {0xAD,0xAD,0xA1,0xD5,0xC4,0x5A,0x9F,0xB1,0xFA,0x14,0xB3,0x78,0xBC,0x87,0x31,0x55,0x9B,0xEC,0xC2,0x6B,0xC4,0xE6,0xB9,0xDB,0xB8,0x97,0x24,0x87,0xA6,0x99,0x59,0x61,0x4B,0x1C,0x05,0x63,0x56,0x79,0x6C,0x05,0x4C,0xC5,0x14,0x81,0x35,0xB4,0x98,0xAC,0xAE,0x7D,0x6E,0x77,0xAA,0xE2,0xD2,0x5A,0x63,0xD5,0xAD,0x6E,0xBD,0xBA,0xE2,0xD3,0x8A,0xAB,0xF2,0x1C,0x15,0x50,0x41,0x8A,0x03,0x7E,0x29,0xF1,0x80,0x05,0x2C,0xA0,0x01,0x01,0xFC,0xD6,0x2A,0x01,0x60,0xC0,0x0B,0xEC,0x16,0x60,0x40,0xB7,0x63,0xFF,0x0F};
//const uint8_t spBETWEEN[] PROGMEM = {0xA2,0xED,0xD9,0x59,0x4C,0xFB,0xEC,0xE2,0x0C,0x33,0x34,0x83,0xD9,0x96,0x3B,0x8E,0x69,0xC6,0x15,0x14,0xDA,0x03,0xE0,0x80,0x6E,0xCD,0x03,0xD0,0xE3,0xB8,0x02,0x72,0x48,0x2B,0x45,0xB0,0xE9,0x69,0x12,0x77,0x55,0x99,0xA7,0x57,0x42,0x93,0x53,0x74,0x19,0xE6,0x89,0x6B,0x4E,0x39,0x82,0xB3,0xA6,0x3E,0x3A,0xE5,0x2C,0x81,0x5C,0x59,0xE9,0xD6,0xAB,0xEB,0x81,0x31,0x27,0xCA,0xCC,0xA5,0x6F,0x65,0x1B,0x09,0x5D,0x3D,0xDC,0xD4,0x23,0x9F,0xE9,0xA9,0x8A,0xB4,0xDD,0x92,0xFC,0x3F};
//const uint8_t spMINUTES[] PROGMEM = {0x61,0xCA,0xCC,0x38,0x5B,0x9A,0xE6,0xA9,0xB6,0xA7,0xEC,0x2A,0xC5,0xDD,0x17,0xDF,0xE2,0xE6,0x23,0x6B,0x16,0xC3,0x2D,0x92,0xCC,0x72,0xB5,0xD5,0xBA,0x86,0xD5,0xEC,0xB9,0x94,0xAD,0x98,0x90,0xF4,0x79,0x14,0xDE,0x8E,0x53,0x3C,0x63,0x23,0x02,0x45,0x28,0x77,0x11,0xD9,0x00,0x80,0x80,0xCF,0x58,0x05,0xF0,0x7B,0x99,0x04,0x38,0xC0,0x01,0x0A,0x50,0xE0,0xFF,0x01};
//const uint8_t spBUTTON[] PROGMEM = {0x10,0xA6,0x28,0xDD,0xCD,0x2D,0xD5,0x6A,0x8B,0xEE,0x6C,0xB1,0x4D,0xA7,0xAC,0x2E,0xA3,0x44,0x97,0xDC,0xA6,0xF5,0xCD,0x6B,0x34,0x46,0x13,0x32,0x89,0x50,0xEE,0x22,0xB2,0x01,0x20,0xA5,0xDD,0xA1,0x94,0xBB,0xB3,0xB6,0x0C,0x2F,0xA4,0xE6,0xF1,0xFA,0x96,0x8F,0x70,0x8F,0xC2,0x2A,0xE6,0x4A,0xDD,0xD3,0x2D,0x51,0x7A,0xDA,0xF3,0xAF,0x7B,0x47,0x63,0x51,0x73,0x67,0xE1,0x6B,0x46,0xDD,0x49,0xEB,0xFE,0x3F};
//const uint8_t spCLOCK[] PROGMEM = {0x06,0x48,0x65,0x34,0x00,0x93,0xA7,0x5B,0xA0,0xA4,0x95,0xBA,0x5F,0x82,0x9B,0x95,0x07,0x37,0x55,0x24,0x4D,0x4E,0x51,0xE9,0x54,0x25,0x76,0xB9,0xE5,0x2D,0x4F,0x93,0x7D,0xE5,0x98,0xAE,0xDE,0x63,0x3B,0x72,0xC9,0x2C,0x8E,0xD9,0xF1,0x41,0xA0,0x08,0xE5,0x2E,0x22,0x1B,0x00,0x40,0x00,0x35,0x0D,0x69,0x80,0x02,0xFF,0x0F};
//const uint8_t spDEVICE[] PROGMEM = {0x64,0x8E,0x38,0x3C,0x4B,0x62,0x8F,0x7D,0x89,0x14,0xD4,0xCC,0xB5,0x86,0x11,0x9A,0xD1,0xB5,0xCF,0x1C,0xDC,0xDC,0xA5,0x23,0xB5,0x3B,0xCB,0x73,0x9D,0x46,0x99,0x6D,0x59,0x35,0xE5,0xD9,0xF5,0x69,0xAA,0x1E,0xCB,0xE2,0xCD,0xB7,0xB9,0xDD,0x19,0xAA,0x2F,0xE9,0xD0,0xD5,0x7B,0x69,0x57,0xF3,0x49,0x1E,0xF1,0x28,0xDE,0x0C,0xB8,0x36,0x54,0x00,0xBF,0x55,0x6A,0x40,0x03,0x1A,0xE0,0x00,0x07,0x28,0xF0,0xFF};
//const uint8_t spEAST[] PROGMEM = {0xAD,0x1D,0x59,0x50,0xBC,0x17,0x8F,0x7A,0x96,0x02,0x8C,0x7C,0xB2,0xEB,0x5D,0xCD,0x7A,0x0C,0x63,0x10,0x71,0xCC,0xEC,0x3E,0xA5,0x75,0x0C,0x41,0xF2,0x7A,0x4C,0x80,0x6F,0x67,0x24,0xA0,0x01,0x05,0xFC,0x3C,0xA5,0x01,0x0D,0x58,0x40,0x02,0x04,0xF8,0xDA,0x1C,0x03,0x1A,0x30,0xC0,0x31,0x37,0x02,0xE8,0xF5,0x8D,0x00,0xD5,0x39,0xFC,0x3F};
//const uint8_t spFAIL[] PROGMEM = {0x04,0x98,0x3E,0x8D,0x03,0x1C,0xD0,0x80,0x07,0x4A,0xBF,0x54,0x9B,0x3A,0x79,0x9C,0xCD,0xAA,0x9B,0x0F,0x31,0x8F,0x37,0xB7,0xBE,0xCD,0x6A,0x47,0x2A,0x66,0xB3,0xB7,0xB3,0xDB,0x6B,0x5F,0xC7,0x56,0x44,0x58,0x8E,0x76,0xAA,0x7B,0xD8,0x33,0xB9,0x32,0xD7,0x3C,0xF9,0x0C,0x67,0xD4,0x13,0x9E,0x98,0xC7,0x5F,0xEE,0x49,0x7C,0xAA,0x8D,0xF3,0xF9,0xF7,0xFF,0x01};
//const uint8_t spFREQUENCY[] PROGMEM = {0x04,0xA8,0x4A,0x9D,0x01,0x33,0x8C,0x71,0x40,0x02,0x1A,0x08,0x71,0x4E,0x5C,0x52,0xEA,0x7E,0x67,0x2B,0xEB,0xB5,0x98,0x82,0xB7,0xEE,0x64,0xA4,0x7D,0x18,0xB2,0xDB,0x1B,0x9B,0x22,0x50,0x84,0x72,0x17,0x91,0x0D,0x04,0xF0,0x35,0x2D,0x25,0x59,0xB9,0x57,0xCA,0xE2,0x39,0xB4,0xB1,0x69,0xB4,0xF2,0xB4,0x5B,0x97,0xB0,0x14,0x05,0x15,0x91,0x6A,0xF4,0x2A,0x80,0x5F,0x4A,0x2D,0xE0,0x01,0x0B,0x68,0x40,0x03,0x63,0x69,0x56,0xC5,0x25,0x57,0x8D,0xAD,0x27,0x63,0xB1,0x78,0xDC,0x8F,0x7E,0x95,0x6B,0xE6,0x24,0x32,0x5B,0x93,0xEE,0xD1,0x83,0x58,0xEC,0x4D,0x7E,0xE3,0xF7,0xFF};
//const uint8_t spGATE[] PROGMEM = {0x0C,0x08,0xDA,0x75,0x2C,0xB3,0x27,0x19,0xBB,0xDD,0xD1,0xB7,0x44,0xE4,0x51,0x73,0x4E,0x3D,0x7A,0x90,0x49,0x2C,0xB9,0xE5,0xAD,0x6E,0xB5,0xBA,0x99,0x0A,0x24,0xE3,0xF1,0x1E,0xFA,0x1E,0xEE,0x31,0x13,0x59,0xE3,0x8D,0xFA,0x47,0x21,0x32,0xAF,0xC7,0x08,0x14,0xA1,0xDC,0x45,0x64,0x03,0x00,0x38,0x60,0x89,0x52,0x03,0x6C,0xF3,0xC3,0x80,0xDE,0xD7,0x08,0x50,0x8D,0xE1,0xFF,0x03};
//const uint8_t spHIGH[] PROGMEM = {0x04,0xC8,0x7E,0x9C,0x02,0x12,0xD0,0x80,0x06,0x56,0x96,0x7D,0x67,0x4B,0x2C,0xB9,0xC5,0x6D,0x6E,0x7D,0xEB,0xDB,0xDC,0xEE,0x8C,0x4D,0x8F,0x65,0xF1,0xE6,0xBD,0xEE,0x6D,0xEC,0xCD,0x97,0x74,0xE8,0xEA,0x79,0xCE,0xAB,0x5C,0x23,0x06,0x69,0xC4,0xA3,0x7C,0xC7,0xC7,0xBF,0xFF,0x0F};
//const uint8_t spINTRUDER[] PROGMEM = {0xAB,0x1D,0xA9,0x88,0xCC,0x37,0x9F,0x66,0xBA,0x16,0x31,0xFE,0xBC,0xEB,0x55,0x0F,0xCF,0x98,0x69,0x55,0x47,0xD3,0x0C,0xF2,0xA4,0x45,0xAB,0x6D,0x6D,0x43,0x57,0x34,0xF8,0x78,0x34,0x45,0xA0,0x08,0xE5,0x2E,0x22,0x1B,0x14,0xD0,0x4A,0x46,0x06,0x34,0xD0,0xD2,0xEC,0x39,0xCC,0xCC,0xDD,0xCC,0x56,0x9E,0x95,0x58,0x14,0xB5,0xDB,0x45,0xAB,0xAB,0x27,0x4B,0xF6,0x74,0xA2,0x62,0xCE,0xB2,0x3C,0x66,0xB7,0x7A,0x2C,0x0B,0x61,0x95,0xBB,0x96,0x96,0x4C,0xD9,0x35,0xDB,0x98,0xAB,0x29,0xA2,0xB3,0x7C,0x73,0xED,0x47,0xBB,0x4A,0x2E,0xD0,0x71,0x3F,0xF9,0x8B,0x5F,0xF8,0x4A,0x0F,0xF4,0xD1,0x3C,0xFF,0x0F};
//const uint8_t spMEASURE[] PROGMEM = {0x66,0x71,0x52,0xED,0xD2,0x92,0x86,0x39,0x2B,0xE6,0x4E,0x8F,0x9B,0xC7,0xD1,0x17,0xA3,0x1C,0x22,0x69,0x4F,0xD7,0x73,0xA8,0x9B,0xAE,0xBE,0xF5,0xAD,0x6E,0x39,0xF2,0xEE,0x45,0xD4,0x7C,0xA5,0x01,0x1A,0x63,0x0E,0xC0,0xA8,0x81,0x11,0x18,0x7D,0x8F,0x29,0x68,0x96,0x75,0x0C,0x25,0x27,0x71,0x85,0xF7,0x39,0xCF,0x7D,0x1E,0xE5,0x2A,0x4B,0xD8,0x5B,0xF3,0xE4,0x27,0x3E,0xFE,0x75,0x7F,0x19,0x46,0xD9,0xBC,0xE5,0xFF,0x01};
//const uint8_t spNORTH[] PROGMEM = {0x66,0x8E,0x54,0xAC,0x9A,0xE7,0x84,0xA9,0x0A,0xE2,0x1C,0xAE,0x5B,0xC6,0xE6,0x51,0xCD,0x23,0xE9,0xE9,0x8B,0x71,0x77,0xD3,0xAE,0xA7,0x2A,0x22,0x3D,0x8B,0xB2,0x9E,0x32,0x8B,0xCE,0x6C,0xD6,0x76,0x8B,0x55,0x26,0xB7,0xE2,0xCB,0x7A,0x77,0x35,0x87,0xB6,0xE5,0x92,0x54,0xA9,0xF9,0xC6,0x91,0x63,0x88,0xA7,0x77,0xEE,0x67,0xBA,0x4B,0x60,0x2F,0xAB,0xD6,0x04,0x18,0xB2,0x44,0x03,0x06,0xC8,0xB2,0x44,0x03,0x14,0xA0,0xC0,0xFF,0x03};
//const uint8_t spPASS[] PROGMEM = {0x0A,0xC8,0x33,0x83,0x03,0xA3,0xEC,0x55,0x2D,0xD4,0x12,0xAF,0xAA,0x04,0xC9,0xD4,0x0E,0x7D,0xAA,0x16,0x4A,0x33,0x65,0xCE,0xAD,0x6F,0x7D,0x9A,0x9A,0xDC,0xDB,0x62,0xEE,0x6D,0x6E,0x73,0xC6,0x12,0xDD,0x5B,0x6B,0xEE,0x5D,0xF6,0x3A,0xCE,0xAA,0xD2,0x26,0xED,0x75,0xBB,0x9B,0x4D,0x6D,0xF1,0x25,0xFD,0x77,0x7F,0xEF,0xD2,0xCE,0x9D,0x46,0x00,0x4B,0x17,0x2B,0xE0,0x8F,0x52,0x0B,0x68,0x40,0x02,0x1C,0x90,0xC0,0xFF,0x03};
//const uint8_t spPOSITION[] PROGMEM = {0x02,0xC8,0x3C,0x78,0x24,0x5D,0xB8,0xBB,0x53,0xB7,0x5B,0xDC,0x62,0xD5,0x4B,0x38,0x87,0xA1,0x1F,0x05,0x5C,0x40,0x66,0x81,0x95,0x1D,0x19,0xA6,0x4E,0x7E,0x4E,0x3C,0x75,0xA8,0x39,0xF5,0x3D,0x51,0xB7,0xA9,0xA6,0xBA,0xE7,0x44,0x2D,0x99,0x2A,0xC7,0xA6,0x04,0x8C,0x3E,0x95,0x81,0x0C,0x78,0xA0,0xF5,0x2D,0xA8,0x98,0xD9,0x96,0x3D,0x8D,0x69,0xE8,0x64,0x4B,0xE9,0x3B,0x8E,0xA1,0x9D,0xBD,0xA4,0x4B,0x3B,0xBA,0x16,0x2C,0x77,0x7B,0xF9,0xCA,0x4F,0x78,0x7B,0x20,0x35,0x0B,0xA7,0xF1,0xFF,0x7F};
//const uint8_t spPUSH[] PROGMEM = {0x06,0x28,0x22,0x5D,0x03,0xCB,0x4B,0x2A,0x23,0x03,0xDB,0x9E,0xB8,0x88,0x8C,0x18,0xCC,0x7A,0xD3,0x9B,0xAF,0xBA,0x78,0xE7,0x70,0xEB,0xDA,0xC6,0x9E,0x27,0x44,0x44,0xAB,0x01,0x56,0xBE,0x8A,0x40,0x04,0x22,0xE0,0x01,0x0F,0x78,0x40,0x02,0xFF,0x0F};
//const uint8_t spRIGHT[] PROGMEM = {0x66,0xD7,0xB1,0x24,0xDC,0xE3,0x98,0xCD,0x95,0xA4,0x28,0xB5,0x97,0xD6,0xD0,0x8C,0x3A,0x55,0xFE,0x18,0x43,0xB1,0x4C,0x37,0x6F,0xA7,0x2D,0x72,0x22,0x8A,0xF3,0x9E,0xA6,0xFA,0x94,0x0A,0xDD,0x7C,0x9B,0xDB,0xAD,0xB1,0xD7,0x40,0xF3,0x78,0x3D,0xE7,0x7E,0xE6,0x07,0x81,0x22,0x94,0xBB,0x88,0x6C,0x00,0x50,0xC0,0xB6,0xD7,0x1E,0x10,0x40,0x9B,0xEB,0x0C,0x28,0x56,0xE9,0xFF,0x01};
//const uint8_t spSLOW[] PROGMEM = {0x04,0xF8,0xCB,0x44,0x01,0xBF,0x86,0x5B,0xC0,0x02,0x1C,0x28,0xD3,0xC6,0x1C,0x55,0xA2,0xAD,0x0F,0xB3,0x3D,0xC5,0xA4,0x16,0x95,0xE4,0xF5,0x64,0x95,0x7B,0x8E,0x53,0xDF,0x9B,0xAD,0x22,0xF1,0xEA,0x61,0xCE,0xBB,0x9B,0xD9,0xCF,0xB9,0x2F,0x7D,0x0D,0x9B,0xD7,0x5D,0x0B,0x92,0x27,0x1E,0xEE,0xD4,0xA5,0x32,0x50,0xDB,0xD8,0xD3,0x5E,0xEE,0xF6,0xB1,0xDD,0x55,0xBB,0xFC,0x3F};
//const uint8_t spTOOL[] PROGMEM = {0x09,0x38,0xD6,0xCC,0x01,0xCB,0x76,0xB5,0x38,0x73,0x0B,0x4F,0xCA,0x3A,0x92,0x42,0xAD,0x25,0x29,0xFD,0x4E,0x47,0x9A,0x78,0x64,0x34,0xA4,0xEB,0xC5,0xA8,0x0A,0xB1,0xCA,0x02,0x77,0xB5,0xAF,0x73,0x5A,0x83,0x88,0x69,0xA3,0x6C,0x69,0xCD,0xCC,0x67,0x94,0xDC,0xE7,0x3D,0x5E,0xF1,0x09,0x7F,0x11,0xDA,0xC3,0xE2,0xF5,0xFF,0x01};
//const uint8_t spWEST[] PROGMEM = {0x66,0xB7,0x7C,0x53,0x53,0x6B,0xFA,0xC5,0xCF,0x65,0x4C,0x64,0x56,0x5C,0x1C,0xAF,0xA6,0xE0,0xEA,0x68,0x52,0x77,0x8A,0x2A,0xD2,0xB3,0x29,0xDF,0xC9,0x9B,0x4A,0xCD,0xE2,0xCD,0x37,0x5F,0x45,0x8B,0x21,0xAD,0xF1,0x78,0xB7,0xBB,0x1F,0x4B,0x89,0x92,0xC6,0x17,0x5B,0x01,0x8F,0x9B,0x1A,0xE0,0x97,0x48,0x0F,0x78,0xC0,0x03,0x1A,0x10,0xC0,0x9F,0xED,0x1C,0xC0,0x00,0x28,0xE0,0x15,0x56,0x05,0x1C,0x9F,0x43,0x80,0x61,0x26,0xFF,0x1F};
//const uint8_t spKILO[] PROGMEM = {0x06,0xD8,0x29,0x25,0x01,0x5D,0x22,0x7B,0xA0,0x85,0x33,0x1A,0x52,0xD7,0xDB,0x19,0xCF,0x68,0x44,0xD3,0x29,0x51,0x79,0xBC,0x99,0xAC,0x6C,0x71,0x0B,0x4D,0xCA,0xB6,0xC7,0x35,0x55,0xEE,0x39,0x4E,0x7D,0xEF,0xBA,0xD6,0xC2,0x32,0xAB,0xB8,0xEF,0xDE,0xDB,0x99,0x4C,0x65,0x2B,0xF5,0xED,0x67,0xB9,0x7D,0xAC,0x6C,0xD4,0x35,0xF1,0x8E,0x4F,0x78,0x83,0x9A,0xCA,0x20,0xBF,0xEE,0x4F,0x62,0xBC,0x82,0xF4,0xFD,0x3F};
//const uint8_t spAND[] PROGMEM = {0xA9,0x6B,0x21,0xB9,0x22,0x66,0x9F,0xAE,0xC7,0xE1,0x70,0x7B,0x72,0xBB,0x5B,0xDF,0xEA,0x56,0xBB,0x5C,0x65,0xCB,0x66,0xC5,0x3D,0x67,0xD7,0xAB,0x6D,0x2E,0x64,0x30,0x93,0xEE,0xB1,0xCD,0x3D,0x92,0xB9,0x9A,0xDA,0xB2,0x8E,0x40,0x12,0x9A,0x6A,0xEB,0x96,0x8F,0x78,0x98,0xB3,0x2A,0xB4,0xD3,0x48,0xAA,0x2F,0x7D,0xA7,0x7B,0xFB,0x0C,0x73,0x71,0x5C,0xCE,0x6E,0x5C,0x52,0x6C,0x73,0x79,0x9A,0x13,0x4B,0x89,0x45,0xE9,0x6E,0x49,0x42,0xA9,0x57,0xFF,0x3F};
//const uint8_t spFARAD[] PROGMEM = {0x04,0x58,0x3E,0x8D,0x03,0x1C,0xD0,0x80,0x05,0x4A,0xB9,0x54,0x9B,0x3A,0x79,0x9C,0xD5,0xA9,0x7B,0x0C,0x71,0xF7,0xD7,0xB7,0xBE,0xCD,0x68,0x4B,0x56,0xF1,0x12,0x3F,0xB5,0x4B,0x6B,0x2C,0x6C,0x91,0x26,0xBF,0x4E,0x63,0x2E,0x91,0x43,0x5D,0xDB,0xAF,0xA5,0xF9,0x10,0x0D,0xE9,0x3E,0xF7,0x7A,0xF2,0x0B,0x81,0x22,0x94,0xBB,0x88,0x6C,0x20,0xCF,0xA2,0xEE,0x95,0x99,0x38,0x3D,0xDD,0x85,0x89,0xCA,0x96,0xFC,0xFC,0x3F};
//const uint8_t spMILLI[] PROGMEM = {0x6E,0xF0,0x8A,0xB3,0x4B,0xEB,0xC6,0xAE,0x36,0xA7,0x1A,0x3A,0x54,0x53,0xD6,0xDC,0xEC,0x66,0x23,0xDF,0x58,0x26,0x43,0xB4,0xCD,0xEA,0x74,0x5D,0x94,0x46,0xF0,0x96,0x3B,0x9D,0x79,0x98,0x26,0x75,0xDB,0xB3,0xD7,0xB6,0xF5,0x90,0xA8,0x91,0x9F,0xEA,0x9E,0xEE,0xE9,0x9B,0x20,0x7D,0xCB,0xFF,0x03};
//const uint8_t spCAUTION[] PROGMEM = {0x02,0x48,0x69,0x4D,0x03,0x06,0xE8,0x34,0xA2,0x85,0x95,0x4C,0x78,0xA8,0xD2,0x93,0x66,0xB1,0xE9,0x4D,0x79,0x6F,0x7A,0xD3,0x9D,0xF5,0xCC,0x01,0x2B,0x86,0x06,0x60,0xC5,0xAB,0x08,0x44,0x20,0x00,0xCD,0x10,0x8D,0xB6,0x26,0x11,0x8B,0xE8,0x3C,0xE6,0x62,0x5D,0x3D,0x63,0xF7,0x58,0xBB,0x4E,0xF1,0xB0,0x2E,0xED,0x28,0xCA,0x74,0xCC,0x9B,0xB8,0xB7,0x69,0xA6,0x0E,0x8F,0x66,0xBE,0xAC,0x48,0xC6,0xAD,0xAE,0xFB,0x9A,0x16,0x0E,0xF3,0x78,0xFE,0xF3,0xBF,0xFF,0xED,0xFF,0xFF};
//const uint8_t spLIGHT[] PROGMEM = {0x61,0x69,0xC0,0x2B,0x82,0xB3,0xA5,0x79,0x01,0x9A,0x52,0x71,0x57,0xC7,0x31,0x0C,0x5C,0x5D,0xC1,0x59,0x6F,0x7B,0x9A,0xC6,0x3B,0xCB,0xA5,0xCB,0xA9,0xAA,0x6D,0x6B,0xB3,0xCD,0xA7,0x6C,0x29,0xB4,0x34,0x56,0xAF,0xBA,0x0F,0x23,0x93,0x5C,0x32,0xC7,0xB6,0xF6,0x46,0xA4,0x39,0xB3,0xF3,0x86,0x40,0x11,0xCA,0x5D,0x44,0x36,0x00,0x80,0x02,0x96,0x2A,0x35,0xC0,0xB6,0x97,0x0C,0xE8,0xF9,0x04,0x01,0xC5,0x19,0xFC,0x3F};
//const uint8_t spCHECK[] PROGMEM = {0x0E,0x58,0x25,0x25,0x00,0xB3,0x8E,0x7B,0x60,0xC5,0x35,0xB3,0x68,0xE4,0xEA,0x53,0xB4,0x1C,0x12,0xEE,0x9B,0x6F,0x79,0xAB,0x5B,0xEF,0x71,0xEF,0xE6,0xAE,0x49,0xA9,0x2A,0x17,0x21,0x50,0x84,0x72,0x17,0x91,0x0D,0x00,0x0A,0x68,0xC5,0x49,0x02,0x12,0xE0,0xC0,0xFF,0x03};
//const uint8_t spDEGREES[] PROGMEM = {0x65,0x9F,0x5A,0x48,0x42,0x1D,0x8F,0x61,0xB8,0x62,0x56,0xFE,0xB2,0xFA,0x51,0x9C,0x85,0xED,0xCD,0xEA,0x47,0x4B,0x64,0xD5,0x35,0x69,0xE8,0xC7,0x41,0xD4,0x5E,0x8B,0x25,0x6B,0xB4,0x75,0xB7,0x84,0x40,0x11,0xCA,0x5D,0x44,0x36,0x98,0xAD,0xA9,0xAB,0x28,0x8D,0x1B,0xFA,0xE2,0x26,0xC9,0x44,0x69,0x6A,0xA3,0x13,0x8F,0x70,0xAD,0xA5,0xC9,0x99,0x42,0xDC,0x9C,0x8D,0xA6,0x36,0x4E,0x72,0xB3,0xBF,0xEA,0xD6,0x54,0xD9,0x25,0xFD,0xAA,0x46,0x19,0x86,0x90,0xAF,0xB3,0xEE,0x4D,0x19,0x47,0x12,0x90,0xCE,0x5B,0x75,0xC9,0x5B,0xDA,0x47,0x31,0x14,0xF3,0xD7,0xF9,0xCC,0x77,0xFC,0xFC,0xEF,0xFE,0xE6,0x99,0xC2,0x7C,0x93,0xFE,0xC5,0xDF,0x44,0x08,0x5B,0x75,0x36,0xFF,0xD2,0xC6,0xE2,0x91,0xCE,0xFD,0xDF,0x89,0x9A,0x68,0x3A,0x01,0x4C,0x48,0x2A,0x80,0x5F,0x33,0x34,0x40,0x81,0xFF,0x07};
//const uint8_t spSERVICE[] PROGMEM = {0x04,0xF8,0xAD,0x94,0x03,0x1A,0xB0,0x80,0x07,0x2C,0xB0,0xA2,0xE6,0xCD,0xD4,0xB4,0xEB,0xC9,0xAA,0x4D,0xE1,0xD6,0xEC,0x23,0x2B,0xBE,0x85,0x96,0xFD,0xCD,0xBC,0x15,0xB9,0x16,0xE9,0xB0,0xBF,0x51,0x66,0x5F,0x24,0xA3,0x7A,0x53,0x97,0xBD,0x89,0xBB,0xC4,0x52,0x4B,0xB1,0xAE,0xE6,0x9A,0xB9,0xEE,0x63,0xAD,0xCE,0x35,0xD4,0x7A,0xCF,0xA3,0x9F,0xE9,0x2E,0xD2,0x25,0xDD,0x77,0x13,0xE0,0xB7,0x52,0x09,0x48,0xC0,0x02,0x16,0x90,0x00,0x05,0xFE,0x1F};
//const uint8_t spSWITCH[] PROGMEM = {0x08,0xF8,0x3B,0x93,0x03,0x1A,0xB0,0x80,0x01,0xAE,0xCF,0x54,0x40,0x33,0x99,0x2E,0xF6,0xB2,0x4B,0x9D,0x52,0xA7,0x36,0xF0,0x2E,0x2F,0x70,0xDB,0xCB,0x93,0x75,0xEE,0xA6,0x4B,0x79,0x4F,0x36,0x4C,0x89,0x34,0x77,0xB9,0xF9,0xAA,0x5B,0x08,0x76,0xF5,0xCD,0x73,0xE4,0x13,0x99,0x45,0x28,0x77,0x11,0xD9,0x40,0x80,0x55,0xCB,0x25,0xE0,0x80,0x59,0x2F,0x23,0xE0,0x01,0x0B,0x08,0xA0,0x46,0xB1,0xFF,0x07};
//const uint8_t spVALVE[] PROGMEM = {0x61,0x1F,0x5A,0x58,0x4D,0x9C,0x08,0x60,0x58,0x95,0x32,0x0D,0x2D,0xAC,0x26,0x4E,0x46,0xD7,0x5C,0x58,0x18,0xAF,0x3E,0x6D,0x73,0x6A,0x65,0xF6,0xE4,0x34,0xCD,0xA6,0x97,0xD9,0x93,0x5B,0xDF,0xFA,0x36,0xAB,0xCF,0x6A,0xA3,0x55,0x36,0xEF,0x7E,0xCF,0x63,0x2E,0xF4,0xAA,0x9C,0xFA,0x8C,0xAD,0xC1,0x9E,0x76,0xF2,0xD6,0xF7,0xBA,0xD7,0xA3,0x1C,0x85,0x78,0x76,0xA1,0xFA,0x78,0xC4,0x3B,0xDC,0x91,0x55,0x94,0x70,0x6A,0x7F,0xEB,0x87,0x00,0x55,0xA8,0x70,0x80,0x02,0x14,0xC0,0xC0,0xFF,0x03};
//const uint8_t spVAL[] PROGMEM = {0x24,0x4B,0x38,0x2C,0x43,0x13,0xBB,0xEC,0xB8,0xB6,0xD0,0x76,0xBD,0xDA,0x6D,0x4B,0xC5,0xD8,0xF7,0x69,0x9B,0x55,0x2B,0xB3,0x27,0xA7,0x69,0x36,0xAD,0xCC,0x9E,0xDC,0xFA,0xD6,0xB7,0x59,0x7D,0x56,0x1B,0xAD,0xB2,0x79,0xF7,0x73,0x68,0x73,0x0C,0x5D,0xE1,0xD2,0xA6,0xEE,0xF9,0x0C,0x57,0xB0,0x13,0xC1,0x9E,0x36,0x5E,0xEE,0xCE,0x22,0xAC,0xD5,0xE2,0xF8,0xDB,0xDC,0x4D,0x09,0xA5,0x47,0xDC,0x78,0x9B,0xBB,0x7B,0x62,0xB7,0x70,0xF6,0xFF};
//const uint8_t spNUMBER[] PROGMEM = {0x66,0xA9,0x12,0x72,0x42,0x9B,0x86,0xA5,0x1B,0x90,0x0E,0x6D,0x76,0xA6,0x26,0x2B,0xDC,0xA5,0xCF,0x6D,0x4F,0x95,0x4D,0xA5,0xBB,0x6E,0x5E,0x45,0x31,0x5E,0x65,0x92,0x66,0x14,0x45,0xAA,0xB4,0x98,0x9D,0x5A,0x84,0x2A,0x18,0xF6,0x92,0x74,0x43,0x3A,0xAD,0x5C,0x27,0xDD,0x6D,0x98,0xA3,0x09,0xF5,0x92,0xA4,0x65,0x4C,0x4D,0xA4,0x82,0x56,0x97,0x39,0x77,0xC7,0x68,0xF1,0x5D,0xD6,0xDC,0x1D,0x63,0xD4,0x4F,0xBE,0xC3,0x9D,0x53,0x81,0x4E,0xF3,0x89,0x9F,0xFF,0xDC,0x5F,0x66,0x92,0xB5,0x7A,0xFE,0x7F};
//const uint8_t spOUT[] PROGMEM = {0xAD,0xCF,0xE6,0xDD,0xD3,0x17,0xED,0xFE,0xF4,0x9D,0x4F,0x56,0x71,0x97,0xDB,0xDD,0xEE,0x76,0xA7,0xCF,0xAE,0x6A,0x54,0x5A,0xEF,0x7E,0x0F,0x7B,0x4C,0x6B,0x88,0x95,0x21,0xBC,0xD9,0x6F,0x08,0x14,0xA1,0xDC,0x45,0x64,0x03,0x00,0x08,0xE0,0xE8,0x2E,0x0F,0x50,0xE0,0xFF,0x01};
//const uint8_t spPOINT[] PROGMEM = {0x06,0xA8,0xCC,0x4B,0x03,0x2D,0xF3,0x69,0x2B,0x8C,0x1A,0xAF,0x2C,0x98,0xE9,0x28,0x4A,0xB3,0xF3,0x53,0xC6,0x90,0x9E,0xC1,0x6D,0x76,0x77,0xE6,0x9C,0x5D,0xD3,0x75,0xF1,0x58,0x5B,0x75,0x76,0xB7,0x4F,0xE3,0xE8,0xCE,0x31,0x3A,0x17,0xB6,0xB3,0x45,0x96,0xF4,0xAA,0x6D,0x4F,0x75,0x76,0xA3,0x94,0x66,0x6E,0x10,0x28,0x42,0xB9,0x8B,0xC8,0x06,0x50,0xC0,0x32,0x11,0x0A,0x58,0x76,0x87,0x01,0x3D,0xB5,0xFE,0x3F};
//const uint8_t spBREAK[] PROGMEM = {0x90,0xC6,0x62,0x2D,0xDC,0xCC,0x76,0xE9,0x63,0x55,0xD3,0x32,0xF5,0xAD,0x4F,0x5D,0x42,0x53,0xF5,0x9D,0xB6,0x14,0x49,0x0D,0xCD,0x73,0xEA,0x5A,0x4C,0xC3,0x6D,0xF3,0x69,0x7A,0x0B,0x52,0x8D,0x25,0xBB,0x9D,0x8B,0xDB,0xC7,0x13,0x90,0x8A,0xC7,0x08,0x14,0xA1,0xDC,0x45,0x64,0x03,0x00,0x03,0xC6,0xA8,0x14,0x40,0xCD,0x4A,0x16,0xE0,0x00,0x06,0xFE,0x1F};
//const uint8_t spHOURS[] PROGMEM = {0x63,0xC9,0x66,0xA2,0xCC,0x57,0x9F,0xB1,0xF1,0xCE,0x6E,0xEE,0x72,0xBB,0xD3,0x24,0x3B,0x99,0x49,0x79,0x6E,0x35,0x2A,0x1F,0x27,0xBD,0xC8,0x4B,0x69,0x4D,0xDA,0xB0,0x54,0x2E,0x65,0xB0,0x65,0x34,0x43,0xF8,0x96,0x31,0x75,0xA5,0x6E,0xEA,0x53,0xD7,0x7C,0xA4,0x27,0xD7,0x00,0x6F,0xD7,0x1B,0x1F,0xFF,0xB8,0xB7,0x26,0x16,0x49,0xEB,0xE6,0x5F,0xF7,0x56,0x2B,0x62,0xEA,0xEB,0xDC,0xDB,0x83,0xB2,0x9A,0x74,0x73,0xEF,0x76,0x9E,0xC4,0xAA,0xDE,0x7D,0xBF,0x87,0xA6,0xA0,0x52,0x06,0x7C,0x4B,0x24,0x01,0x09,0x70,0xE0,0xFF,0x01};
//const uint8_t spCALIBRATE[] PROGMEM = {0x0E,0x18,0xC9,0xD9,0x01,0x55,0x29,0x9E,0xA0,0x16,0x97,0x70,0x5F,0x7C,0xB2,0xAA,0xDB,0x2B,0x79,0xCD,0xCD,0x56,0x51,0xC9,0x54,0x0D,0x26,0x1E,0x45,0xC3,0x55,0xDE,0xE2,0xF8,0x54,0xC5,0x94,0xA7,0x73,0x97,0xDB,0x94,0x3E,0xE9,0x52,0x2F,0xF6,0xC2,0x16,0xA9,0x4B,0xB3,0xCC,0x5E,0xD8,0xAA,0x34,0x31,0x73,0x27,0xE5,0x4C,0x8D,0xC3,0xD3,0xF4,0xF6,0xA9,0x2F,0xEB,0xA8,0x2E,0x39,0x42,0xFB,0x8E,0xAB,0x99,0xA4,0x28,0xFF,0x5C,0xEE,0x69,0x97,0x28,0x7D,0x4F,0x7D,0xD2,0xDF,0xAB,0x92,0x98,0x6F,0x41,0x8F,0x08,0xE5,0x2E,0x22,0x1B,0x00,0x18,0xB0,0x42,0xA4,0x02,0x5E,0xA8,0x26,0xC0,0xF0,0xE7,0xFF,0x0F};
//const uint8_t spCRANE[] PROGMEM = {0x0A,0xC8,0xBD,0xD5,0x03,0x16,0x50,0x40,0x5E,0x15,0x23,0x4F,0x5D,0xCC,0x87,0xB3,0xAE,0xA2,0xE4,0x64,0x1D,0x73,0x7F,0x8A,0x9A,0x9B,0xB5,0xA5,0xEB,0x29,0x7A,0x4D,0x36,0xB7,0x45,0xB7,0x58,0xF5,0x28,0x8E,0xDA,0x31,0x69,0x77,0x7B,0x98,0x73,0x5F,0xEA,0x1A,0xF6,0x1E,0x99,0xB3,0x62,0x74,0xB8,0xBA,0x47,0x73,0x4F,0xA7,0xF1,0x0A,0x77,0x4F,0xE4,0x2A,0xEE,0xD5,0x3D,0xCD,0x91,0x86,0x86,0xBB,0xF0,0x8C,0xC8,0x6C,0x9A,0xCE,0xFE,0x1F};
//const uint8_t spDIRECTION[] PROGMEM = {0xA5,0x7E,0xBE,0x3C,0x49,0x14,0xAF,0x6E,0xAA,0x52,0x72,0xCD,0x77,0xBA,0x66,0x4A,0x38,0xAC,0xDB,0xE9,0x8A,0x0F,0xB6,0xB0,0xF4,0xAD,0x4B,0x5D,0xDC,0x35,0xED,0xCF,0xF6,0xD4,0xA5,0x68,0xB8,0x85,0xFB,0x53,0xD6,0x90,0x34,0x1E,0x9D,0x6E,0x31,0xF2,0x36,0x9D,0x4A,0x6C,0x91,0xC9,0x47,0x18,0x63,0xD1,0xD8,0x02,0xE8,0xC1,0xCC,0x01,0x63,0x6C,0x45,0x20,0x02,0x1E,0x68,0x45,0x8D,0xAA,0x6E,0xD1,0x69,0x36,0x63,0x69,0x81,0x2D,0x25,0x9A,0xD4,0x23,0x1D,0x5D,0x0B,0xA5,0x7B,0xB4,0x78,0xF9,0xDB,0x7D,0x23,0x18,0xB9,0x58,0x7C,0xFF,0xBB,0xAF,0x19,0xC1,0x54,0x4B,0xF6,0xFF};
//const uint8_t spENTER[] PROGMEM = {0xAB,0x18,0xB6,0x39,0xDC,0x5E,0xDD,0xFA,0x96,0xAB,0xE8,0x41,0x24,0xC9,0x17,0xE5,0x0A,0x0C,0x70,0x4C,0x65,0xE9,0x4A,0x37,0xCC,0xE4,0xDE,0xB3,0x6F,0x73,0xA9,0x0D,0x36,0x9C,0x37,0xEF,0xE9,0xCA,0x35,0xA0,0x5A,0xFA,0x94,0xB7,0xD4,0xC4,0x48,0xC9,0x93,0xBF,0xFF,0x07};
//const uint8_t spFEET[] PROGMEM = {0x08,0x98,0x31,0x93,0x02,0x1C,0xE0,0x80,0x07,0x5A,0x3E,0x4A,0x28,0x99,0x3F,0x59,0xE9,0xE8,0x4E,0x64,0xFE,0x64,0x67,0xA3,0x98,0x45,0x41,0xB2,0x67,0xF7,0x36,0x4F,0x6A,0x9F,0x9D,0x91,0xB3,0x6E,0xA3,0x7B,0xCA,0x30,0x53,0x95,0x03,0x00,0x00,0x08,0x18,0xD2,0x4D,0x00,0xC7,0x6C,0x6A,0x40,0x00,0x3D,0xAC,0x62,0xE0,0xFF,0x01};
//const uint8_t spFROM[] PROGMEM = {0x04,0x18,0x26,0x8D,0x03,0x12,0xF0,0x80,0xAB,0x42,0x57,0x8B,0x61,0x6F,0xAB,0x4C,0xCE,0x2B,0xD2,0xD4,0xDD,0xE2,0x96,0xA7,0xCC,0x72,0xCA,0x93,0xDB,0xEC,0x6A,0xB7,0x73,0x68,0x4B,0xA7,0x61,0xA1,0x6C,0xB6,0xAF,0xF9,0x88,0x47,0x3C,0xFD,0xF3,0xFF};
//const uint8_t spGAP[] PROGMEM = {0x0C,0x08,0xDA,0x75,0x2C,0xB3,0x27,0x19,0xBB,0xDD,0xD1,0xB7,0x44,0xE4,0x51,0x73,0x4E,0x3B,0x7A,0x90,0x49,0x2C,0x39,0x75,0x77,0xAD,0x66,0xB6,0xE6,0x56,0xA7,0xAA,0x31,0x25,0x2D,0xD7,0xEC,0x61,0x2E,0x71,0x41,0xA0,0x08,0xE5,0x2E,0x22,0x1B,0x00,0x00,0x01,0x5D,0x85,0x29,0xE0,0x88,0x76,0x05,0x4C,0xF7,0xCE,0x80,0xEE,0x9B,0x29,0xF0,0xFF};
//const uint8_t spHOLD[] PROGMEM = {0x08,0x68,0x34,0x5A,0x03,0x06,0x98,0x42,0xCC,0x02,0x23,0x4F,0x7C,0xD6,0x85,0xDA,0xAC,0xAC,0xE2,0xD8,0x32,0x4C,0xD3,0xF2,0x8C,0xF3,0x9C,0xA9,0x4B,0xCF,0x5A,0x51,0x91,0xEE,0x04,0xBA,0xEB,0x55,0xED,0xCB,0x12,0x85,0x6F,0x0A,0xBB,0xCB,0x6B,0xDC,0xE3,0x61,0x0F,0x73,0x65,0x41,0xAB,0x6A,0x69,0xCC,0x95,0x04,0x75,0x93,0xA7,0x35,0x67,0xD3,0x28,0xE3,0x9A,0x56,0x5D,0x85,0x93,0x65,0x68,0xB6,0x74,0x55,0x63,0xE6,0x62,0x6B,0xDC,0x59,0x2D,0x87,0xBB,0x3F,0xF9,0x7F};
//const uint8_t spLEFT[] PROGMEM = {0x69,0x1D,0xC0,0xDA,0xCC,0xD3,0xA6,0xB5,0x81,0x68,0xD1,0xF4,0xDA,0xC7,0xD3,0x57,0x6F,0x11,0xDC,0x4B,0x6E,0x73,0x9A,0xE6,0x5D,0x5B,0x72,0xF5,0xED,0xF7,0xD2,0xCE,0x92,0x2C,0x5C,0xEA,0x0D,0x03,0x8A,0x0E,0x25,0xC0,0x74,0xE3,0x12,0xD0,0x80,0x04,0x10,0x90,0x89,0x2B,0x08,0x60,0x8B,0x71,0x0B,0x10,0xA0,0xB5,0xF3,0xFF,0x07};
//const uint8_t spMILL[] PROGMEM = {0x66,0x8E,0x8A,0xA2,0xC2,0x93,0xFA,0x29,0x8E,0xB9,0x1B,0x6D,0x4B,0xA6,0x26,0xF9,0xE4,0xD6,0xB7,0xBA,0xD5,0x6A,0xAB,0x4C,0x6B,0xD5,0xC7,0x6B,0x28,0xA4,0xB3,0x8D,0xFB,0xCC,0xB9,0xEC,0x05,0x75,0x97,0x61,0xDE,0xBA,0xE7,0x33,0x5D,0x0D,0x47,0x4D,0x80,0x97,0x78,0x9B,0xC7,0xEA,0xA9,0x62,0xED,0xFC,0xFF};
//const uint8_t spUH[] PROGMEM = {0x63,0x2A,0xAC,0x2B,0x8D,0xF7,0xEC,0xF1,0xB6,0xB7,0xDD,0xDD,0xEC,0xC7,0x5A,0x58,0x55,0x39,0xF5,0x9E,0x6B,0x3D,0xD3,0x59,0xB8,0x67,0x39,0xEE,0x8A,0x77,0x7A,0xAB,0x54,0x6F,0xC7,0x4C,0xF6,0x91,0xCF,0xFF,0x03};
//const uint8_t spPAST[] PROGMEM = {0x0A,0x88,0x29,0x4C,0x02,0x25,0xAB,0x4E,0xB4,0xCC,0x6B,0x9E,0x22,0x47,0x89,0xF2,0xAA,0x7C,0xEA,0x1A,0xDC,0x3A,0xED,0xCE,0xAD,0x6F,0x77,0x87,0x3B,0xCF,0x7D,0x9C,0xD5,0xBA,0x75,0xEA,0xE2,0x7E,0xB5,0xAB,0x05,0x8D,0x96,0x5C,0xE2,0xCE,0x3E,0x39,0x93,0xCA,0x0D,0x03,0xBE,0x37,0xD5,0x80,0x05,0x3C,0x60,0x01,0x0D,0x00,0x02,0x9E,0xE7,0xB0,0x80,0x00,0xA6,0x5E,0x47,0x40,0x1D,0x4B,0xFF,0x0F};
//const uint8_t spPRESS[] PROGMEM = {0x02,0x28,0x31,0x43,0x03,0x25,0xCB,0xBE,0xDC,0x5D,0xED,0x94,0x22,0x0E,0xCE,0x70,0xC9,0xBD,0xF2,0x9C,0xD5,0xBD,0x24,0xEF,0xC9,0xAB,0x77,0xF5,0x92,0x3E,0x27,0x6B,0xA1,0x25,0xD5,0x56,0xDF,0xEC,0x34,0x5D,0xA7,0x94,0xF9,0xEB,0x3B,0xEC,0x69,0xEE,0x75,0x15,0xC0,0x57,0xC1,0x02,0xF8,0x3D,0x5D,0x02,0x1A,0xD0,0x80,0x04,0x28,0x80,0x81,0xFF,0x07};
//const uint8_t spRANGE[] PROGMEM = {0x6C,0xE7,0xA5,0xD9,0x33,0xAD,0xAA,0x4D,0xF7,0xC0,0x6C,0x93,0xEA,0x66,0x3F,0x95,0x3A,0xD5,0x79,0xEB,0x62,0x17,0x69,0x0B,0xE7,0xAB,0x29,0x45,0x8A,0x4B,0xBD,0x9E,0xBA,0x17,0x63,0xB7,0x58,0x7D,0xAB,0x5B,0xAD,0x7A,0x94,0x00,0xAB,0x9C,0xB5,0xBB,0x39,0xCC,0xB9,0xAF,0x75,0x4F,0x7B,0x8F,0x10,0xEE,0x69,0x27,0x9C,0x3D,0x93,0xA4,0x79,0x5C,0x7F,0x87,0xB7,0x7B,0xE6,0x30,0x8B,0xE7,0x5F,0xF3,0x54,0xCD,0x92,0xA1,0x75,0xFC,0xC3,0x80,0x51,0x9C,0x24,0x60,0x01,0x01,0x8C,0xEC,0xF4,0xFF};
//const uint8_t spSAFE[] PROGMEM = {0x08,0xF8,0x39,0x4C,0x02,0x1A,0xD0,0x80,0x05,0x3C,0x60,0x81,0x95,0x0F,0x15,0xE2,0x6A,0xAB,0x4F,0xD1,0x43,0x8A,0x8A,0xBF,0xB9,0xD5,0xAD,0x57,0x3F,0xAA,0x23,0xBB,0x3F,0x9E,0xCB,0xDC,0xF3,0x99,0x9E,0x5E,0x19,0xCD,0xEB,0x8E,0x79,0x7A,0x43,0x13,0xED,0x39,0x0C,0x18,0x7E,0x5C,0x02,0x12,0x90,0x00,0x07,0x28,0x40,0x81,0xFF,0x07};
//const uint8_t spSOUTH[] PROGMEM = {0x08,0xF8,0x2E,0x8C,0x03,0x0C,0xF8,0xB5,0xCD,0x02,0x16,0x50,0xC0,0x6F,0xA5,0x1E,0x50,0xC0,0x37,0xEE,0x23,0x69,0xCA,0x35,0x55,0x57,0xAF,0xA2,0xD8,0x8E,0x16,0x5D,0x7D,0xEB,0xDB,0xDC,0x76,0xF5,0xC9,0x4C,0x95,0x71,0xEF,0x3D,0xCD,0xBD,0x9C,0xC1,0x75,0x95,0x72,0x97,0xFC,0x84,0x3F,0xAA,0xAE,0x31,0xF1,0x2D,0x5E,0x5B,0x72,0x9C,0x62,0xB5,0xF9,0x92,0x8E,0x18,0x93,0xC4,0x04,0x18,0xB2,0x45,0x02,0x1C,0xA0,0x00,0x05,0x28,0x40,0x81,0xFF,0x07};
//const uint8_t spTURN[] PROGMEM = {0x01,0x18,0xA9,0xCC,0x02,0x06,0x28,0x4E,0xA9,0x14,0x39,0x25,0x69,0x4B,0xBA,0x5D,0xAE,0xAA,0x84,0x15,0x5A,0xF5,0xBE,0xAB,0x59,0xCF,0x61,0xCE,0x7D,0x6B,0x5B,0x09,0x49,0x76,0xEE,0xB5,0x1E,0xE5,0x69,0x2E,0x44,0xD3,0x9A,0xE6,0x27,0x7C,0x4D,0x09,0xA5,0x47,0xDC,0xF8,0xB9,0xAF,0x7B,0x62,0xB7,0x70,0xE6,0xBE,0x1A,0x54,0x4C,0xB8,0xDD,0xFF,0x03};
//const uint8_t spYELLOW[] PROGMEM = {0x69,0xBD,0x56,0x15,0xAC,0x67,0xE5,0xA5,0xCC,0x2B,0x8E,0x82,0xD8,0xD6,0x39,0x9E,0xAE,0x85,0x50,0x37,0x5F,0x7D,0xEB,0x53,0x55,0x1B,0xDE,0xA6,0x6B,0x56,0x5D,0x74,0x47,0x2B,0x77,0x6E,0x75,0x87,0x59,0x95,0xA4,0x76,0x76,0x6B,0xCE,0xA2,0xB3,0x4C,0xF2,0xCF,0xBD,0xED,0xC9,0x54,0xB6,0x52,0x9F,0x7E,0xA5,0xDB,0xC7,0xCA,0x46,0x5D,0x13,0xEF,0xF8,0x84,0x37,0xA8,0xA9,0x0C,0xF2,0xE3,0xBE,0x24,0xC6,0x2B,0x48,0xDF,0xFF,0x03};
void setup() {
CircuitPlayground.begin();
CircuitPlayground.speaker.say(spDANGER);
CircuitPlayground.speaker.say(spDANGER);
CircuitPlayground.speaker.say(spMOTOR);
CircuitPlayground.speaker.say(spIS);
CircuitPlayground.speaker.say(spON);
CircuitPlayground.speaker.say(spFIRE);
// Calling speaker.end() after playing a sound is optional -- this
// will turn off the pin 13 LED (it's connected to a microcontroller
// pin that's also related to the speaker), but there's a small
// audible click when it turns off. Tradeoffs!
CircuitPlayground.speaker.end();
}
void loop() {
}

400
arduino-cli/libraries/Adafruit_Circuit_Playground/examples/Speech_Demos/Talk_US_TI99/Talk_US_TI99.ino Normal file
View File

@@ -0,0 +1,400 @@
// Talkie library
// Copyright 2011 Peter Knight
// This code is released under GPLv2 license.
//
// The following phrases are derived from those built into the
// Texas Instruments TI99/4A Speech System add-on from 1979.
//
// A deep male voice with a southern USA accent.
//
// Due to the large vocabulary, this file takes up 32Kbytes of flash.
// It will not fit in most Arduinos as is, so just copy and paste
// out the words you need.
//
// Note that some words/letters are repeated with different spellings.
// eg. 'TWO', 'TO', 'TOO' or 'YOU' and 'U'
#include <Adafruit_CircuitPlayground.h>
#include <Wire.h>
#include <SPI.h>
//const uint8_t spA[] PROGMEM ={ 0xA7,0x8A,0xCE,0x25,0xA7,0x2A,0xDD,0x62,0xE7,0x3B,0xBF,0xF9,0xAD,0x56,0xD5,0x72,0xA0,0x44,0x7D,0x99,0x4D,0xED,0xFC,0xE0,0x87,0x07,0x00,0x00};
//const uint8_t spA1[] PROGMEM ={ 0xAD,0x36,0x25,0x46,0x7C,0x2C,0xCD,0x66,0x36,0xB3,0xED,0x6D,0xEF,0x72,0xE7,0xBB,0xD8,0x3F,0x00,0x00};
//const uint8_t spABOUT[] PROGMEM ={0xA1,0x08,0x2E,0xCF,0x4A,0xDB,0xF7,0x62,0x54,0xC9,0xC6,0xB9,0xC9,0xDA,0x56,0x45,0xE3,0x1B,0xCE,0x5D,0x55,0x2D,0x43,0x06,0xAA,0xA7,0x86,0x51,0x05,0x95,0xED,0x26,0xBB,0x57,0xE5,0x6D,0xB5,0xAB,0xBD,0xDE,0xD5,0xAE,0x4E,0xE5,0xFD,0xB4,0x69,0xD4,0x9D,0x55,0xAF,0x4A,0x6D,0xC2,0x8E,0x48,0xD4,0x75,0xB5,0x35,0xF3,0xAC,0x36,0x47,0xD4,0xA2,0xB7,0x4B,0x87,0x65,0x00,0x00,0x02,0x64,0xED,0x81,0x80,0xA3,0xDD,0x10,0xE0,0x4D,0x18,0xC0,0x03};
//const uint8_t spAFTER[] PROGMEM ={0x25,0x8B,0x23,0xC3,0xA1,0xC3,0x9C,0x2C,0xF6,0x32,0xE7,0xAA,0x7A,0xB3,0x9B,0xDF,0xE2,0x56,0xB5,0x31,0x80,0x15,0xC6,0x1A,0xD0,0x00,0x80,0x01,0x8A,0x32,0x4F,0x85,0x5F,0xEC,0x96,0x9A,0xBD,0xD7,0xB5,0xCB,0x83,0x1B,0xEC,0xA0,0x88,0x8C,0x74,0x62,0xB4,0x03,0xAA,0x2C,0x12,0xB3,0xC9,0x76,0xD6,0xCC,0x70,0xF2};
//const uint8_t spAGAIN[] PROGMEM ={0x08,0xD0,0xD1,0xBD,0x55,0xAE,0xA7,0x73,0x54,0xAD,0x53,0xC5,0x18,0xE1,0xA2,0x4B,0x4F,0x9D,0x42,0xA8,0x89,0x76,0x6D,0xB5,0xB7,0x22,0x21,0xE9,0xAD,0x36,0xB3,0x1D,0x4D,0xB1,0x22,0xAE,0x97,0xA4,0xE7,0x23,0x2B,0x89,0x5D,0x63,0x92,0xEC,0x6C,0xA7,0x23,0x2D,0xD5,0x42,0x74,0x14,0xCF,0x6C,0xE4,0xA9,0x45,0x08,0x8D,0xE3,0x5D,0xEF,0x66,0xB4,0xB1,0x67,0xB2,0x66,0xE2,0xD9,0x8F,0x3E,0x8C,0x08,0xF2,0x8C,0x1B,0x06,0xE9,0xA5,0xCC,0x46,0xB6,0x1F,0xEC,0x20,0x07,0x34,0xD0,0x10,0x99,0xDA,0x92,0x1E,0x00,0x00};
//const uint8_t spALL[] PROGMEM ={0x29,0xB1,0xE6,0x57,0xB9,0xE6,0xD4,0xB4,0xA7,0x23,0x35,0xEE,0xD6,0xD8,0x9B,0xCE,0x74,0x66,0xB3,0x9A,0xD5,0xAC,0x4B,0x23,0xEB,0x8C,0x62,0x3B,0xA9,0x5D,0xE8,0xC4,0xDA,0x56,0x28,0x65,0xBE,0xD7,0xBD,0xEC,0x1F};
//const uint8_t spAM[] PROGMEM ={0xA3,0x28,0x4D,0xDD,0x64,0x15,0x9D,0xA2,0x34,0x0B,0xD5,0x4A,0x74,0xAA,0x3C,0x2D,0x44,0x2A,0xD5,0xAD,0x6E,0x75,0xAA,0xD4,0xB5,0x59,0x33,0xCE,0xAD,0x4F,0x1D,0x6B,0x94,0x9A,0x57,0xD9,0xED,0x68,0x6D,0xA9,0x56,0xC9,0xD8,0xAD,0x35,0x8E,0x4B,0xC5,0x54,0xFB,0xCE,0x77,0xA6,0xD3,0x8E,0x4A,0xC3,0xDD,0x98,0x4E,0x7A,0x49,0xE5,0x76,0xEA,0x3B,0xDD,0x3F,0x00,0x00};
//const uint8_t spAN[] PROGMEM ={0xA3,0xCA,0xD3,0x4C,0xBC,0x22,0xDF,0x62,0x15,0x65,0x99,0xB3,0x4E,0x9C,0x5D,0xDC,0xE2,0x54,0x65,0x78,0x32,0x77,0xE2,0x5B,0xED,0x6A,0xD7,0xA3,0x8D,0x4D,0x43,0x39,0x13,0xA5,0xD6,0x7A,0x6A,0xD1,0x76,0x63,0x3B,0xDB,0xAB,0x5E,0x06,0x0E,0x95,0x49,0xAC,0x7B,0xDD,0x3F,0x00,0x00};
//const uint8_t spAND[] PROGMEM ={0xA1,0xC8,0xD3,0x4C,0xBC,0x22,0xCF,0x62,0xE4,0x65,0x99,0xB3,0x4E,0x9C,0x9B,0xCD,0xAC,0x65,0x65,0x78,0x32,0x77,0xE2,0x96,0x97,0x58,0x2A,0x66,0xB3,0x5B,0x95,0x53,0xB1,0x9A,0x4D,0x69,0x75,0x2A,0x69,0xA2,0x3A,0xA7,0x35,0x31,0x97,0x91,0xD9,0xAC,0xD4,0x25,0x5F,0x85,0x2E,0xB3,0x43,0xAF,0x83,0x9A,0x9A,0xD7,0x76,0xBD,0x0A,0x5C,0x62,0xE3,0xC0,0xF5,0x32,0x70,0x89,0x77,0x2C,0xD3,0x4B,0x47,0x6D,0x3A,0xB1,0xD4,0xA0,0x2D,0xAE,0xD9,0x44,0x92,0x23,0x9F,0xC2,0x54,0x94,0x8B,0x78,0x6C,0xD0,0xA3,0x18,0x52,0x4C,0x75,0xCD,0x5A,0x0F};
//const uint8_t spANSWER[] PROGMEM ={0xA5,0x88,0x59,0x2B,0xBC,0x2A,0xDE,0xEA,0x14,0x69,0x78,0x8A,0x56,0x9C,0x9B,0xEF,0x7C,0x64,0x3E,0x25,0x05,0x67,0x3D,0x97,0x5A,0xCF,0xEE,0x78,0x6D,0x75,0x96,0xAA,0x9E,0x2B,0x4D,0x4D,0xB1,0x01,0x6E,0x50,0xF3,0x40,0x06,0x1C,0x70,0xB2,0x7B,0x6B,0x62,0x4C,0x53,0x0D,0xB7,0xA5,0x75,0x5D,0x4C,0x5B,0x9B,0x85,0x5E,0x77,0xCA,0x2C,0xCF,0x65,0x06,0xDD,0x71,0xDA,0xA3,0x95,0x1A,0x64,0xE7,0xDC,0x0C,0x99,0x0F};
//const uint8_t spANY[] PROGMEM ={0xA7,0xAA,0x2D,0x53,0x54,0xD7,0xDE,0xEA,0x16,0xB7,0x28,0x45,0x88,0x92,0xAC,0xA3,0xAA,0x14,0x65,0x79,0x08,0xE6,0xD2,0x5B,0xAD,0xB6,0x2E,0x31,0xC1,0x9C,0xD3,0xBA,0x56,0x95,0xD5,0x7A,0x72,0x18,0x52,0x20,0xF3,0xDA,0x00,0x66,0xF0,0x52,0xB5,0xDA,0x0D,0xAB,0xD1,0x3B,0xE2,0x2D,0xB3,0xA2,0xC6,0xC0,0x9D,0xD9,0xCB,0xB5,0x98,0xBC,0x52,0x76,0xCF,0x34,0x0F};
const uint8_t spARE[] PROGMEM ={0xA7,0x70,0xB1,0xCE,0x29,0xD2,0xDD,0xFC,0xE6,0x37,0xBF,0xC5,0xA9,0x7C,0xC8,0x4E,0x95,0xE6,0xB7,0x3A,0x8D,0xAF,0x1E,0x19,0x9C,0xFC,0x76,0xAD,0xB3,0x43,0x32,0xDD,0xEA,0xE4,0xCE,0xF5,0xBE,0x2A,0x6B,0x73,0x22,0xD3,0xC5,0xE9,0x2C,0xCA,0xAE,0x1E,0x00,0x00};
//const uint8_t spAS[] PROGMEM ={0x27,0x2F,0x3D,0x53,0xD5,0x96,0x9E,0xA2,0xF4,0x4C,0x55,0x9F,0x77,0x8B,0x53,0x84,0x9E,0x29,0x96,0x4D,0x6F,0x75,0xAB,0x55,0xFB,0xE2,0x29,0x96,0x63,0x77,0xD3,0xDB,0xDE,0xE6,0x36,0xB4,0xAA,0x78,0x5A,0x54,0x58,0xD7,0xAA,0xE4,0xE1,0x31,0x91,0x4C,0x6B,0x79,0x59,0xE8,0xA4,0xC8,0xAD,0x02,0x16,0x11,0x95,0x00,0x07,0x28,0x40,0x81,0x07};
//const uint8_t spASSUME[] PROGMEM ={0xAD,0x31,0x29,0x43,0x23,0x27,0xCF,0xA6,0x37,0xA5,0xB1,0x3E,0x52,0x3D,0x2E,0xE5,0xC1,0x01,0x19,0x84,0x79,0xC0,0x03,0x0E,0x78,0x2E,0x3C,0x03,0x1E,0x68,0xA1,0xD5,0x19,0x1A,0xD9,0x6B,0x26,0x3D,0xE9,0x69,0xCD,0x7A,0x51,0xAB,0x52,0x1B,0xC7,0xA5,0x62,0xAA,0x73,0x1B,0x3B,0xDF,0xFB,0xC1,0x8E,0x76,0xB4,0xD3,0x03};
//const uint8_t spAT[] PROGMEM ={0x2B,0x8B,0xC9,0x3A,0x3D,0xA7,0xDC,0xE2,0x16,0xB7,0xD8,0x55,0x6F,0x62,0x03,0x00,0x0A,0xC8,0xCA,0xC5,0x00,0x4B,0xB8,0x11,0xC0,0xA9,0x60,0x80,0x07};
//const uint8_t spB[] PROGMEM ={0xAB,0xED,0xD1,0x14,0x5D,0xBB,0xAD,0xB6,0x45,0x57,0xF0,0xDE,0x3A,0x9A,0x59,0x94,0x31,0x62,0xCD,0x6E,0x76,0xB3,0x9B,0xD9,0xF4,0xB6,0xB6,0xB1,0xB7,0x3D,0xEF,0x1F,0x00,0x00};
//const uint8_t spBACK[] PROGMEM ={0xA7,0x4D,0x59,0xCB,0x39,0xD6,0x9D,0x21,0x54,0x6D,0x93,0xCE,0x76,0x86,0x54,0xAD,0xCD,0x3A,0xED,0xED,0x6F,0x77,0xDB,0xDB,0xDE,0x2A,0x17,0x00,0x08,0xD0,0xC2,0x44,0x01,0x21,0x8B,0x0A,0x20,0x79,0x27,0x04,0xB8,0x28,0xFC};
//const uint8_t spBASE[] PROGMEM ={0xA6,0xE6,0x3C,0x23,0x3D,0x12,0x9C,0x2A,0xE5,0x08,0x36,0xEE,0x76,0xAA,0x9C,0x4D,0x34,0xF2,0xE9,0xAD,0x4F,0x9D,0x93,0xB1,0x66,0x2E,0x5D,0x75,0xF6,0xC6,0x52,0x39,0xFB,0xD6,0xAD,0xC9,0x4A,0xC5,0x37,0x26,0xB7,0x36,0x67,0x15,0xD1,0x5A,0x92,0xBA,0xA9,0xCD,0x98,0xA2,0x8D,0x02,0x2E,0x17,0x51,0xC0,0xB3,0x2A,0x06,0xF8,0xD1,0xD4,0x00,0xBF,0x39,0x1B,0xE0,0x65,0x25,0x05,0x2C,0xD9,0x86,0x00,0x9B,0x0A,0x1E};
//const uint8_t spBE[] PROGMEM ={0xAB,0xED,0xD1,0x14,0x5D,0xBB,0xAD,0xB6,0x45,0x57,0xF0,0xDE,0x3A,0x9A,0x59,0x94,0x31,0x62,0xCD,0x6E,0x76,0xB3,0x9B,0xD9,0xF4,0xB6,0xB6,0xB1,0xB7,0x3D,0xEF,0x1F,0x00,0x00};
//const uint8_t spBETWEEN[] PROGMEM ={0xA1,0x86,0xA6,0x33,0x23,0x1C,0x9D,0xA2,0x5A,0x0B,0x4E,0xED,0x77,0xAA,0x6A,0xCD,0xD9,0x65,0xAF,0xE9,0x24,0x8D,0xB4,0x8A,0x54,0xC0,0x80,0x51,0x35,0x19,0x90,0x43,0x15,0x01,0xFC,0x34,0x43,0x00,0xEB,0xC2,0x2D,0xF3,0x22,0x33,0x1C,0x3A,0xAF,0x3C,0xE9,0x52,0x35,0xEE,0xBC,0x8A,0x9A,0x1C,0xA5,0xA2,0xF3,0xAC,0x56,0x35,0x6A,0x30,0x78,0xB4,0xDE,0xF5,0x6E,0x76,0xBB,0xBB,0xD9,0x85,0xCE,0x79,0xB2,0x0C,0x9D,0xED,0x5A,0x6B,0x61,0xC3,0xCA,0xB6,0x69,0xA4,0xE5,0x73,0x6B,0x4B,0xAA,0xE1,0x46,0xA7,0x34,0x63,0x88,0x46,0x2A,0x89,0xD6,0x4C,0xFC};
//const uint8_t spBLACK[] PROGMEM ={0xA4,0x12,0xBC,0x32,0x22,0x9C,0x94,0xDA,0x78,0x3B,0xD2,0xF4,0xBC,0xAA,0x60,0x65,0x0B,0x3D,0xDD,0xA9,0xAC,0x8B,0x4D,0xC8,0xA4,0xA7,0xF2,0xC9,0x4E,0x64,0xDC,0xDE,0xFA,0xD4,0xA1,0xF9,0x48,0xB4,0x9B,0xDB,0xEE,0xAE,0xF4,0xA1,0x73,0x5A,0x96,0xA1,0x3A,0xD8,0x01,0x40,0x00,0x71,0x38,0x09,0x20,0x16,0x05,0x06,0x24,0x9F,0x80,0x00,0x17,0x94,0x1E};
//const uint8_t spBLUE[] PROGMEM ={0x2D,0x0B,0x81,0xC7,0x94,0xD5,0x8F,0x2A,0x27,0x1C,0x27,0x71,0x3F,0xAB,0x55,0x59,0x97,0xA1,0x22,0x79,0x77,0xB5,0xAB,0x59,0xCF,0xB6,0x77,0xA1,0x17,0xB6,0x4B,0x03,0xB3,0xFB,0x9E,0x0D,0x2C,0x6C,0x4A,0x67,0x92,0x07,0x00,0x00};
//const uint8_t spBOTH[] PROGMEM ={0xA2,0x45,0x29,0xCD,0xAC,0xD2,0xAE,0x5A,0xFB,0x3C,0xA5,0xC8,0x73,0xAB,0x5B,0xAD,0x4A,0xB9,0xBA,0x40,0xEF,0xBA,0xEB,0x5E,0xA7,0x56,0x94,0x2E,0x21,0x7F,0x9E,0x3B,0xDB,0xC9,0x01,0x08,0x10,0xA5,0x8B,0x02,0x52,0x88,0xD2,0x80,0x01,0xB2,0x6B,0x23,0x80,0x6B,0xC1,0xF0};
//const uint8_t spBOTTOM[] PROGMEM ={0xA2,0x23,0xA2,0x3C,0x2C,0x9C,0xAF,0xCA,0xBB,0x7C,0x09,0x9D,0x73,0xAB,0x5D,0xAD,0xDA,0xA6,0x3A,0x36,0xAF,0xBB,0x9B,0xDE,0x28,0x40,0xAA,0x54,0x09,0x94,0xDA,0x36,0x5F,0xF2,0x70,0xD3,0xEB,0xDA,0xC4,0xD6,0x75,0xDA,0xEB,0xB0,0x97,0x1A,0xDF,0xD9,0x4E,0x0E,0x7C,0x78,0x00,0x00};
//const uint8_t spBUT[] PROGMEM ={0xAA,0xC5,0xA6,0xCC,0x2D,0xD2,0xAE,0x2A,0x18,0x7F,0x2B,0x59,0xBD,0xAB,0x5B,0xDD,0xEA,0xD6,0xB3,0x4E,0x8D,0xAD,0xE6,0x92,0x13,0x5A,0x36,0x00,0x00,0x0E,0xC8,0xCC,0x0D,0x01,0xDA,0x3B,0xC3,0x03,0x00,0x00};
//const uint8_t spBUY[] PROGMEM ={0xAE,0xC2,0xA6,0xCC,0x2D,0xD2,0x9E,0xC2,0xA7,0x78,0x91,0xC8,0x74,0xAB,0x53,0xB9,0x34,0xA3,0x30,0x8E,0x6F,0x75,0xAB,0x5B,0x9D,0xDA,0x95,0x6E,0x93,0xB1,0x7F,0xEB,0xDB,0xAC,0x2E,0x4C,0x4B,0xC9,0x96,0xDC,0xBB,0xD6,0x85,0xE2,0x61,0x19,0xA5,0x5B,0x1F,0x8A,0xA9,0x77,0x44,0xEE,0x7D,0xEE,0x62,0x2F,0xFB,0x07,0x00,0x00};
//const uint8_t spBY[] PROGMEM ={0xAE,0xC2,0xA6,0xCC,0x2D,0xD2,0x9E,0xC2,0xA7,0x78,0x91,0xC8,0x74,0xAB,0x53,0xB9,0x34,0xA3,0x30,0x8E,0x6F,0x75,0xAB,0x5B,0x9D,0xDA,0x95,0x6E,0x93,0xB1,0x7F,0xEB,0xDB,0xAC,0x2E,0x4C,0x4B,0xC9,0x96,0xDC,0xBB,0xD6,0x85,0xE2,0x61,0x19,0xA5,0x5B,0x1F,0x8A,0xA9,0x77,0x44,0xEE,0x7D,0xEE,0x62,0x2F,0xFB,0x07,0x00,0x00};
//const uint8_t spBYE[] PROGMEM ={0xAE,0xC2,0xA6,0xCC,0x2D,0xD2,0x9E,0xC2,0xA7,0x78,0x91,0xC8,0x74,0xAB,0x53,0xB9,0x34,0xA3,0x30,0x8E,0x6F,0x75,0xAB,0x5B,0x9D,0xDA,0x95,0x6E,0x93,0xB1,0x7F,0xEB,0xDB,0xAC,0x2E,0x4C,0x4B,0xC9,0x96,0xDC,0xBB,0xD6,0x85,0xE2,0x61,0x19,0xA5,0x5B,0x1F,0x8A,0xA9,0x77,0x44,0xEE,0x7D,0xEE,0x62,0x2F,0xFB,0x07,0x00,0x00};
//const uint8_t spC[] PROGMEM ={0x08,0xD0,0xB4,0x42,0x00,0x8B,0x88,0x3A,0xE0,0x2B,0xD5,0x00,0xFC,0x18,0xE6,0x81,0x08,0x78,0xC0,0x00,0x4F,0xAB,0x1C,0xA7,0xF8,0x60,0x31,0x7D,0x73,0xE2,0x1A,0x93,0xD8,0xED,0xEB,0x8D,0x6F,0x72,0xB3,0x51,0xF4,0x9A,0x02,0x1A,0x6F,0x77,0xB5,0xEB,0xD9,0x94,0xB6,0x34,0x22,0xA9,0xA9,0x93,0xBB,0xD0,0x25,0xC7,0x94,0x97,0xA1,0x4D,0xE7,0x95,0xF0,0x9E,0x18,0x35,0x5D,0xF4,0xA0,0xD3,0x29,0x4C,0x75,0xC1,0x82,0x86,0xB9,0xB3,0x07};
//const uint8_t spCAN[] PROGMEM ={0x0C,0x68,0x42,0xCC,0x00,0x33,0x2A,0x3B,0x20,0x69,0xD5,0x92,0xE6,0xE9,0xA6,0x9A,0x75,0x6F,0x75,0xAB,0x53,0xA5,0x6E,0x2E,0x5E,0x51,0x6F,0x7D,0x9B,0xDB,0xEC,0x66,0xB7,0xB3,0xE9,0x4D,0xAA,0xAD,0xA7,0x16,0x6D,0x37,0xB9,0xCE,0xB5,0xAB,0x64,0xE0,0x50,0x99,0xC4,0xBE,0xE6,0xCD,0x03};
//const uint8_t spCASSETTE[] PROGMEM ={0x0E,0xF0,0x25,0x48,0x03,0x1A,0x68,0xB9,0x49,0xCD,0xE1,0x1D,0xAB,0x56,0x06,0x58,0xD6,0xCD,0x02,0x16,0x70,0xC0,0xB7,0x19,0x16,0x90,0x40,0xAB,0xDC,0x30,0xF7,0xE8,0xBA,0xBB,0xDE,0xF5,0x6C,0x46,0xED,0x9A,0x85,0x79,0xC7,0xA9,0x95,0xAC,0x40,0x03,0x1E,0x20,0x80,0x54,0xA9,0x18,0x78};
//const uint8_t spCENTER[] PROGMEM ={0x02,0xF8,0x92,0x55,0x00,0xF7,0x1A,0x2A,0xE0,0x17,0x45,0x03,0xFC,0x16,0xEA,0x80,0x9F,0xD4,0x18,0x60,0x9A,0xEA,0xC9,0x43,0x2F,0x76,0xF5,0xAE,0xB7,0xBA,0xD5,0xA8,0xBC,0x57,0x4B,0x88,0x3A,0xB1,0x49,0x40,0x75,0x1E,0xAD,0x76,0x4D,0x34,0xD2,0x3A,0xDF,0x66,0x36,0xBD,0xA9,0x4D,0xAC,0x75,0x2D,0x9B,0x07};
//const uint8_t spCHECK[] PROGMEM ={0x0E,0x98,0xBD,0x32,0x03,0x11,0x60,0x00,0x73,0x1E,0x23,0x0E,0xD9,0xCD,0x33,0xC7,0xEC,0x74,0xA7,0x3B,0x9F,0x55,0x6F,0x7C,0x03,0x00,0x16,0xE0,0x00,0x06,0x30,0xF0};
//const uint8_t spCHOICE[] PROGMEM ={0x06,0x98,0xA9,0x2A,0x03,0x16,0x40,0x00,0x9B,0x9D,0x2B,0xB6,0x26,0x3B,0x92,0xF3,0xEE,0x64,0xA7,0x2B,0x8B,0x3A,0xC7,0x83,0xB3,0xED,0x6A,0xD5,0x31,0x8E,0x7A,0x50,0xE7,0xD9,0xB5,0x21,0x99,0x74,0x2D,0x6F,0x5C,0x06,0x5F,0x9C,0xD2,0x3B,0x4A,0x18,0x63,0x70,0x11,0x89,0x19,0x04,0xF8,0x5E,0x48,0x03,0x1A,0xB0,0x80,0x06,0x24,0x40,0x81,0x07,0x00,0x00};
//const uint8_t spCLEAR[] PROGMEM ={0x02,0x08,0xB1,0x28,0x00,0xDE,0x47,0x06,0xA0,0x3A,0x2B,0x01,0x38,0x5F,0xB9,0x62,0xA3,0x3A,0x25,0xA4,0xED,0x4E,0x4E,0x9A,0x92,0xB1,0x56,0xB4,0xB9,0xD9,0xCD,0x76,0x7E,0xAA,0x54,0x8D,0x35,0xBD,0xEB,0xAD,0x5A,0xED,0x17,0x66,0x9B,0x2D,0xAE,0x6D,0x6E,0x7D,0x67,0x3B,0xDD,0xCB,0xE1,0x01,0x00,0x00};
//const uint8_t spCOLOR[] PROGMEM ={0x0E,0x88,0xC7,0x35,0x00,0x31,0x15,0x7B,0x40,0x03,0x27,0xF6,0xAE,0xDA,0x4D,0xB2,0xDD,0x78,0xC4,0xDA,0x7D,0xB1,0xF2,0xEA,0x9E,0xE4,0xAC,0x17,0xAB,0x72,0x31,0x83,0x8B,0xDB,0xEE,0x66,0x76,0xA9,0xB7,0x4D,0x2D,0x9B,0xB6,0xC4,0x41,0x0F,0x7A,0x94,0xC3,0x03,0x00,0x00};
//const uint8_t spCOME[] PROGMEM ={0x0E,0x88,0xCD,0xD4,0x01,0xCE,0xB9,0x38,0x20,0xBA,0x54,0x05,0xC4,0x1C,0x1A,0x92,0x64,0xAA,0x2D,0x38,0xED,0xCD,0x6E,0x76,0x32,0x17,0xBA,0xD5,0xB8,0xC9,0xCD,0x77,0xD5,0x6A,0x9B,0xA5,0x54,0x28,0x4D,0x6C,0x63,0x1B,0xDB,0xD8,0xF9,0xCE,0xF6,0xB2,0xA7,0xFD,0x03};
//const uint8_t spCOMES[] PROGMEM ={0x06,0x08,0x5D,0xC5,0x01,0x3E,0x1A,0x1A,0x20,0x85,0x16,0x06,0xA8,0x6A,0x76,0x92,0x90,0xCB,0xCD,0xB5,0xF3,0x49,0x42,0xE8,0x74,0x97,0x26,0x37,0x3D,0xA9,0x4D,0x93,0x62,0x56,0x64,0x67,0xA3,0xB2,0x79,0x82,0x42,0x93,0xA4,0xC6,0x3B,0x2C,0x95,0xF0,0x1E,0x9B,0xD8,0xC6,0x36,0xB4,0xC6,0x72,0x89,0x94,0xDB,0xD0,0x5A,0xED,0x61,0x0E,0x8D,0x53,0xF7,0x0C,0x7A,0xB0,0xA4,0x35,0xC0,0x42,0x40,0x06,0xB8,0x82,0x4D,0x01,0x3F,0xB2,0x1A,0xE0,0x09,0xB6,0x07};
//const uint8_t spCOMMA[] PROGMEM ={0x01,0x08,0xD3,0x38,0x00,0xD1,0x84,0x3A,0x20,0xA5,0x75,0x02,0xA8,0x63,0xB6,0x22,0xDB,0x2B,0xDC,0xBD,0xCE,0x4D,0x6E,0xB2,0x12,0xDD,0xCE,0x25,0x3D,0x4E,0x2B,0x6C,0x96,0x52,0xA1,0x34,0xBD,0xAA,0xD5,0x68,0xF4,0x68,0xB1,0xB0,0x04,0xBD,0x6D,0xBD,0x8D,0xED,0x21,0xD8,0xA8,0x0E,0x7E,0xD0,0xFD,0x03,0x00,0x00};
//const uint8_t spCOMMAND[] PROGMEM ={0x06,0x08,0xDB,0x58,0x01,0xDE,0x25,0x1B,0xC0,0x64,0xE5,0x53,0x25,0x53,0x6D,0xC1,0x69,0x6F,0x75,0xAB,0x51,0x85,0x40,0xE5,0x60,0xC9,0x67,0x35,0xAB,0x55,0xC5,0x9A,0xDA,0x94,0x55,0x6F,0x75,0xAB,0x5D,0xEF,0x66,0xB5,0xBE,0x7B,0x9A,0x65,0xD4,0xD9,0xB5,0xCE,0x16,0x0B,0xD2,0xB2,0x5C,0x7B,0xD3,0x2B,0xCB,0x9D,0xDC,0x89,0x6D,0xAF,0x7B,0xDD,0x9B,0x9E,0xA9,0x88,0xB4,0x88,0x6B,0x7A,0xE2,0x32,0x3C,0xCB,0x66,0xE8,0xAD,0xB1,0x50,0x9F,0x06,0xB6,0x7F};
//const uint8_t spCOMPLETE[] PROGMEM ={0x06,0x08,0xB9,0x65,0xE4,0xB6,0x54,0xB8,0x78,0x92,0x5D,0xED,0xAA,0xD4,0x2E,0x70,0x0B,0x9B,0x9A,0xDC,0x86,0xD6,0x7B,0x6C,0xA5,0xD4,0xEA,0x3A,0xE1,0xDD,0x13,0xCA,0x8E,0xE9,0x8D,0x32,0x0F,0x35,0x27,0x00,0x06,0xF0,0xD6,0xDC,0x02,0x25,0xF1,0xB2,0x3C,0xD4,0x16,0xEF,0x64,0x65,0x4E,0x87,0x56,0xC4,0xAC,0x51,0x04,0x2B,0xDC,0x99,0x75,0x5A,0x15,0x0C,0x6B,0x6D,0x26,0xEC,0x8D,0xEB,0xAD,0xC1,0xEE,0x28,0x2B,0xB2,0xC7,0x33,0x00,0x30,0xA0,0xB1,0x34,0x0D,0x70,0x80,0x02,0xF0};
//const uint8_t spCOMPLETED[] PROGMEM ={0x02,0xD0,0xC5,0x99,0x03,0xAD,0xD2,0x35,0x52,0xD3,0x12,0xEF,0xBA,0x34,0xA9,0xE0,0xB2,0x88,0x96,0xD0,0xD8,0x88,0xCF,0x11,0x5E,0x7D,0x23,0x7B,0x10,0x40,0xAD,0xE2,0x1E,0x70,0x40,0xD1,0x9A,0x27,0xF1,0xC6,0x23,0x24,0x32,0x9F,0xD4,0x79,0x33,0x8F,0x6A,0xB5,0xD2,0x14,0x49,0xDD,0x7B,0xF1,0x4C,0x43,0x1E,0x1B,0xB3,0x64,0x6C,0x42,0x00,0xF0,0x15,0x02,0x70,0xDC,0x2D,0xD5,0x25,0x9A,0xA3,0xEB,0xB6,0x5D,0xDF,0x76,0x77,0xA5,0x4F,0xC1,0x8D,0x0D,0xBE,0x88,0x81,0xE9,0xC8,0x88,0xCC,0xC8,0x07,0x31,0x2A,0xE9,0x96,0x9E,0x0E,0xED,0xF0};
//const uint8_t spCOMPUTER[] PROGMEM ={0x0A,0x08,0x79,0xC4,0x02,0xA7,0x8A,0xCE,0xD3,0x03,0xDA,0xEE,0xAA,0xD7,0xA5,0xB6,0x59,0x4A,0x85,0xD2,0xD8,0x16,0x8F,0x02,0x60,0x21,0x32,0x00,0x29,0x2B,0x5A,0xE0,0x24,0x25,0x85,0x82,0x5B,0x9F,0x9D,0xAC,0x34,0x38,0x4B,0xB1,0xC8,0x33,0x33,0x07,0x74,0x1D,0x91,0x2A,0xDF,0x34,0xA9,0xAD,0xED,0xAC,0x66,0x3B,0xFB,0xD6,0xBB,0xA6,0xAA,0x1B,0xE9,0xC3,0x60,0x3B,0xFB,0x14,0xA5,0x76,0x83,0xAD,0xE4,0xE9,0xE6,0xDA,0x0C,0x21,0x5A,0x92,0x7A,0xAA,0x07};
//const uint8_t spCONNECTED[] PROGMEM ={0x0E,0x88,0xC7,0x35,0x00,0x31,0x15,0x7B,0x20,0x24,0xB1,0x78,0x5A,0xD8,0x92,0x9B,0x9F,0xDC,0xE7,0x70,0x53,0x9F,0x93,0x72,0xEF,0x5D,0x1D,0x2D,0x6D,0x2F,0x4E,0x96,0x72,0x84,0x43,0xD5,0x39,0x69,0x6E,0x91,0x86,0xDD,0x66,0xA4,0x69,0x59,0x90,0x8F,0xEB,0x94,0x45,0xED,0xAA,0x62,0x4A,0x78,0x0D,0x00,0x0A,0x90,0x41,0xA3,0x65,0x25,0x9A,0xA3,0xEB,0xB6,0x59,0xEC,0xAA,0xB6,0xA2,0x17,0x26,0x2C,0xC3,0x33,0xC6,0xDE,0xF6,0xAA,0x57,0xD2,0x2D,0x3D,0x1D,0xBA,0xA6,0x44,0x15,0x16,0xC9,0xAC,0xFA,0x18,0x45,0x94,0xA2,0x26,0xC0,0x03,0x00,0x00};
//const uint8_t spCONSOLE[] PROGMEM ={0x02,0xF0,0x31,0xC0,0x02,0x1A,0xE0,0xC0,0x8A,0x5D,0x9C,0x70,0x4D,0x3B,0x37,0xB9,0xC9,0x4E,0x52,0xAA,0xBD,0xB9,0xC2,0x68,0xF1,0x99,0x2D,0x74,0xED,0x80,0xAD,0xDC,0x33,0x10,0x01,0x0B,0xB4,0x4A,0xBB,0x4E,0x4D,0xAF,0x5B,0x6A,0xB1,0xAA,0x54,0xB2,0x5B,0x6E,0x63,0x1F,0x07,0x3F,0x98,0x81,0xD5,0x57,0xD3,0x72,0xA3,0x07,0x3D,0x88,0x91,0xB6,0x0B,0x11,0x73,0xC2,0x47,0x3A,0x3E};
//const uint8_t spCORRECT[] PROGMEM ={0x0E,0x70,0xC7,0x49,0x00,0x3E,0x86,0xA5,0x58,0x8D,0x2C,0x53,0xCD,0x76,0x8B,0x56,0x98,0x23,0x95,0xA2,0x99,0x6B,0x95,0x9B,0xDA,0xAC,0xCA,0x27,0x6D,0xF1,0x8D,0xBD,0xAB,0x59,0xF7,0x26,0xB5,0xBE,0x73,0x79,0x4D,0x90,0xDC,0xB9,0x21,0x0C,0x28,0x8F,0x91,0x29,0x47,0x00,0x00,0x01,0x0C,0xED,0xAA,0x80,0xE5,0xA2,0x05,0xD0,0x74,0x3B,0x02,0xBC,0x4B,0x7A,0x00,0x00};
//const uint8_t spCOURSE[] PROGMEM ={0x0A,0x70,0xC7,0x49,0x03,0x1A,0x48,0xA1,0xEC,0xB5,0xA4,0xDE,0xA5,0x86,0x35,0xAA,0xD1,0x48,0xD4,0xC8,0x32,0xD5,0x6C,0x2D,0x37,0x47,0x2A,0x45,0x33,0xF7,0xAA,0x36,0xB9,0x63,0xC0,0x29,0x6E,0x1A,0x30,0xC0,0x4F,0xEE,0x16,0xD0,0x80,0x00,0x7E,0x31,0x42,0xC0,0xDF,0x8E,0x08,0xF8,0x4B,0x19,0x01,0xD7,0x92,0x3D,0x00,0x00};
//const uint8_t spCYAN[] PROGMEM ={0x06,0xF8,0x56,0x4D,0x03,0x1A,0xB0,0x80,0x04,0x52,0x68,0x52,0xA6,0xCB,0xD8,0xDD,0xF1,0x8E,0x77,0xBC,0xE2,0x30,0x22,0x9C,0x26,0xCE,0x8E,0x77,0xBC,0xD2,0xD4,0x5D,0x9D,0xB2,0xFA,0xCD,0x77,0xB5,0xAB,0xDD,0x8C,0xD6,0x95,0x30,0x2D,0x8F,0x34,0xBB,0xDA,0x85,0x41,0x45,0x71,0xE3,0x4E,0x6C,0x07,0x3D,0x88,0x41,0x45,0x55,0xD7,0x4C,0x6D,0x87,0x07};
//const uint8_t spD[] PROGMEM ={0x0C,0x10,0xD2,0x62,0x64,0xD9,0x2B,0x4B,0xE6,0xE9,0x91,0xE5,0x28,0x2C,0x53,0x83,0x56,0x96,0x8D,0x88,0x6E,0x4D,0x1A,0x59,0x09,0xC2,0xB2,0x35,0x79,0xE6,0xA3,0xEA,0x49,0x19,0xAA,0xC7,0xF4,0xAA,0xD7,0xBD,0xAD,0x9D,0x1F,0xDC,0xD4,0x92,0x12,0x76,0x0F,0x71,0xFD,0x88,0x82,0x32,0x55,0xE5,0x01};
//const uint8_t spDATA[] PROGMEM ={0xAC,0x85,0x6E,0x22,0x2A,0x24,0xB3,0x96,0xA8,0xCC,0x4C,0x77,0x30,0x9A,0x99,0xCA,0x99,0x3D,0xC9,0xC9,0x63,0x52,0x93,0xD8,0xB9,0xB7,0x5A,0x79,0x1E,0x2C,0xE6,0xD3,0x66,0xE7,0x3B,0x37,0x00,0x33,0x9A,0x0E,0x28,0x3E,0xB9,0xD5,0xD1,0x3B,0x1B,0xE6,0x8C,0xD1,0xB8,0x6C,0x29,0x31,0x49,0x66,0x3B,0x7A,0xE7,0xB3,0xDC,0xE3,0x6E,0x19,0x5D,0x0F,0xD3,0xE8,0x2A,0x71,0xF2,0xB3,0x19,0xA3,0xB3,0x30,0x28,0xCB,0xAC,0x0B,0xB7,0x58,0xC9,0x9D,0xC0,0x03,0x00,0x00};
//const uint8_t spDECIDE[] PROGMEM ={0xAD,0x1A,0x2C,0x54,0x24,0x32,0xAF,0xAA,0xD8,0x70,0x51,0xD9,0xAA,0xAA,0x18,0x3D,0x44,0x6A,0xAE,0x01,0x7E,0x14,0x8D,0x40,0x04,0x02,0xF0,0x93,0x69,0x04,0x22,0xA0,0x81,0x11,0x06,0x17,0xED,0xD4,0xB1,0x47,0xEA,0x52,0xA7,0x49,0xC6,0x99,0xD9,0xCC,0x7B,0xD1,0x2A,0xD7,0x32,0xC5,0xDB,0x4A,0xAF,0x4A,0xED,0x77,0x24,0x65,0xC9,0x6E,0xAD,0xDF,0x96,0x1C,0x2D,0xA7,0xF5,0x3E,0xBB,0x44,0x47,0xD0,0xDE,0xD7,0x3E,0xF5,0x36,0xB3,0x57,0x56,0x98,0xD4,0x3B,0xE7,0x6C,0xE5,0x95,0x44,0x8F,0x43,0x7A,0x95,0xC9,0x16,0x3D,0xB6,0xE5,0x15,0x69,0xEB,0x01};
//const uint8_t spDEVICE[] PROGMEM ={0xC0,0x00,0x62,0xDD,0x4E,0x35,0xBC,0x27,0x99,0xF4,0x3B,0x55,0x31,0x9E,0x14,0xDA,0xAD,0x35,0xD5,0x58,0x51,0x90,0xBB,0xDC,0xBA,0xD6,0x69,0x0F,0x65,0xCA,0x73,0xAA,0x60,0xA6,0x85,0xBD,0xF5,0xCD,0x6E,0x76,0xD3,0x93,0x66,0x3D,0x55,0x42,0x8D,0x6F,0x76,0x8A,0xE4,0xC7,0x5D,0xAC,0xF6,0x6D,0xC7,0x18,0xA3,0x69,0xDA,0x94,0x29,0x83,0x4F,0x52,0x99,0x17,0x2A,0x0C,0x2E,0x18,0x75,0x76,0x29,0x01,0x68,0xD0,0x2A,0x80,0x3F,0x59,0x1D,0xF0,0x8B,0x9B,0x03,0xBE,0x15,0x53,0xC0,0x8F,0x22,0x0A,0xF8,0x89,0x89,0x01,0xDF,0xB0,0x10,0xE0,0x59,0xD6,0x07};
//const uint8_t spDID[] PROGMEM ={0xA2,0x13,0xCC,0xCA,0xD3,0x6D,0xA5,0x6E,0x48,0x63,0x55,0x76,0x32,0xF2,0x11,0xDA,0x20,0x65,0xEB,0xCA,0x6B,0x2C,0x01,0xB3,0x35,0x2B,0x4D,0xD9,0x51,0x2A,0x5F,0xAF,0x24,0x45,0x47,0xED,0xBC,0xB5,0xD2,0x18,0x9D,0xAD,0xEA,0xF6,0xC8,0xA2,0x77,0xD6,0xCA,0x27,0xA3,0xAA,0x26,0x8C,0xAB,0xB6,0xB6,0xAE,0xD9,0x70,0x0A,0x7B,0xDB,0xFA,0xE2,0xC2,0x28,0xEC,0x69,0x1D,0x7C,0x0F,0xA6,0xCF,0x4C,0x45,0x2C,0xDD,0xB8,0xAE,0x28,0x17,0xF1,0xD8,0x20,0xC6,0x5C,0xC3,0x04,0x6D,0xEA,0x03,0x00,0x00};
//const uint8_t spDIFFERENT[] PROGMEM ={0xAC,0x6A,0x3E,0x8C,0x4D,0xF6,0xFA,0xEA,0xD6,0xB7,0x58,0x79,0x4A,0x6E,0x62,0xF9,0x66,0xA5,0xAE,0xAA,0x59,0x76,0x99,0x50,0x8F,0x5C,0xA1,0x8C,0x4E,0x18,0x10,0xA4,0xAA,0x00,0x54,0xB4,0x74,0x40,0x76,0x65,0x2A,0xB6,0x13,0xCB,0x13,0xF3,0xF4,0x6A,0xD4,0x6E,0x52,0xD8,0x90,0xBF,0xD1,0xF8,0xCD,0xA9,0x8D,0x5D,0x4F,0xEB,0xAB,0xA5,0xB9,0x36,0x3F,0x7D,0x88,0x1D,0x14,0xD6,0xA6,0xF7,0x61,0x50,0x52,0x23,0xB5,0x42,0xD9,0x41,0xF5,0xD6,0x8A,0x26,0x79,0x6A,0x50,0x40,0x37,0x66,0x06,0x38,0xD4,0x4C,0x00,0x5E,0x34,0x12,0x40,0x44,0x37,0x00,0x78};
//const uint8_t spDISKETTE[] PROGMEM ={0xAD,0x5F,0xD6,0x95,0x19,0xEC,0x9E,0x2A,0xE5,0x50,0xD6,0x5A,0x7A,0xAA,0x18,0x9D,0xAD,0xEA,0x76,0xAB,0xAB,0x09,0xE3,0xAA,0xAD,0x01,0xF8,0xD9,0x2D,0x03,0x09,0xF8,0xD1,0xCC,0x00,0x15,0xAF,0x82,0x01,0x6A,0x31,0x33,0x40,0x8B,0x4A,0x27,0x4E,0xC9,0xA9,0xAD,0xE6,0xDC,0xE4,0xA4,0x39,0x59,0x99,0xE6,0xDC,0x9B,0xDF,0x6A,0xD5,0x31,0x5A,0x39,0x6F,0xCC,0xD8,0x02,0x80,0x02,0xA2,0x74,0x55,0xC0,0x91,0x16,0x0A,0x18,0xDC,0x1C,0x1E};
//const uint8_t spDO[] PROGMEM ={0x2E,0x4E,0x80,0xB3,0x32,0x6D,0x8D,0x22,0x44,0x53,0x4B,0xFB,0x7C,0xB2,0x22,0xAC,0xA8,0x2C,0xFB,0x4E,0x76,0x32,0xD3,0x99,0xB5,0x22,0x51,0x6B,0x49,0xC9,0xDE,0xAB,0xD6,0x38,0x11,0xA9,0x2E,0xD9,0x6B,0x1B,0x7A,0x69,0x2A,0xCD,0xB5,0x9B,0xEF,0x6D,0xAF,0x87,0x07};
//const uint8_t spDOES[] PROGMEM ={0xAD,0x4E,0xDE,0x4D,0x4D,0xDE,0xDC,0x7C,0x25,0x26,0x7B,0xB9,0x4D,0x95,0x9D,0xCE,0x74,0xA6,0xAB,0xF0,0x21,0xD3,0xD3,0x16,0xCF,0x6A,0x36,0xB3,0xE9,0x5D,0xE9,0xAC,0xF7,0x70,0xF7,0x2B,0xB9,0xCB,0x9D,0xEB,0xB5,0xF7,0x74,0x8F,0xD1,0xBE,0x67,0x40,0x05,0xEC,0x1A,0xE0,0x00,0x05,0x1E};
//const uint8_t spDOING[] PROGMEM ={0xAD,0x49,0xC1,0x54,0x9D,0xF7,0xEE,0x64,0x64,0x3E,0x58,0x9A,0xE9,0xAE,0x94,0x88,0x6E,0xEE,0x5E,0x23,0x62,0x52,0xD3,0x90,0x89,0x6E,0xAE,0x99,0x13,0x4B,0x61,0x8A,0xB9,0x79,0x9C,0x6E,0x55,0x6B,0x65,0xE8,0xBC,0x75,0x36,0xBB,0x9D,0x5D,0xEB,0xEA,0x4A,0xC6,0xF0,0xD6,0xB9,0xB7,0xBD,0xEE,0x45,0x6F,0x1D,0x76,0x50,0xC5,0x11,0x9D,0x75,0xD4,0x41,0x15,0x9B,0xF5,0xD2,0x6A,0x14,0x65,0x43,0xD2,0x6B,0x65,0xEA,0xE2,0x6E,0x1E,0x00,0x00};
//const uint8_t spDONE[] PROGMEM ={0xC0,0x32,0xA6,0x22,0xD2,0xC3,0x36,0xAB,0x88,0xAA,0x4A,0x8B,0xD8,0xA9,0x8E,0xC1,0xD2,0x2C,0x9E,0xDE,0xEA,0x56,0xA7,0x8A,0x3E,0x2A,0x35,0x52,0xDF,0xEA,0x54,0xD1,0x45,0xA7,0x44,0xEA,0x53,0x05,0x1F,0xE5,0x1E,0x89,0x4F,0x1D,0x42,0x94,0xBB,0x47,0x5D,0x8D,0x0F,0x51,0xEE,0x1E,0xB7,0xB5,0x3E,0x78,0x84,0x79,0x96,0xD0,0x05,0x0F,0x6D,0x19,0x6A,0x42,0x17,0x3C,0xB4,0x65,0xA8,0x56,0x9D,0x0B,0x30,0x16,0xA9,0xDA,0x8C,0xDA,0xD2,0x8C,0xB6,0x02,0x3D,0xF1,0x89,0x4E,0x0F};
//const uint8_t spDOUBLE[] PROGMEM ={0xAB,0x2E,0xC2,0x2D,0xCB,0x52,0xAD,0x3A,0x79,0x4B,0xB7,0x59,0x7B,0x2A,0xE3,0xFD,0x46,0x24,0xFD,0xAD,0x6E,0xB5,0x2B,0xD1,0x12,0xDF,0xAE,0x12,0x6D,0x5D,0x23,0x7D,0x5D,0x08,0xA7,0xEE,0x75,0x6B,0x78,0xEB,0x53,0xE6,0xD6,0xB5,0x4D,0x1D,0x5B,0x3D,0x4C,0x9E,0x3A,0x0E,0x7A,0xC0,0xC3,0x03,0x00,0x00};
//const uint8_t spDOWN[] PROGMEM ={0xAE,0x49,0x32,0xCC,0x35,0x95,0x8C,0x36,0x79,0x37,0x35,0x79,0xB3,0x0A,0xEF,0xA7,0x4D,0xA3,0xEE,0x2E,0x76,0xB5,0xAB,0xDD,0xCC,0xB6,0xB5,0x26,0xF4,0xAA,0x58,0xBA,0xDE,0xF5,0xAE,0xF6,0xA1,0x0F,0x1E,0xDA,0x32,0xD4,0x84,0x21,0x78,0x68,0xCB,0x50,0x1D,0x07,0x37,0x6A,0x4B,0x33,0xDA,0x0A,0xEC,0xA8,0x47,0x3E,0xD2,0xE9,0x01};
//const uint8_t spDRAW[] PROGMEM ={0xAE,0x70,0xBD,0x54,0xD2,0xE4,0xB6,0x7A,0xC4,0x34,0x07,0x92,0x3A,0xAA,0xE0,0x53,0xD9,0xDD,0xE9,0xA8,0x4C,0x51,0xF7,0x84,0xE4,0xAB,0x32,0xDE,0x4F,0x9D,0xDB,0xDE,0x6A,0x55,0xC6,0xE7,0x27,0x59,0xFA,0x5D,0xED,0x6A,0x57,0xB3,0x9E,0x4D,0x6B,0x55,0xE9,0x55,0x76,0xAF,0xA9,0x93,0xA3,0x86,0xCD,0x3C,0x84,0x4E,0xEC,0x4A,0x87,0x74,0x1A,0x5A,0xB9,0xD3,0x8D,0x33,0x9C,0xEB,0x94,0xF7,0x12,0x33,0xC9,0xAA,0xF3,0xCE,0xD2,0x20,0xE4,0x3C,0x00,0x00};
//const uint8_t spDRAWING[] PROGMEM ={0xA6,0x0B,0x3E,0x95,0xDD,0x9D,0xBA,0xCE,0x14,0x75,0x4F,0x48,0xDE,0x6A,0xE3,0xFD,0xD4,0xB9,0xED,0xAC,0x5B,0xE5,0xE4,0xAE,0x1B,0x66,0x9F,0xC5,0xCC,0x67,0x36,0xB3,0x9E,0xF7,0x62,0x54,0xD6,0x4D,0x99,0x48,0xDB,0xD5,0x84,0xD0,0x65,0xCA,0x69,0x4F,0x57,0x42,0xA7,0x38,0x67,0x3D,0x5D,0x4B,0x93,0x64,0x94,0xF5,0xF6,0x7B,0x28,0xC3,0x0C,0xAA,0xD0,0xD5,0x5A,0x0D,0xDA,0xD1,0x94,0xB6,0x45,0x3D,0xE8,0x41,0x0C,0xDA,0xD1,0xA6,0x86,0x05,0x35,0x68,0x67,0xDC,0xE1,0x8E,0xD5,0x60,0x95,0x53,0x35,0x45,0x94,0xE3,0x03};
//const uint8_t spE[] PROGMEM ={0x21,0x2A,0x81,0x49,0xB7,0x2B,0xD7,0xB4,0xA7,0x33,0xDB,0xD9,0xCE,0x77,0xBE,0xF3,0x51,0xD4,0x22,0x84,0x5D,0x4B,0x66,0xD5,0xAB,0x5A,0x31,0x80,0x59,0x79,0x53,0x3B,0x61,0xE6,0xE7,0x35,0x1F};
//const uint8_t spEACH[] PROGMEM ={0xAB,0xE8,0xD1,0x19,0xB2,0x9F,0x8C,0x62,0x24,0x63,0xA8,0x99,0xB3,0x8B,0x5D,0xCC,0xAA,0x35,0xA3,0x99,0x40,0xD4,0x1D,0xDF,0xE1,0x0E,0x80,0x00,0x33,0xB2,0x2A,0x60,0xEF,0x0C,0x0B,0x28,0xE0,0x9C,0x4E,0x01,0xAC,0x69,0xA9,0x80,0x6E,0xCD,0x00,0x01,0x7E,0x90,0x3D};
//const uint8_t spEIGHT[] PROGMEM ={0x2D,0x2F,0xC5,0x54,0xA3,0x63,0xB5,0xBC,0x54,0x55,0xCD,0x1E,0x32,0xB2,0x5A,0x85,0xB8,0xBA,0xCE,0xCE,0x66,0x36,0x8B,0x56,0xD5,0x22,0xC8,0x55,0x73,0x63,0x2F,0x07,0x00,0x00,0x02,0x44,0x6D,0xCA,0x01,0x04,0x18,0x21,0x86,0x81,0x07};
//const uint8_t spEIGHTY[] PROGMEM ={0x20,0x00,0x2B,0x2D,0x4E,0xD1,0x52,0x32,0x57,0xAC,0x39,0x59,0x4D,0xC6,0xDA,0xBD,0x66,0x25,0x2D,0x0B,0xC9,0x74,0xAB,0x1B,0xCF,0x44,0xD6,0x0A,0x10,0x28,0x2A,0x14,0xBD,0x38,0x41,0xD6,0xD2,0x59,0xED,0x7A,0x74,0xBD,0x19,0x43,0xF6,0xD2,0x3C,0xF8,0x49,0x4F,0x7C,0x79,0x00,0x00};
//const uint8_t spELEVEN[] PROGMEM ={0xA7,0x1E,0xC1,0x1C,0xC3,0xD6,0xDE,0xFA,0xD4,0xA9,0xA5,0xA1,0x45,0x9B,0xD5,0xC4,0x10,0xC6,0x94,0xE9,0x76,0xBD,0x6A,0xAF,0x2B,0xD9,0x37,0xEE,0xA9,0x42,0x4F,0x75,0xAB,0xB8,0xB7,0xB8,0xF9,0xCD,0x57,0xEE,0x53,0x89,0xBB,0xD7,0x73,0xAD,0x8D,0x2D,0x1E,0xDC,0x38,0xB7,0xBB,0x9D,0x7D,0x19,0x5C,0x49,0x29,0xD1,0x46,0x6E,0xB4,0x51,0x5D,0x49,0x9A,0xBA,0xC9,0x04,0x36,0xE7,0x4C,0xA2,0x66,0x13,0xC4,0x02,0x2B,0x91,0x98,0x6C,0x14,0x33,0xC9,0xC4,0x62,0x52,0xC1,0x34,0x24,0x52,0x3F};
//const uint8_t spELSE[] PROGMEM ={0x21,0x4B,0xC5,0xDC,0x34,0x27,0x97,0xCC,0x67,0xF7,0xD0,0x5E,0x7A,0x8B,0x5B,0xDD,0x6A,0x54,0x3A,0x6D,0x84,0xFA,0xBC,0x56,0x29,0xFF,0xA3,0xCE,0x69,0x6A,0x53,0x5B,0xD7,0x89,0xD0,0xB1,0x40,0x75,0x54,0x5F,0x4D,0x90,0x8B,0xD8,0x56,0xC0,0x95,0xC5,0x16,0x70,0x40,0x07,0x26,0x1A,0x60,0xC0,0xC1,0x6A,0x0C,0xF8,0xD2,0xF2,0x01};
//const uint8_t spEND[] PROGMEM ={0xA3,0xC8,0x4D,0x4D,0x3C,0x63,0x9F,0xA2,0xB4,0x34,0x51,0x5F,0x7B,0xF3,0x93,0xE5,0x96,0xA6,0x9A,0x73,0x4F,0x56,0x4A,0xA9,0x54,0xCD,0x3D,0x59,0xC9,0xA5,0x5A,0x33,0xE7,0xE4,0x25,0x96,0x8A,0xD9,0xEC,0x53,0xE5,0x54,0xAC,0x66,0x53,0x4E,0x9D,0x4A,0x9A,0xA8,0xCE,0x59,0x4D,0xCC,0x65,0x64,0x36,0x6B,0x74,0xC9,0x57,0xA1,0xCB,0xEC,0xD0,0xEB,0xA0,0xA6,0xE6,0xB5,0x5D,0xAF,0x02,0x97,0xD8,0x38,0x70,0xBD,0x0C,0x5C,0xE2,0x1D,0xCB,0xF4,0xD2,0x51,0x9B,0x4E,0x2C,0x35,0x68,0x8B,0x6B,0x36,0x91,0xE4,0xC8,0xA7,0x30,0x15,0xE5,0x22,0x1E,0x1B,0xF4,0x28,0x86,0x14,0x53,0x5D,0xB3,0xD6,0x03};
//const uint8_t spENDS[] PROGMEM ={0xA7,0xCA,0x39,0xC5,0xCC,0x6B,0x9F,0x2A,0xD7,0x30,0x93,0xA8,0x73,0xAA,0x5C,0xD3,0x55,0xB2,0xEE,0xAD,0x6E,0x75,0xAA,0xD8,0xDD,0xC5,0x2A,0xEA,0xAD,0x6E,0xB3,0xBB,0xD6,0xD9,0x6C,0x6A,0x92,0x95,0x43,0xEF,0x34,0x4C,0xB5,0xD2,0x8D,0x7D,0x1C,0xFC,0x68,0x27,0xD7,0x71,0x23,0x5F,0xEA,0x4C,0x7C,0x47,0x00,0x2C,0x2B,0x04,0x30,0x65,0x84,0x04,0x24,0xC0,0x01,0x0A,0x3C};
//const uint8_t spENTER[] PROGMEM ={0xA7,0x28,0x39,0x4C,0x43,0xEF,0x9C,0xA2,0x94,0x34,0x31,0x7D,0x72,0xF2,0xD2,0xD4,0x8D,0xBD,0xC9,0xCD,0x52,0xCE,0xBC,0x77,0xE8,0x99,0xCA,0x85,0x03,0x4A,0x70,0x77,0x40,0xE3,0xE2,0xA3,0xF0,0x53,0xD4,0x9D,0xD7,0xCE,0xB6,0xF7,0x61,0x34,0x1D,0xAA,0xC2,0x16,0x99,0xC9,0x74,0xD6,0xF6,0x88,0xAD,0x26,0x9D,0xD8,0xC6,0x5D,0xF1,0x03,0x00,0x00};
//const uint8_t spERROR[] PROGMEM ={0x2B,0xAF,0xC9,0x9C,0xDC,0x97,0x9E,0xBC,0xE5,0x34,0x72,0x5F,0x77,0xF2,0x58,0x4D,0x35,0xA3,0xEB,0xCD,0x5A,0x6A,0x07,0x7B,0x27,0xAD,0xEA,0x59,0xCF,0x5B,0xE5,0xB6,0x89,0x37,0x6E,0xED,0x55,0xAF,0x7B,0xD7,0xFB,0x3A,0xF4,0xA1,0x8D,0xB6,0xB9,0xE8,0xD3,0x56,0x37,0xB9,0xA9,0x1A,0x43,0x5B,0xCC,0xEC,0x16,0x66,0xAB,0xA5,0x72,0x8B,0xAB,0x66,0xC6,0xA3,0xE4,0x01,0x00,0x00};
//const uint8_t spEXACTLY[] PROGMEM ={0xA7,0x2A,0x35,0x95,0xC3,0xD7,0xDE,0x7A,0x37,0xA3,0xC9,0xCD,0x48,0xCB,0xD7,0xE4,0x3A,0x36,0xAD,0x89,0x51,0xC0,0xDB,0x1A,0x05,0xA0,0x03,0x54,0x07,0x74,0x80,0x3A,0x8A,0xC9,0xC3,0x55,0xC2,0xCB,0xC9,0xE3,0x8E,0x30,0x1A,0x27,0x37,0xBF,0xF9,0xCD,0x6F,0xB6,0xF2,0xBC,0x25,0x24,0xDA,0x16,0x02,0x70,0x34,0x03,0x20,0x80,0x97,0xCA,0x01,0x48,0x51,0xDD,0x02,0xA5,0x90,0x25,0xDD,0xCC,0x96,0xF4,0x6A,0xF4,0xA1,0x99,0x89,0xD6,0xD5,0x3A,0x84,0x21,0x24,0xE8,0xAC,0x8B,0x1E,0x46,0x6D,0x3D,0x76,0xCC,0x94,0x19,0x8D,0x93,0xBA,0x34,0x51,0xF0};
//const uint8_t spEYE[] PROGMEM ={0x23,0x09,0xDE,0x27,0x82,0xBB,0xED,0xEC,0x16,0xB7,0xBE,0xF5,0x6D,0x4E,0x13,0xB2,0x97,0x5B,0xB4,0xDD,0xDD,0xEA,0x42,0xF6,0x70,0x8F,0x39,0xAD,0x8F,0x85,0xDB,0xBC,0xCB,0x94,0x3E,0x64,0xD5,0x1C,0x0B,0x95,0x07,0x37,0x78,0x27,0xB9,0xA9,0x86,0x4D,0x1F,0x3C,0xD3,0xA4,0x1B,0x96,0x35,0xAF,0xE1,0x01,0x00,0x00};
//const uint8_t spF[] PROGMEM ={0x2B,0x8B,0x25,0x4A,0xAC,0x13,0xEF,0xEC,0xE6,0xB7,0xB8,0xD5,0xAD,0x6E,0xBD,0x5A,0x1F,0x23,0xD8,0x63,0xD2,0xEE,0xFA,0xE8,0x80,0x68,0x4D,0x3C,0x60,0x01,0x0D,0x68,0x80,0x02,0x0F};
//const uint8_t spFIFTEEN[] PROGMEM ={0x0A,0xE8,0x26,0xD4,0x02,0x27,0x2C,0x29,0x84,0xCD,0xDE,0xDC,0xE4,0xA6,0x35,0x8B,0xB9,0x01,0x8A,0x0A,0x54,0x40,0x91,0x1E,0x16,0x40,0x00,0xB2,0x15,0x00,0x0A,0x10,0xC6,0x7C,0xC4,0x3D,0x3A,0x43,0xF6,0x93,0x95,0x8C,0x64,0x0C,0x35,0x73,0x66,0x3A,0xB3,0x9E,0xB7,0x6A,0x34,0x13,0x88,0xBA,0xD3,0xEB,0xDE,0x86,0x2E,0x6B,0x96,0x9A,0x0C,0xE8,0x7B,0xD3,0x53,0x17,0x95,0x11,0xB6,0xEC,0x60,0x07,0x3D,0x88,0x81,0x6B,0x8B,0x96,0xB4,0xC5,0x06,0xA1,0xB4,0x56,0xC2,0xD1,0x03};
//const uint8_t spFIFTY[] PROGMEM ={0x0C,0xA8,0x61,0x54,0x02,0x1A,0xF0,0xC0,0x8A,0x73,0x09,0x63,0xB1,0x67,0x37,0x59,0x49,0x2A,0x66,0xAC,0x39,0x66,0xA4,0xD6,0x99,0x55,0x6C,0x84,0x9C,0x2B,0x60,0x66,0x57,0x0D,0x48,0x80,0x03,0x00,0x0A,0xE8,0x34,0x4D,0x01,0x3D,0xA5,0xA4,0xB0,0x05,0x13,0x8A,0x79,0x33,0x8B,0x5E,0x87,0xAE,0x7A,0x61,0xC9,0xF8,0xE2,0x7B,0x3B,0xD8,0x59,0x8F,0x0F};
//const uint8_t spFIGURE[] PROGMEM ={0x0C,0xB0,0x3C,0x9C,0x01,0x59,0xBB,0x29,0xA0,0x5A,0x33,0x0B,0x9C,0x30,0x04,0x57,0xCD,0xAC,0x77,0xE2,0x1A,0xD3,0x58,0x74,0xCD,0x89,0x5A,0x36,0xE1,0xF6,0xB7,0x2D,0xAE,0xD5,0x81,0xDB,0x97,0xAA,0x44,0x4B,0x0B,0x2C,0x71,0xC2,0x32,0xE2,0x2A,0xD3,0xDC,0x8E,0x28,0x38,0xAF,0xF4,0x34,0xDB,0xA5,0x5A,0xCD,0xC8,0xC9,0x94,0xB4,0x6A,0x78,0x51,0xB4,0xEA,0xB3,0xEA,0x1A,0x9C,0x21,0x7C,0xEF,0x6A,0x72,0x4A,0x01,0xAF,0x6E,0xAB,0x8D,0x39,0x0D,0xC3,0xD3,0x9F,0x3E,0xF6,0x34,0x0E,0xF6,0xDE,0x7A,0x17,0x93,0xB8,0x33,0xB9,0x1B,0x6D,0x17,0xC9,0xD2,0xEC,0x66,0x70,0x85,0x2C,0xDD,0x92,0x98,0x31,0xB4,0x10,0x52,0x75,0xF5};
//const uint8_t spFIND[] PROGMEM ={0x0C,0x30,0x56,0x5C,0x01,0xD1,0xA8,0x5A,0xC0,0x02,0x27,0xB1,0x21,0xD6,0x39,0x93,0x9C,0xDC,0xB6,0x0E,0x93,0x4A,0xB3,0x8B,0x5D,0xED,0x6A,0x57,0xAB,0x8E,0xC3,0x4B,0x2C,0x92,0xEC,0x66,0xB6,0xA5,0xCD,0x4D,0xC5,0x3D,0xA7,0xD4,0xB6,0x76,0xA1,0x63,0xCE,0x32,0xA4,0x63,0xF8,0xDE,0x0F,0x76,0x68,0x93,0x73,0xA6,0xE6,0x39,0xB9,0x0E,0xA9,0x8B,0xD9,0x4D,0xC0,0x2A,0x3F};
//const uint8_t spFINE[] PROGMEM ={0x0C,0x30,0x56,0xDC,0x00,0xD1,0xA8,0x46,0x20,0x02,0x2B,0xB4,0x21,0xD6,0x39,0x93,0x9C,0xCC,0xB6,0x0E,0x93,0x4A,0x73,0xB3,0x9B,0xDD,0xFC,0x16,0xA7,0x8A,0xC3,0x4B,0x2C,0x92,0xDC,0xE6,0xB6,0xA7,0xCB,0x4D,0xC5,0x3D,0xA7,0xEC,0x6E,0xF7,0xA1,0x67,0xCE,0x32,0xA4,0x63,0xC4,0xDE,0xF7,0xBE,0xB7,0x83,0x1E,0xF8,0xF0};
//const uint8_t spFINISH[] PROGMEM ={0x02,0x48,0xCA,0x55,0x03,0x16,0xF0,0xC0,0x49,0x63,0x32,0xE3,0x8A,0x25,0x27,0xCB,0x39,0x9C,0xC2,0xDA,0xDE,0xEC,0x16,0xA9,0x8A,0x0E,0x22,0x30,0x9B,0xF4,0x6A,0x36,0xA3,0x2D,0xD6,0x49,0x2C,0x5A,0xCC,0xAE,0x75,0x49,0xB3,0x55,0x56,0x45,0x07,0xEC,0x3E,0xE1,0x01,0x0F,0x58,0x40,0x02,0x14,0x78};
//const uint8_t spFINISHED[] PROGMEM ={0x02,0x28,0xCA,0x49,0x03,0x16,0xB0,0xC0,0x89,0x73,0x0A,0x31,0x8F,0xB6,0x37,0xB9,0x69,0xCB,0x4A,0x75,0x21,0xF6,0x7A,0xAB,0x28,0xC5,0xD9,0x55,0x2E,0x9F,0xBA,0x06,0x25,0xB5,0x9A,0xB9,0x9B,0xD9,0x96,0x2E,0x31,0x93,0xEA,0x0C,0x69,0x80,0x77,0xCA,0x23,0x10,0x81,0x08,0x48,0x00,0x00,0x14,0x30,0xAC,0x9B,0x01,0xB4,0xB7,0x20,0x80,0x57,0xAE,0x0F};
//const uint8_t spFIRST[] PROGMEM ={0x08,0x08,0xDA,0x04,0x03,0x18,0xE0,0x80,0x07,0x42,0x64,0x86,0x69,0x15,0x65,0xDB,0xF9,0xCE,0x77,0x3E,0x8B,0x51,0xBB,0x9E,0xA4,0x6D,0xEE,0x5B,0xEB,0x87,0x89,0x94,0xB9,0xAF,0x7D,0x1D,0x0C,0xF0,0x8A,0xB1,0x01,0x9E,0x17,0xD6,0x00,0x01,0xFE,0x76,0x44,0x80,0x66,0x95,0x00,0x0A,0x68,0xC1,0xDC,0x00,0xDB,0x8A,0x3F};
//const uint8_t spFIT[] PROGMEM ={0x04,0x88,0x2E,0x4C,0x02,0x1A,0xD0,0x80,0x07,0x46,0x9C,0x82,0xAB,0x56,0xAE,0xB9,0xC9,0x4D,0x4F,0x1E,0x43,0xA4,0x6A,0xEC,0xD9,0x55,0x6F,0x7C,0xAB,0x7B,0x00,0x50,0x40,0x55,0x2E,0x02,0x68,0xB6,0xE5,0x01,0x00,0x00};
//const uint8_t spFIVE[] PROGMEM ={0xC0,0x80,0xE8,0xCD,0x46,0xEE,0x9C,0x6F,0x31,0x66,0x39,0xB9,0xF3,0x35,0x45,0xD6,0xF4,0x64,0xDE,0x77,0x27,0x79,0xDD,0x93,0x7A,0xDF,0x1D,0x14,0x45,0x4E,0xE6,0x43,0x97,0x73,0x05,0x3D,0x45,0x08,0x5D,0xC5,0x15,0xE5,0x54,0x21,0x56,0x06,0x67,0x90,0x53,0xC7,0x54,0x15,0x14,0x75,0x4F,0x1B,0xAB,0x17,0x43,0x25,0x59,0x5D,0x6C,0x5E,0xAA,0x59,0x75,0xF4,0xA9,0x59,0x69,0xD5,0xD4,0xD1,0xC7,0x6A,0xA1,0x5E,0x53,0xDB,0x10,0x8B,0x86,0x46,0x5D,0x6D,0x43,0x28,0x1A,0x1A,0x35,0xB4,0xF4,0x2E,0x4B,0xA9,0x75,0x62,0x33,0x98,0xA2,0xC6,0x5A,0x09,0xD9,0x20,0x95,0x7B,0x99,0xBB,0x06,0x04,0x38,0x27,0x84,0x00,0xE5,0xD5,0x1F};
//const uint8_t spFOR[] PROGMEM ={0xC0,0x00,0x23,0x2D,0x24,0xA0,0x01,0x0B,0x58,0x20,0xC5,0xBC,0xF7,0x11,0x4C,0x9A,0x9A,0xA4,0x84,0xF6,0x39,0x85,0x6E,0x97,0x93,0x98,0x84,0x8C,0xF5,0x5E,0x45,0xCD,0xDE,0x2A,0x91,0x63,0xD2,0x58,0x7D,0x6B,0x55,0xB1,0xF2,0x26,0xED,0xA9,0xE7,0xDB,0xC2,0x4B,0xFC,0xBA,0x49,0x2E,0x89,0x55,0xF4,0xE3,0x66,0xB5,0x95,0xAB,0xCC,0xBB,0x9B,0xED,0x30,0xF6,0x11,0x35,0x76,0x7B,0x00,0x00};
//const uint8_t spFORTY[] PROGMEM ={0x08,0x48,0x4C,0x8D,0x02,0x0A,0x28,0xDE,0x5D,0x84,0x22,0xCC,0x25,0x50,0xFB,0x9A,0xB4,0x94,0x97,0x19,0x43,0x6D,0xD7,0xD3,0x91,0xA9,0xE2,0x61,0xC5,0xBD,0x7B,0x4E,0x00,0x9D,0x58,0x1C,0x90,0x63,0x6A,0x4A,0x4A,0x0C,0x21,0x9F,0xB7,0xBD,0x18,0x4D,0x8B,0xCE,0x18,0xF1,0x26,0xB7,0xBE,0x73,0x5D,0xB3,0x2E,0x1C,0xD1,0xDA,0x0E,0x72,0x7C};
//const uint8_t spFOUR[] PROGMEM ={0xC0,0x00,0x23,0x2D,0x24,0xA0,0x01,0x0B,0x58,0x20,0xC5,0xBC,0xF7,0x11,0x4C,0x9A,0x9A,0xA4,0x84,0xF6,0x39,0x85,0x6E,0x97,0x93,0x98,0x84,0x8C,0xF5,0x5E,0x45,0xCD,0xDE,0x2A,0x91,0x63,0xD2,0x58,0x7D,0x6B,0x55,0xB1,0xF2,0x26,0xED,0xA9,0xE7,0xDB,0xC2,0x4B,0xFC,0xBA,0x49,0x2E,0x89,0x55,0xF4,0xE3,0x66,0xB5,0x95,0xAB,0xCC,0xBB,0x9B,0xED,0x30,0xF6,0x11,0x35,0x76,0x7B,0x00,0x00};
//const uint8_t spFOURTEEN[] PROGMEM ={0x00,0x04,0xF0,0xD2,0x54,0x01,0x49,0xB9,0x85,0x94,0xE5,0x6A,0x0F,0x93,0xDF,0x52,0x11,0xEB,0x99,0x39,0x73,0xCA,0xD8,0xA8,0xA3,0xD0,0xCE,0x25,0xE3,0x2B,0x52,0x5D,0xFB,0x8E,0xDC,0x24,0x37,0x1B,0x75,0xAF,0x00,0x1A,0xA4,0x81,0x00,0x95,0x92,0x03,0x80,0x03,0x8A,0x37,0xB6,0x80,0x00,0x8A,0x23,0x2D,0x41,0xD1,0x22,0xDE,0x59,0x6A,0x24,0x4D,0x0B,0x49,0x56,0xE5,0x91,0x0D,0x2D,0xC4,0x99,0x95,0x5B,0x3E,0xB4,0x30,0x57,0x55,0x2E,0x45,0xE7,0xC4,0x3A,0x19,0xB9,0xD4,0x85,0x13,0xC5,0x84,0x99,0xD4,0x54,0x4E,0xE2,0x17,0xA6,0x53,0xDB,0x34,0x8B,0x6F,0x98,0x49,0x5D,0xD6,0x2C,0x35,0x19,0x30,0x74,0x51,0x2B,0xFB,0x79,0x68,0xD1,0x33,0xAD,0xDD,0x1A,0xA6,0x45,0x4F,0xB4,0x56,0x4A,0xCB,0x16,0x3D,0xD3,0x3A,0x25,0x65,0x4A,0x74,0x5C,0xEB,0x8C,0x44,0x24,0xD1,0x49,0xAD,0xBD,0x1A,0x8E,0x1F,0x00,0x00};
//const uint8_t spFOURTH[] PROGMEM ={0x08,0xD0,0x22,0x84,0x00,0x51,0x1A,0x0B,0xA0,0x69,0x23,0x03,0xD4,0x50,0x4E,0x00,0x7C,0xCB,0x4B,0x2A,0x5D,0x4D,0x00,0x24,0xEB,0x69,0x48,0xE9,0xDE,0x64,0x88,0xAA,0x21,0xA3,0xBB,0x97,0xC1,0xDA,0xA7,0x9C,0xAD,0x1A,0x45,0xCB,0xD6,0x2A,0x3E,0xB2,0x5D,0x34,0x7B,0xAB,0x75,0xB3,0x1A,0xE5,0xEE,0xA5,0x35,0x95,0x27,0x52,0xDA,0xA6,0x4E,0x27,0x2D,0xCB,0x8C,0x4D,0x00,0xC9,0x8D,0x30,0x80,0x00,0xCF,0x5D,0x11,0xE0,0x99,0x9B,0x00,0xB2,0x34,0x62,0x80,0x0A,0xAA,0x18,0x78};
//const uint8_t spFROM[] PROGMEM ={0x80,0x80,0x28,0x55,0x08,0x50,0xBD,0xA3,0x03,0x52,0x48,0x2F,0xA9,0x5A,0x9C,0x19,0x94,0x75,0x64,0x7A,0x68,0x79,0x60,0xA7,0x95,0x99,0x30,0xC3,0x9A,0x51,0x76,0xBE,0xF3,0x51,0x38,0xD7,0xC7,0x92,0xA5,0x67,0x35,0x9B,0xD9,0x96,0xCE,0x1B,0x0D,0x43,0x75,0x1F,0x3B,0xD7,0x5B,0x2D,0x65,0x68,0xC9,0x7D,0xEF,0x7B,0xD3,0x5B,0xCD,0xAD,0xE0,0xEE,0x7C,0xEF,0xFB,0x07,0x00,0x00};
//const uint8_t spFRONT[] PROGMEM ={0x06,0xA8,0x21,0xC5,0x03,0x11,0x88,0x40,0x49,0xF5,0x92,0xF4,0x42,0xAF,0x35,0xEB,0xF9,0xA9,0xBC,0xAF,0x0E,0xF2,0xF4,0xBB,0xDE,0x4D,0xEB,0x7D,0x82,0x76,0x69,0x35,0x71,0xB0,0xBD,0xEB,0x93,0x4D,0x33,0x15,0x19,0xC0,0x80,0xA6,0x9A,0x2D,0xF0};
//const uint8_t spG[] PROGMEM ={0xAA,0xBE,0xAB,0x90,0xC1,0xD4,0x05,0x60,0x47,0x86,0x51,0xED,0xE2,0xC2,0x6C,0xD9,0x57,0xD5,0x53,0x08,0x81,0x6E,0x5D,0x45,0x2B,0x41,0x64,0xBE,0x66,0x17,0xBB,0xD8,0xD5,0xAE,0x76,0xD3,0xDA,0x92,0x05,0xA5,0xF2,0x76,0x6D,0x53,0x97,0xB5,0xB2,0x5E,0xD4,0x72,0x5D,0xD4,0xCC,0x79,0x11,0xD2,0x77,0xBA,0x93,0xFD,0x03};
//const uint8_t spGAMES[] PROGMEM ={0xAA,0x15,0x24,0x2A,0xD6,0xE4,0xB6,0xB6,0x79,0x13,0xB1,0x5C,0xB2,0xF3,0x93,0x97,0xA4,0x66,0x3E,0x75,0x77,0x3E,0xF2,0x52,0x8D,0xCD,0x26,0xF6,0xCC,0x7B,0xDE,0x8A,0x9A,0x14,0x2D,0xBA,0xD2,0xAC,0x66,0xDD,0xEB,0xDE,0x8E,0xB6,0x7A,0x47,0x0D,0xAF,0x95,0x3A,0x6D,0xB1,0x9A,0xDA,0x8E,0xED,0x6C,0x67,0x3A,0x6E,0xA5,0x46,0x42,0xB1,0xED,0x74,0x27,0x3A,0x62,0x32,0xC2,0x23,0x76,0xEA,0x7F,0x22,0x36,0x11,0xF5,0x06,0x38,0x1C,0xC8,0x00,0xDF,0x29,0x39,0xE0,0x7B,0x56,0x03,0x7C,0xCD,0xCA,0x80,0xCC,0x83,0x1E,0x00,0x00};
//const uint8_t spGET[] PROGMEM ={0xA3,0xAE,0x4A,0xD5,0xC0,0xB4,0xAC,0xB4,0x26,0x17,0xF1,0x58,0xB2,0xF2,0x98,0x2D,0x25,0x72,0xF4,0x2E,0x76,0xB1,0xAB,0x5D,0xCD,0xBA,0x34,0xAE,0x6A,0x58,0x76,0x69,0xDF,0x02,0x00,0x28,0xA0,0xAA,0x30,0x02,0x48,0x6F,0x06,0x0F,0x00,0x00};
//const uint8_t spGETTING[] PROGMEM ={0xA3,0x9E,0xB9,0x52,0x99,0x1C,0xAF,0x64,0x05,0x67,0xD5,0x74,0x73,0x92,0xE6,0x42,0xB8,0x72,0xF1,0xC9,0x63,0x71,0xA5,0xAC,0x39,0x27,0x4F,0xD5,0x42,0x75,0x13,0xAF,0x3C,0x36,0x4B,0x8C,0xC9,0x06,0x01,0x28,0xD9,0x2C,0x85,0xCD,0x27,0xA3,0x7A,0xAB,0x53,0x95,0xE6,0xA2,0x11,0x4B,0x4E,0x53,0x93,0xB3,0x44,0x2E,0x3E,0x5D,0xCF,0xC6,0xE8,0xD1,0xA8,0x75,0xCD,0x2B,0x71,0x67,0xA4,0xD4,0x27,0x87,0xD2,0x19,0x92,0x4D,0x2F,0x9D,0x6C,0x44,0x4A,0x36,0x83,0xB5,0x38,0x21,0x25,0x43,0x0D,0xC6,0xE0,0x16,0x94,0x0C,0x33,0x38,0x03,0xDD,0x18,0x4E,0xC4,0xC0,0xAC,0x75,0x71,0xA4,0x32,0x53,0xAE,0xC6,0x22,0xE4,0x4C,0x4D,0x39,0x28,0x79,0x54,0x98,0x07,0x00,0x00};
//const uint8_t spGIVE[] PROGMEM ={0x6A,0x60,0x22,0x3A,0xD3,0x64,0xA7,0x6E,0x16,0x37,0xA0,0x5A,0x5B,0xBB,0xD1,0x8D,0x56,0x09,0x4C,0xDB,0x77,0x3F,0xFA,0xDA,0x82,0xC5,0xE9,0x7B,0xEF,0x47,0x17,0x92,0x9B,0x06,0x7F,0x1B,0x6D,0x8A,0x12,0x11,0xB2,0x7D,0x35,0x3E,0x68,0xB9,0xD9,0x9B,0x51,0xEB,0xE8,0xE3,0x5A,0xAD,0x4A,0xA5,0x82,0xAD,0x4B,0x36,0x70,0x95,0x8C,0xD6,0xC2,0xD5,0xCA,0x65,0x46,0x98,0x15,0xBB,0x5B,0x04,0x18,0x29,0xC2,0x80,0x14,0x54,0x10,0xA0,0x43,0x2A,0x3C};
//const uint8_t spGIVES[] PROGMEM ={0xAA,0x15,0x34,0x26,0x46,0xE5,0xB6,0x66,0x46,0x66,0x56,0x4F,0x3A,0x8A,0x61,0x58,0x24,0x6B,0xD5,0xCA,0x9B,0x36,0xE1,0x9A,0x45,0x2B,0xCB,0xC2,0xD5,0xB6,0x6A,0x8E,0x34,0x58,0xB3,0xD8,0x9A,0x34,0x32,0xE3,0xCD,0x73,0xAB,0xD2,0xC8,0x5D,0x54,0xF3,0x9C,0x9A,0xA3,0xB0,0x2E,0xCC,0xBA,0x66,0x8E,0xCA,0xD9,0x74,0xCB,0x78,0x34,0x9B,0xDE,0xB6,0x2E,0x4A,0x77,0x75,0x4A,0x5D,0xBB,0xDC,0x99,0x5E,0x99,0x50,0x13,0xAB,0xED,0x86,0x28,0x42,0x45,0x35,0xB5,0x1D,0x05,0xF0,0x9D,0xB9,0x02,0x7E,0x50,0x57,0xC0,0x0F,0x2A,0x0C,0xF8,0x8E,0x95,0x00,0x5F,0x33,0x21,0xE0,0x39,0xD2,0x07};
//const uint8_t spGO[] PROGMEM ={0xA5,0x4E,0xAE,0x58,0xBC,0x6B,0x9D,0xA2,0x1B,0x75,0xAA,0xC8,0x76,0xAA,0x1C,0x34,0x2C,0x39,0xCB,0xA9,0x82,0xF6,0xB1,0xD4,0x3C,0xA7,0xF2,0x3A,0x37,0x9C,0xBA,0xDD,0xEA,0xD6,0xBB,0x99,0x7D,0x9A,0x8C,0xAA,0x0B,0xC7,0xB4,0x71,0x72,0x93,0x56,0xFD,0x62,0x92,0x56,0xCF,0x0F};
//const uint8_t spGOES[] PROGMEM ={0xA3,0xEA,0x46,0x9D,0x2A,0xB2,0x9D,0x3C,0x07,0x0D,0x4B,0xCE,0x72,0x8A,0xA0,0x7D,0x2C,0x35,0xCF,0x29,0xBC,0xCE,0x0D,0xA7,0x6E,0xBB,0xBA,0xF5,0x68,0x8D,0xAA,0x0B,0xC7,0xB4,0xBD,0xCB,0x43,0x1C,0xDD,0xA8,0x55,0xBF,0x98,0xA4,0xF5,0x93,0x99,0x3C,0xF1,0x4C,0x01,0x7F,0x76,0x16,0xC0,0x11,0xC4,0x04,0xF8,0xC3,0x51,0x00,0x7F,0x07,0x12,0xE0,0x55,0x42,0x06,0x74,0x21,0xF1};
//const uint8_t spGOING[] PROGMEM ={0xA4,0x42,0xAE,0x3B,0xA3,0x15,0x85,0xDA,0x1B,0x65,0xD5,0x76,0xD2,0xF2,0x98,0x82,0xC5,0x33,0xF3,0xC9,0x13,0xD5,0x8C,0x52,0xDF,0x2B,0xB7,0xAE,0xDF,0x05,0x3A,0xEF,0xAC,0xE5,0x2A,0xF6,0x29,0xC1,0xE6,0x5C,0xB4,0x4A,0xC5,0x6D,0x06,0x59,0xBD,0xAA,0xA0,0x33,0xCD,0x78,0xCB,0x6A,0xDB,0x2C,0x61,0xC1,0xB5,0xBB,0x6B,0x7D,0xF3,0xC6,0x52,0x59,0x31,0x8C,0x25,0x30,0xDA,0x86,0x49,0x3B,0xE9,0x49,0x8C,0x9A,0xD1,0x34,0x44,0x6C,0x39,0xF2,0xC9,0x4E,0x6A,0x0A,0xD9,0x42,0x35,0x2B,0x3E};
//const uint8_t spGOOD[] PROGMEM ={0xA3,0x8D,0x29,0x58,0x3C,0x33,0xDF,0xEC,0x14,0x59,0x68,0x6B,0x4A,0xF6,0x5B,0xDD,0xEA,0x56,0xA7,0xB2,0xC6,0x2B,0x3D,0x3A,0xEC,0xBA,0xD7,0xAA,0x26,0xBC,0xD2,0x23,0x1D,0x3C,0x00,0x00};
//const uint8_t spGOOD_WORK[] PROGMEM ={0xA1,0x89,0xC6,0x95,0xC3,0xF2,0xCD,0xEA,0x14,0x4E,0xA7,0xA6,0x4B,0xFB,0x5B,0xEC,0xE2,0x16,0x0A,0x00,0x57,0x33,0xB4,0xD6,0x58,0xA8,0x4F,0x03,0x10,0x85,0x08,0xDE,0x0E,0x92,0xDA,0xE7,0x21,0x21,0x37,0x4B,0x24,0x32,0xA6,0x88,0x5C,0x77,0xD7,0xF4,0x58,0x42,0x31,0x52,0x3A,0x28,0x53,0x8D,0x46,0x62,0x5A,0x52,0x1C,0xE6,0xED,0x75,0x1F,0xF2,0xA8,0x27,0x00,0x01,0xC4,0xE2,0x22,0x01,0x02,0x94,0xEC,0xF2};
//const uint8_t spGOODBYE[] PROGMEM ={0xA9,0x49,0xE1,0x54,0x91,0x2D,0xAF,0x22,0x07,0x55,0x29,0x69,0x7B,0xF2,0x18,0x38,0x32,0x3C,0xCB,0x4D,0x52,0xC8,0x4A,0x5A,0x65,0x99,0x52,0x21,0x6A,0x61,0x69,0x2E,0x45,0x46,0x2C,0x43,0xA9,0x3C,0x3D,0x1C,0x87,0x2A,0x3A,0xFB,0x50,0x6E,0x73,0xEB,0xDB,0xEC,0x6E,0x77,0xA3,0xF7,0xD1,0x4E,0x35,0xA2,0xCC,0x7E,0x74,0x3E,0xC6,0xA8,0x79,0x85,0xD1,0x86,0x64,0x65,0x16,0x95,0x5B,0x13,0x52,0xB0,0x65,0x94,0x2E,0xB5,0x4D,0x6A,0x55,0x65,0xF8,0x01,0x00,0x00};
//const uint8_t spGOT[] PROGMEM ={0xA2,0x20,0xBA,0x2A,0xDD,0x13,0x8F,0x2A,0x07,0x13,0x2D,0x5D,0x7B,0xF3,0x93,0xFB,0x6C,0xE1,0x11,0x73,0x4F,0xE1,0x73,0xB6,0x6B,0xD4,0xBF,0xC5,0xAD,0x66,0x5D,0x3A,0xEF,0x5A,0x4A,0xC2,0x52,0xEE,0x75,0x0F,0x20,0x00,0x43,0xC2,0x19,0x30,0x44,0x04,0x3C};
//const uint8_t spGRAY[] PROGMEM ={0x04,0xD0,0xD7,0x22,0xA5,0xBA,0x78,0x19,0x8C,0xBA,0x54,0xC8,0x22,0x27,0xAE,0xD9,0x4B,0xA1,0x2A,0xBF,0xA6,0xF8,0x6F,0x99,0x6E,0xFC,0x32,0xD2,0x71,0x65,0x3E,0x4B,0xCB,0x56,0xA2,0x9D,0xED,0xFC,0x14,0xA5,0x99,0x68,0xC4,0xDC,0x5B,0xDD,0x7A,0xB5,0x29,0x93,0x7B,0x6E,0x94,0xDE,0xA7,0x3E,0x46,0xB4,0xAC,0x0E,0x92,0xFA,0xE8,0x49,0xBB,0x3B,0x88,0xEB,0x83,0x11,0xEE,0xE3,0x00,0x0F,0x00,0x00};
//const uint8_t spGREEN[] PROGMEM ={0xA1,0x0A,0x45,0x46,0xC0,0xA8,0xA6,0xCA,0x66,0x38,0xB5,0x72,0x37,0x0A,0x5F,0x70,0x38,0xDC,0xF7,0xCA,0x63,0xC7,0xE2,0xF0,0x2C,0x27,0x4B,0x55,0x45,0x3C,0x96,0x9D,0xAC,0x77,0x23,0xB2,0x5C,0xBC,0xF3,0x5B,0xEC,0x6A,0xD7,0xAB,0xEE,0xC3,0x19,0x75,0x66,0xEF,0x66,0xB4,0x75,0x19,0xB3,0xF4,0xE2,0xD0,0x39,0x0B,0x1B,0x16,0x76,0x7D,0x6B,0x5A,0x6B,0xE0,0xDD,0x43,0x99,0x68,0x59,0xB2,0x49,0x28,0x43,0xA2,0xD5,0x0A,0x7B,0x25,0x1D,0xBB,0x36,0x44,0x27,0x8E,0x4C,0x24,0x7A,0x1F,0x45,0x4C,0xDB,0x36,0x3C};
//const uint8_t spGUESS[] PROGMEM ={0x21,0x1F,0xDE,0x14,0x2D,0xDE,0xEC,0x7C,0xE5,0x39,0x59,0x99,0xE6,0xDC,0x9D,0xEF,0x62,0x57,0xAB,0x8E,0xD1,0xCA,0x79,0x63,0xCE,0x26,0xB7,0x02,0x98,0x3C,0x54,0x01,0x3F,0xA8,0x69,0x40,0x03,0x0A,0xF8,0x3E,0xD4,0x00,0xDF,0x46,0x18,0xE0,0x8A,0x30,0x05,0x64,0x57,0x8C,0x00,0x9D,0x54,0x00,0x80,0xD4,0xC1,0x84,0x5B,0xB9,0x93,0x07,0x00,0x00};
//const uint8_t spH[] PROGMEM ={0x27,0x2F,0xC1,0x55,0xAB,0x26,0x9F,0x22,0x47,0x55,0xAB,0x9E,0x7A,0x8A,0x92,0x8C,0x74,0x7B,0xF2,0xAD,0x56,0xD5,0x83,0x11,0x75,0x3D,0xAE,0xB5,0xAC,0x01,0x1C,0x30,0x23,0xAB,0x03,0xF6,0xCE,0xB0,0x00,0x03,0xCE,0xE9,0x14,0xC0,0x9A,0x96,0x0F};
//const uint8_t spHAD[] PROGMEM ={0x08,0x30,0xD6,0x4A,0x00,0x3E,0x68,0x85,0x24,0x25,0x75,0x8F,0x8E,0x72,0xE3,0x93,0x96,0xE2,0xA6,0x59,0x75,0x6E,0x7A,0xB3,0x93,0xE7,0x9A,0x2E,0x9A,0x55,0x6F,0x75,0xEA,0x5C,0xB3,0xC5,0x62,0xEA,0x6D,0x6E,0xB3,0xDB,0xDE,0x9A,0x9E,0xEB,0x14,0xF9,0xA8,0x6C,0x7A,0x61,0x9D,0xF4,0x32,0xB2,0xEB,0x8B,0x72,0x11,0x8F,0x0D,0xB9,0xF3,0xA3,0xEA,0x52,0x71,0xA3,0x58,0xD9,0x0F,0x00,0x00};
//const uint8_t spHAND[] PROGMEM ={0x08,0x10,0xD6,0x13,0x01,0xC6,0x50,0x49,0x40,0x03,0x25,0x4E,0xCD,0x53,0x63,0x1C,0xDF,0xF4,0xA6,0x27,0x4D,0xCD,0x87,0x32,0x93,0xDE,0xEC,0xE6,0xB7,0xB8,0xD5,0x6E,0x56,0xE3,0xAB,0x87,0x79,0xC5,0xE9,0x4D,0x6F,0x4C,0xC3,0xA2,0x55,0xC9,0x44,0xB2,0x8D,0x6E,0x74,0xC3,0x5A,0x66,0xAC,0x5A,0xC3,0x61,0xE8,0x52,0x14,0x51,0xF0,0x2A,0xB6,0xD5,0xCD,0x03,0x00,0x00};
//const uint8_t spHANDHELD_UNIT[] PROGMEM ={0x08,0x70,0x5E,0x8C,0x03,0x1A,0x18,0x49,0x1A,0xEE,0xC6,0xE7,0xFC,0x24,0x79,0x64,0x38,0x56,0xD2,0x9B,0xDE,0x6C,0x66,0x21,0x57,0x4E,0xDA,0xE4,0x55,0x99,0x9C,0xD8,0xA8,0x85,0xB0,0x60,0x0B,0x5B,0xC8,0x0A,0x30,0xC0,0x00,0x61,0xA4,0x38,0x30,0x9A,0xD0,0x22,0xC4,0xAB,0xCE,0x6E,0x76,0x33,0x9B,0xD6,0xE8,0x56,0xAD,0x1A,0xB3,0x6B,0x93,0x1A,0x39,0xAA,0x45,0xB3,0xB1,0x6F,0x4C,0x4B,0x5D,0xA8,0x67,0xDB,0x0A,0x7D,0xD0,0xC6,0xBA,0x63,0xD3,0x37,0xA9,0x29,0x23,0x15,0x8B,0xFB,0xA6,0xDA,0x07,0x28,0xD7,0x74,0x17,0xEB,0xD8,0xF8,0xCE,0xF5,0xA1,0x5A,0x50,0xC4,0xD4,0x3C,0xBA,0xD1,0x39,0x8B,0xC8,0x88,0xE1,0x47,0x3D,0x02,0x00,0x08,0xA0,0x7B,0x37,0x0D,0x10,0x20,0x49,0x73,0x0C,0x3C,0x00,0x00};
//const uint8_t spHAS[] PROGMEM ={0x08,0xB0,0x56,0x94,0x01,0x29,0x3A,0x2B,0x20,0xB5,0x30,0x05,0xF8,0xC0,0x76,0xB2,0xD4,0x3C,0x35,0xC6,0xF1,0x4D,0x6F,0xBA,0xF2,0xD4,0x7C,0x28,0x33,0xE9,0x2E,0x6E,0x75,0xBB,0xDD,0xED,0x7E,0x0C,0xBE,0x7A,0x98,0x57,0x9C,0x3E,0xE4,0xD1,0x8D,0xC6,0x6B,0x99,0x6E,0x6C,0x05,0x74,0x40,0x29,0x01,0x06,0xFC,0xA0,0x82,0x80,0x9F,0x95,0x11,0xF0,0x9C,0x2A,0x3C};
//const uint8_t spHAVE[] PROGMEM ={0x0C,0x08,0xD1,0x44,0x02,0x14,0x10,0x40,0x0C,0x4E,0x21,0xF5,0xD9,0x2D,0x33,0xAD,0xCC,0x74,0xA7,0x37,0x3D,0x59,0x1A,0x1E,0x62,0x1D,0xF7,0xE6,0xB7,0xBA,0xF5,0xAA,0x43,0x8D,0x30,0x8F,0xAD,0xBB,0x59,0x8D,0x8F,0x11,0x5A,0xB2,0x66,0xB7,0xBD,0x4D,0x9D,0x8B,0x6A,0x2C,0xDC,0xDA,0x77,0xBA,0x93,0xBD,0xED,0x6D,0xAF,0x7B,0x80,0x07,0x00,0x00};
//const uint8_t spHEAD[] PROGMEM ={0x80,0x80,0x60,0x59,0x08,0x10,0x3D,0xB7,0x00,0x62,0x64,0x1D,0x41,0x8E,0x61,0xC6,0xFE,0xE6,0xC6,0x37,0xBE,0xC9,0xC9,0x72,0x09,0x33,0xCE,0x2D,0xB7,0x3A,0x4D,0x4A,0xEE,0xAE,0xB1,0xE6,0x76,0xAB,0x8F,0xD1,0xDC,0x2C,0x96,0x88,0x9E,0xBA,0x50,0xCF,0xB6,0x25,0x07,0x31,0x50,0x97,0xEA,0xD9,0xB2,0xC4,0xC0,0x54,0x7A,0x46,0x38,0x16,0xC3,0x90,0xA6,0xEA,0xEE,0x3A,0x74,0xCD,0x8F,0x14,0x97,0x43,0xD3,0x46,0xAF,0x26,0xDA,0x0D,0x43,0x9F,0x7D,0x9A,0xB3,0x3A,0x79};
//const uint8_t spHEAR[] PROGMEM ={0x08,0x08,0xD2,0x88,0x00,0x51,0x29,0x13,0x20,0x5B,0x92,0x94,0x36,0xAF,0x42,0x15,0x6B,0x76,0x32,0xE3,0x1D,0xAF,0xA4,0xE6,0x10,0x48,0xEF,0x3E,0xB3,0x5D,0x8D,0x3A,0xD6,0x32,0x4C,0xF4,0x3E,0xDB,0xDE,0xF5,0x21,0x8D,0x7E,0x9A,0xC8,0x48,0xFE,0x38,0xEA,0x89,0x4F,0x74,0x7A};
const uint8_t spHELLO[] PROGMEM ={0x00,0xC0,0x80,0x60,0x59,0x08,0x10,0x3D,0xB7,0x00,0x62,0x64,0x3D,0x55,0x4A,0x9E,0x66,0xDA,0xF6,0x56,0xB7,0x3A,0x55,0x76,0xDA,0xED,0x92,0x75,0x57,0xA3,0x88,0xA8,0xAB,0x02,0xB2,0xF4,0xAC,0x67,0x23,0x73,0xC6,0x2F,0x0C,0xF3,0xED,0x62,0xD7,0xAD,0x13,0xA5,0x46,0x8C,0x57,0xD7,0x21,0x0C,0x22,0x4F,0x93,0x4B,0x27,0x37,0xF0,0x51,0x69,0x98,0x9D,0xD4,0xC8,0xFB,0xB8,0x98,0xB9,0x56,0x23,0x2F,0x93,0xAA,0xE2,0x46,0x8C,0x52,0x57,0x66,0x2B,0x8C,0x07};
//const uint8_t spHELP[] PROGMEM ={0x08,0xB0,0x4E,0x94,0x00,0x21,0xA8,0x09,0x20,0x66,0xF1,0x96,0xC5,0x66,0xC6,0x54,0x96,0x47,0xEC,0xAA,0x05,0xD9,0x46,0x3B,0x71,0x94,0x51,0xE9,0xD4,0xF9,0xA6,0xB7,0x18,0xB5,0x35,0xB5,0x25,0xA2,0x77,0xB6,0xA9,0x97,0xB1,0xD7,0x85,0xF3,0xA8,0x81,0xA5,0x6D,0x55,0x4E,0x0D,0x00,0xC0,0x00,0x1B,0x3D,0x30,0x00,0x0F};
//const uint8_t spHERE[] PROGMEM ={0x08,0x08,0xD2,0x88,0x00,0x51,0x29,0x13,0x20,0x5B,0x92,0x94,0x36,0xAF,0x42,0x15,0x6B,0x76,0x32,0xE3,0x1D,0xAF,0xA4,0xE6,0x10,0x48,0xEF,0x3E,0xB3,0x5D,0x8D,0x3A,0xD6,0x32,0x4C,0xF4,0x3E,0xDB,0xDE,0xF5,0x21,0x8D,0x7E,0x9A,0xC8,0x48,0xFE,0x38,0xEA,0x89,0x4F,0x74,0x7A};
//const uint8_t spHIGHER[] PROGMEM ={0x80,0x01,0x04,0x78,0x1F,0x45,0x01,0x0E,0x94,0xC0,0x8F,0x0E,0xB7,0x8C,0xBA,0xC3,0x1D,0xED,0xE8,0x46,0x2B,0x8A,0x2B,0x4B,0xB5,0xE2,0xCD,0x68,0xC4,0xA5,0xA8,0x99,0x77,0xE9,0x99,0xB4,0xBC,0x15,0x15,0xC9,0x5C,0xDD,0xAB,0x51,0x95,0x1A,0x4C,0xE9,0x5D,0x47,0x9D,0x5A,0x32,0x87,0x66,0x1F,0x4D,0x6C,0x29,0x1A,0x92,0xBD,0xB5,0x7E,0x84,0x50,0x53,0xB7,0xDA,0xA6,0xCE,0x2D,0x91,0x0C,0x5A,0xED,0x7B,0xDD,0xCB,0x81,0xF7,0x74,0x10,0xBD,0xAF,0x4A,0xEA,0xE2,0xF1,0x01,0x00,0x00};
//const uint8_t spHIT[] PROGMEM ={0x08,0xB0,0x2E,0x4C,0x00,0xDE,0x47,0x29,0x20,0x2A,0x51,0x0D,0x68,0xA0,0x84,0xD9,0x30,0xC7,0x66,0xC0,0x13,0x97,0xEC,0x2C,0x19,0x4B,0x6E,0x72,0xB3,0x9B,0xB7,0x26,0x79,0x57,0x4A,0x7F,0x02,0x00,0x04,0x88,0xD2,0x54,0x00,0x4B,0x7A,0x08,0x60,0x08,0x37,0x78,0x00,0x00};
//const uint8_t spHOME[] PROGMEM ={0x08,0x50,0x71,0x93,0x00,0x36,0x54,0x53,0x80,0x00,0x2A,0x6E,0x92,0x48,0xFA,0x5F,0x52,0x4D,0xD7,0xA3,0x1E,0xF7,0xB8,0x25,0x5A,0xEE,0x9B,0x81,0xFA,0x99,0xF6,0xAC,0x57,0xAD,0xF6,0x22,0xBA,0x1E,0xE0,0xF6,0xA6,0x37,0xAD,0x0D,0x81,0x23,0x03,0xCD,0xF6,0xAE,0x76,0xB5,0xCB,0x5D,0xEE,0x5C,0xA7,0x2D,0xAE,0x4B,0x38,0x35,0xAD,0x4A,0x6D,0xA1,0xD2,0x48,0x74,0xBA,0xB4,0x89,0x57,0x98,0x07};
//const uint8_t spHOW[] PROGMEM ={0x80,0x80,0x10,0x4D,0x28,0xA0,0x01,0x03,0xC4,0xE0,0x64,0x80,0xE2,0x3B,0x15,0x10,0xA2,0xDA,0x8A,0x7D,0x8B,0x91,0x88,0xA8,0x23,0xB1,0x23,0x5A,0x22,0xA3,0xCE,0x64,0x24,0xB6,0xE7,0x88,0x67,0xD4,0x91,0xDA,0x52,0x23,0x1A,0x71,0x5A,0xE6,0x62,0xAF,0x8A,0x35,0x69,0x95,0x8D,0x7D,0x22,0xB6,0xA6,0xD4,0xA6,0xF4,0xB2,0xDA,0x92,0xDA,0x96,0x4E,0xA7,0x59,0x31,0x6E,0x9D,0xBB,0xD0,0xCB,0xB2,0xCB,0xCE,0xAB,0x4D,0x2F,0xC6,0x36,0x85,0xB4,0x52,0x3D,0xBF,0x4D,0xEA,0xA1,0x9A,0xF4,0xEC,0x36,0x19,0x85,0x23,0xDC,0xC3,0x03,0x00,0x00};
//const uint8_t spHUNDRED[] PROGMEM ={0x04,0x90,0xCB,0x4D,0x02,0x1A,0x68,0x89,0xCD,0x55,0x22,0xAD,0x79,0xA7,0x3B,0x1D,0x69,0x0A,0x5E,0xC2,0x91,0x7A,0xA6,0x2E,0x65,0x5E,0x73,0xAC,0x2D,0xDB,0x54,0xE6,0xA9,0x8A,0x59,0x42,0xC1,0xB3,0xA4,0xDA,0x67,0x0E,0xB5,0x68,0xDF,0xAB,0x59,0xCD,0x7A,0x35,0xDE,0xB9,0x59,0xC5,0xE3,0xD9,0xE6,0x5E,0x74,0xC4,0xA6,0x47,0x96,0x2D,0xD6,0x12,0x53,0x11,0x11,0xB1,0x59,0xCB,0x95,0x5A,0x58,0xAA,0x4E,0x43,0xD4,0xAE,0xE2,0xFC,0x52,0x0C,0x31,0xA5,0x28,0x56,0x2B,0x31,0xE4,0x10,0x6A,0xEC,0x0E,0xC9,0x10,0x55,0x5A,0x58,0xBA,0x7D,0x00,0x00};
//const uint8_t spHURRY[] PROGMEM ={0x00,0x00,0x14,0xE0,0x40,0x4B,0xEC,0x16,0x19,0x95,0xD8,0x3B,0x19,0x89,0xCE,0x8D,0xF1,0xEC,0xB6,0x25,0xBA,0x26,0xC5,0x61,0x97,0x99,0xD4,0xB4,0xE5,0xBA,0xA9,0x55,0x49,0xDE,0x5E,0xAC,0xBA,0x45,0x67,0x8C,0x78,0xB3,0xEB,0xDD,0xCC,0xB6,0xB5,0xB5,0x18,0x72,0xE4,0x9D,0xDA,0xFA,0x4E,0xB7,0x00,0x0F,0x00,0x00};
//const uint8_t spI[] PROGMEM ={0x23,0x09,0xDE,0x27,0x82,0xBB,0xED,0xEC,0x16,0xB7,0xBE,0xF5,0x6D,0x4E,0x13,0xB2,0x97,0x5B,0xB4,0xDD,0xDD,0xEA,0x42,0xF6,0x70,0x8F,0x39,0xAD,0x8F,0x85,0xDB,0xBC,0xCB,0x94,0x3E,0x64,0xD5,0x1C,0x0B,0x95,0x07,0x37,0x78,0x27,0xB9,0xA9,0x86,0x4D,0x1F,0x3C,0xD3,0xA4,0x1B,0x96,0x35,0xAF,0xE1,0x01,0x00,0x00};
//const uint8_t spI_WIN[] PROGMEM ={0x29,0x09,0xDE,0x27,0x82,0xBB,0xF5,0x64,0x26,0x33,0x9D,0xE9,0x48,0x43,0xF6,0x72,0x8B,0xB6,0x35,0x2B,0x99,0x75,0x91,0xAE,0xB2,0x24,0x64,0xC2,0x77,0x99,0x52,0x2B,0x93,0x0B,0x3D,0xED,0x4A,0x2E,0x4D,0xA5,0xC4,0xAC,0x19,0x7A,0x4E,0x55,0xA0,0xB1,0xEA,0x98,0xB7,0x35,0x2D,0x98,0x71,0x51,0xBF,0xD9,0xAE,0xB6,0xC7,0x34,0x4A,0xD9,0xBB,0xBA,0x1E,0xD3,0x39,0xA4,0xEF,0xE8,0x6A,0x48,0xE7,0x90,0xED,0xAD,0x6F,0xAE,0x92,0x9D,0xBA,0xD4,0x3E,0x0D,0xD1,0x99,0x99,0x60,0x13,0x37,0x44,0x4F,0x21,0xEA,0xE9,0xCD,0x60,0xAD,0x26,0x69,0x35,0x53,0xA3,0xB4,0x6E,0x6A,0xD5,0x46,0x8C,0xC2,0x68,0x6B,0xB4,0x6B,0x36,0x19,0xC9,0x95,0x51,0x4A,0xD8,0x64,0x83,0xA9,0x72,0xB8,0x7D};
//const uint8_t spIF[] PROGMEM ={0xAB,0x28,0xD5,0x85,0x2D,0x9E,0xDC,0xE2,0x16,0xB7,0x3A,0xB5,0x0D,0x56,0x1E,0x71,0xB9,0x37,0xBA,0x67,0x40,0x88,0xAE,0x12,0x90,0x00,0x05,0x18,0x10,0x9D,0x19,0x07,0x28,0xF0};
//const uint8_t spIN[] PROGMEM ={0xAB,0x2A,0xD1,0xC4,0xA2,0x2F,0x9D,0xA2,0x79,0x17,0x8D,0x78,0x78,0x8A,0x92,0x4C,0xCC,0xFA,0xE6,0x29,0x4A,0x36,0x53,0xAB,0xB9,0xB7,0xDA,0xD5,0xA9,0x62,0xB0,0x30,0x8F,0x29,0xA3,0x8E,0x5E,0x23,0x5C,0x66,0x87,0x3A,0x05,0x18,0x49,0xD7,0x18,0xEB,0x58,0xBB,0xDA,0x5B,0x58,0x4B,0x73,0xE4,0x1B,0xDD,0x88,0x46,0x29,0xC9,0xB2,0x74,0x4C,0xDB,0x07};
//const uint8_t spINCH[] PROGMEM ={0xAB,0x69,0x59,0x58,0x33,0x66,0x9D,0xAA,0xC6,0x62,0xCE,0x98,0x75,0xAA,0x96,0x5A,0x44,0xED,0xF1,0xAD,0x6E,0xB5,0x9A,0x1C,0x9B,0xCC,0x7A,0xF0,0x9C,0xC2,0xEC,0xAC,0x71,0x85,0x17,0xD6,0x8B,0x58,0x0D,0x77,0x2D,0x57,0xA7,0xC0,0x80,0x46,0xD9,0x08,0x70,0x77,0xBB,0x04,0x34,0xA0,0x01,0x01,0x9C,0x14,0x2D,0x01,0x0A,0x10,0xA0,0xC6,0x0A,0x04,0xE8,0x60,0xFC};
//const uint8_t spINCHES[] PROGMEM ={0x23,0x0A,0x41,0xCD,0xA3,0x26,0xDF,0xFC,0xE4,0xB9,0x98,0x11,0x6F,0xE2,0x9D,0xAD,0x2C,0x45,0x53,0xA7,0x8D,0xED,0x72,0x69,0xB5,0x8B,0x96,0x8A,0xA8,0x48,0xC8,0x6C,0x33,0xCB,0x06,0xF8,0x33,0x34,0x03,0x01,0xB8,0x29,0xA5,0x55,0x21,0x68,0x70,0xE4,0xE3,0xD9,0xF4,0x2E,0x75,0x36,0x68,0x88,0xF7,0xAA,0xDC,0xA5,0xCE,0x44,0x0D,0x89,0x49,0xA9,0x00,0x2E,0xD6,0x0D,0xB0,0xB0,0x88,0x05,0x14,0xF0,0x3D,0x89,0x06,0xE0,0x01};
//const uint8_t spINSTRUCTION[] PROGMEM ={0xAD,0x6A,0xDE,0x95,0x2B,0x66,0xCD,0x6A,0x57,0xA1,0x8E,0x0E,0x92,0x4D,0x96,0xC6,0xDA,0xD7,0xBE,0xF1,0xAD,0x01,0xBE,0x57,0x53,0xC0,0xCF,0x16,0x1A,0x90,0x00,0x28,0xA0,0x84,0x4E,0x05,0xA4,0x18,0x52,0x52,0x53,0x4D,0x3D,0x25,0xDB,0x48,0x5D,0x0E,0xF3,0xA4,0xAC,0x23,0x0D,0xA9,0xDC,0x93,0xB2,0xF6,0xD4,0x56,0x80,0x00,0xE1,0x55,0x14,0xD0,0xE2,0xAE,0x07,0x2C,0xA0,0x80,0x11,0xFB,0x4A,0xDE,0x4D,0x85,0x28,0x66,0xDD,0xCD,0xE8,0xAA,0xEE,0x62,0x15,0xB7,0x69,0xB0,0x31,0x84,0x4C,0x13,0x89,0x41,0x1A,0xA7,0x04,0x2B,0xCF,0x07,0x3E,0xD0,0x05,0x4D,0x06,0x77,0x5B,0x84,0xDB,0x07,0x00,0x00};
//const uint8_t spINSTRUCTIONS[] PROGMEM ={0xAD,0x6A,0xDE,0x95,0x2B,0x66,0xCD,0xAA,0x57,0xA1,0x8E,0x0E,0x92,0x4D,0x96,0xC6,0xDA,0xD7,0xB6,0x11,0xC0,0xF3,0x6A,0x12,0xB0,0x80,0x05,0x24,0x00,0x0A,0x28,0xA1,0x53,0x01,0x29,0x86,0x94,0xD4,0x54,0x53,0x4F,0xC9,0x36,0x52,0x97,0xC3,0x3C,0x29,0xEB,0x4A,0x43,0x2A,0xF7,0xA4,0xAC,0x3D,0xB5,0x15,0x10,0x40,0x78,0x15,0x05,0xB4,0xB8,0x2B,0x01,0x0F,0x18,0x60,0xC4,0xBE,0xD2,0x74,0x53,0x21,0x8A,0x59,0x77,0x33,0xBA,0xAA,0xBB,0x58,0xC5,0x6D,0x18,0x6C,0x0C,0x21,0xD3,0x44,0x62,0x90,0xC6,0x29,0xC1,0xCA,0xF3,0x81,0x0F,0x72,0x94,0x23,0x03,0x5E,0xB2,0xD4,0x00,0x05,0x30,0x80,0x01,0x04,0xCC,0x64,0xF9};
//const uint8_t spIS[] PROGMEM ={0x23,0x6B,0xCE,0x99,0x3B,0x16,0xAF,0xAC,0xDA,0x60,0x9E,0xFC,0xB1,0xF2,0xEC,0x9D,0xB5,0xF2,0xC6,0xC9,0x42,0x50,0x37,0xEF,0x46,0x37,0xBF,0xC5,0xAE,0x56,0xE3,0x7D,0x84,0x84,0xDF,0xEE,0x5D,0xEF,0x6B,0x5F,0xFB,0xD6,0x7F,0xA9,0x6E,0x64,0xEE,0x1C,0xB0,0x00,0xB9,0x03,0xBE,0x60,0x76,0xC0,0xF7,0xAC,0x0E,0xF8,0x9A,0xC4,0x00,0xDF,0xB0,0x21,0x40,0x7A,0x97,0x07,0x00,0x00};
//const uint8_t spIT[] PROGMEM ={0x2B,0x19,0xC1,0x99,0x3D,0xDE,0xEC,0xE2,0x14,0x2D,0xBA,0x88,0xE5,0xDB,0x55,0xD5,0x9C,0xC6,0xE2,0x4F,0x57,0x9D,0xB2,0x99,0x44,0x5F,0x49,0xAD,0x2D,0x1C,0xB1,0x6D,0xDA,0x0C,0xD1,0x98,0x7A,0xA9,0x66,0x00,0x50,0xC0,0x32,0x1E,0x1E,0x10,0x40,0x72,0x49,0x0F,0x00,0x00};
//const uint8_t spJ[] PROGMEM ={0xA1,0xBD,0xAB,0x90,0xC1,0xD4,0x19,0x60,0x47,0x86,0x56,0xED,0xE2,0xC2,0x6C,0xD9,0x57,0x15,0xB2,0xA9,0x68,0x35,0xB9,0xD5,0xAE,0x76,0xB5,0xAA,0x14,0x4C,0x3C,0xAA,0xC5,0xAC,0x66,0x33,0xDA,0x9A,0x9C,0x2D,0xA2,0x71,0x1F,0xD2,0x10,0x23,0x71,0x55,0x47,0x0A,0xA3,0x31,0x66,0x3D,0x6E,0x29,0x8C,0x41,0x8B,0x54,0x87,0xE9,0x07};
//const uint8_t spJOYSTICK[] PROGMEM ={0x01,0x38,0x49,0x79,0x15,0xC5,0xA5,0x91,0x5B,0xB7,0x53,0x38,0x53,0x95,0xCE,0xD9,0x6E,0x7E,0xB3,0x93,0x79,0x57,0x19,0xC6,0x79,0x57,0xE6,0x53,0x58,0xA8,0xAD,0x5E,0x45,0x0C,0x29,0x9A,0xBE,0x66,0x34,0xC1,0x85,0x78,0x64,0x15,0x05,0xFC,0xAC,0x6C,0x01,0x0D,0x68,0x00,0x03,0x60,0x80,0xAD,0x4D,0x46,0x5E,0x62,0xA8,0xAA,0xAD,0xBD,0x4D,0xEB,0x63,0xE1,0xB0,0x98,0xC5,0x6E,0x08,0x0D,0x33,0x72,0x26,0xB3,0x29,0x38,0x95,0xCE,0x70,0x04,0xC0,0x00,0x6B,0x9D,0x18,0xE0,0x92,0x28,0x06,0xE0,0x01};
//const uint8_t spJUST[] PROGMEM ={0x09,0xB8,0x8E,0x60,0xA5,0xC3,0x9A,0x89,0x78,0x9F,0x93,0x67,0x9B,0x2A,0x96,0x6F,0x4F,0x1E,0x62,0xBB,0x8B,0xB7,0xBD,0xC5,0xAD,0x6E,0xD5,0x2A,0x2F,0xC7,0x3C,0x22,0x94,0x02,0xBE,0x95,0xF0,0x80,0x03,0x7E,0x32,0x55,0xC0,0x1F,0xC1,0x1C,0xC0,0x00,0x28,0xA0,0x6A,0x77,0x05,0xDC,0x20,0x22,0x80,0xA4,0x53,0x1E,0x00,0x00};
//const uint8_t spK[] PROGMEM ={0x09,0xE8,0x51,0x25,0x02,0x0E,0xC8,0xD1,0x78,0x44,0xB9,0x99,0x89,0x57,0x93,0x9D,0xDC,0xF4,0x64,0xA5,0xAA,0xAA,0x65,0x9D,0x9B,0xDF,0xE2,0xD6,0xAB,0xF3,0x56,0xBC,0xBB,0x42,0xF7,0x21,0x0F,0x61,0x4C,0x5E,0x24,0x36,0x2B,0xC5,0xC9,0x4E,0x0F};
//const uint8_t spKEY[] PROGMEM ={0x01,0x18,0x9E,0x2D,0x02,0x1E,0x68,0xFE,0x08,0xC6,0x10,0xF5,0x78,0xC6,0x3B,0xD9,0xE9,0xAE,0x76,0xBD,0xDB,0xDD,0x8D,0x7E,0x14,0x13,0xB0,0x7A,0x52,0x86,0xEC,0x99,0x65,0xB6,0x74,0x18,0xB2,0x14,0x8A,0x4F,0xC3,0x76,0xD4,0xA3,0x9D,0x1E,0x00,0x00};
//const uint8_t spKEYBOARD[] PROGMEM ={0x06,0x18,0x23,0xD4,0x01,0xDD,0x0A,0x7B,0x60,0xF8,0x2B,0xAA,0x40,0xE4,0x97,0x19,0xCE,0x70,0x85,0x23,0x3A,0x43,0xE6,0xD7,0x1E,0xA9,0x84,0x5A,0xAF,0x36,0x4D,0xAC,0x73,0x55,0x29,0x95,0x9F,0x8A,0xDA,0x73,0x51,0x8B,0x5A,0x95,0x5A,0x9A,0xFC,0x52,0xD4,0xDE,0x6A,0x63,0x7C,0xCB,0x48,0xFD,0x68,0x8C,0xF3,0x09,0x67,0xF5,0xA3,0x35,0xA5,0x4A,0x4C,0xD4,0x8F,0xDE,0x56,0x77,0x0D,0xF1,0xDE,0x7A,0x5B,0x42,0xB5,0x34,0x7B,0xEB,0x7D,0x33,0xE5,0xF2,0xF4,0xA9,0x57,0x41,0xC9,0xAB,0x1C,0xDB,0x5E,0xF7,0xBA,0xD7,0xFD,0x03,0x00,0x00};
//const uint8_t spKNOW[] PROGMEM ={0xA1,0xF2,0x0E,0x3E,0xD3,0xA9,0x94,0x3A,0x78,0xB8,0xA8,0xA0,0x93,0x6A,0xEF,0xE0,0xA3,0x9C,0xF1,0xAA,0xA2,0xE7,0x32,0xF3,0x24,0xA7,0xB0,0xDE,0xDB,0xDC,0xDB,0xDC,0xFC,0xE6,0x37,0x5F,0x95,0xF2,0xB9,0x61,0xD4,0x65,0x57,0xBB,0x6E,0x2D,0x8F,0xB3,0x6A,0xD4,0xA5,0x76,0xB5,0x0F,0x3D,0xDD,0x1B,0xAA,0x92,0xC8,0xF7,0x0F,0x00,0x00};
//const uint8_t spL[] PROGMEM ={0x27,0x8F,0x25,0xDC,0xA4,0x5B,0x9F,0x3C,0xE5,0x08,0xA7,0x6A,0x73,0xF2,0x10,0xCB,0x83,0xAB,0xCE,0xCD,0x4F,0xE5,0xE4,0x8D,0xA9,0x74,0xBA,0x55,0xA9,0xF8,0x3E,0x11,0xCF,0x4A,0xB5,0xCE,0x75,0xAE,0x43,0xC3,0xCF,0x84,0x70,0xD6,0x72,0x0D,0xDB,0x67,0xE4,0x11,0xDB,0x35,0xBC,0x7C,0x92,0x6A,0x63,0xD5,0xB2,0xB8,0xAE,0xA2,0xB6,0x79,0xFB};
//const uint8_t spLARGE[] PROGMEM ={0xA5,0xB1,0xC6,0x5A,0xB9,0x5A,0xB5,0xDA,0x6A,0x9D,0x80,0x49,0xBD,0x2A,0xAF,0xAB,0x9B,0x79,0xCE,0xAD,0x56,0x11,0x4C,0x55,0x09,0x2F,0x59,0x85,0x8B,0x95,0x29,0xD2,0x64,0x54,0xAE,0x97,0x64,0x50,0x93,0x5D,0xED,0x6A,0xD5,0x7E,0xB9,0x7A,0x50,0xD6,0x59,0xAF,0x3A,0xD4,0x52,0x2E,0x49,0xDF,0x9B,0xD0,0xC6,0x1E,0x82,0x1E,0xF5,0x01,0x34,0xA0,0x01,0x09,0x48,0x80,0x03,0x14,0x78};
//const uint8_t spLARGER[] PROGMEM ={0xA9,0xB5,0x9A,0xAF,0x24,0x3C,0xB6,0xDA,0x6B,0xFE,0x94,0xF0,0x74,0x2A,0xE3,0x7B,0x42,0x64,0xC9,0x29,0x9C,0x99,0xB1,0xE0,0xCE,0x27,0xB3,0x39,0x35,0x83,0xBD,0xEC,0x6C,0x65,0x21,0xB6,0x78,0x93,0x97,0x95,0xC7,0x5C,0xA2,0x25,0x5E,0x77,0xB1,0xEB,0xD9,0xE4,0x5E,0x01,0x8D,0xB0,0x6A,0xA0,0x74,0x7E,0x92,0x45,0x6A,0xD7,0xDA,0x87,0xC1,0x2F,0xB2,0x48,0x79,0x1D,0x07,0x3F,0xE8,0x81,0x0F,0x0F,0x00,0x00};
//const uint8_t spLARGEST[] PROGMEM ={0xA5,0xD0,0xCA,0xB3,0x39,0x66,0x8E,0xCA,0x0B,0xF7,0x15,0xED,0xB4,0xAA,0x20,0xCC,0x9F,0xDC,0xCD,0x29,0xA2,0xF1,0x29,0x93,0x36,0xA7,0xF0,0x3E,0xA6,0x8D,0xD3,0x9C,0xC2,0xE6,0xCC,0x11,0x49,0x7D,0xF3,0x93,0xFB,0x69,0x56,0x2A,0xAD,0x4E,0x1E,0xA7,0xAB,0xB9,0xA6,0x5D,0x55,0x5A,0xA6,0x64,0xE1,0x26,0x54,0xAF,0x65,0x0A,0x10,0xDD,0x04,0x34,0xC2,0x3A,0xEA,0x9B,0xC3,0x08,0x55,0x5B,0xAB,0x83,0x37,0x15,0x9B,0x39,0xA3,0x0D,0xD6,0x42,0x2D,0x6F,0x97,0xDE,0x04,0x77,0x8D,0xAD,0x54,0xFA,0xA0,0x42,0x43,0x2A,0xB5,0x03,0xBE,0x34,0xF1,0x80,0x07,0x28,0x00,0x08,0x40,0xB9,0xC3,0x00,0x47,0xBB,0x09,0x20,0x69,0xE7,0x07};
//const uint8_t spLAST[] PROGMEM ={0xA1,0x61,0xFE,0x25,0xB9,0x22,0x96,0x46,0xF8,0xB5,0x82,0xB7,0x32,0x6A,0x3E,0x52,0x23,0xDA,0xD1,0xA9,0x6C,0xCD,0xF0,0x98,0xB0,0xB7,0xB8,0xF9,0xCD,0x6F,0x71,0xAB,0xD3,0x84,0x1E,0x29,0xD6,0x56,0x76,0xD3,0xDB,0xDC,0x29,0x60,0xAB,0x34,0x0D,0x68,0x40,0x02,0x1C,0xC0,0x00,0x80,0x01,0x12,0xCB,0x60,0x40,0x51,0x25,0x0F,0x00,0x00};
//const uint8_t spLEARN[] PROGMEM ={0xA5,0xB3,0xDA,0x3A,0x85,0xB7,0xB4,0x26,0x6A,0x8E,0x36,0xCC,0xDB,0x6A,0xE9,0xAB,0x92,0x32,0xC9,0xAC,0x56,0x61,0x74,0x8F,0xBB,0x66,0x5A,0x99,0xD5,0x55,0x56,0x92,0x79,0x65,0xCE,0xB7,0xF1,0xAA,0xDA,0x99,0xCF,0x62,0x54,0x21,0x8E,0x52,0xB9,0xB6,0x59,0xEF,0x76,0x75,0x21,0xA7,0x61,0x84,0xF3,0xD9,0xCD,0x3E,0xF4,0x52,0xCB,0xA4,0x85,0x65,0xDF,0xFB,0xCE,0x75,0xCA,0x70,0xB9,0x76,0x2C,0xD7,0x69,0x4D,0x1B,0x16,0x76,0x42,0x67,0x55,0x84,0x64,0xDA,0x7E,0x00,0x00};
//const uint8_t spLEFT[] PROGMEM ={0xAD,0x0E,0xB0,0x96,0x2B,0x5A,0x8C,0xC2,0x93,0x49,0xAE,0x5C,0x78,0x72,0x1F,0x23,0xC5,0xBE,0xF6,0xCD,0x6F,0x71,0xEA,0x58,0xA2,0xC4,0x3A,0xF1,0x6D,0x5B,0xE7,0x63,0x04,0x7B,0x4C,0x8A,0x23,0x03,0xA2,0x35,0xD1,0x80,0x02,0x86,0xF7,0x00,0x00,0x70,0x40,0x17,0xE6,0x08,0x60,0x29,0xFD,0x01,0x00,0x00};
//const uint8_t spLESS[] PROGMEM ={0xA6,0x16,0xBA,0xDB,0x43,0x52,0x85,0xD6,0x88,0x2A,0x76,0x6D,0x53,0x5A,0xA7,0xD4,0xC3,0xA8,0x6B,0x6B,0x9C,0x31,0x2F,0x92,0xAE,0xA7,0x8E,0xC9,0x5B,0xAC,0xB6,0xDD,0xFA,0xD6,0xA7,0x4A,0x59,0x47,0xB8,0x52,0xDE,0xEA,0x14,0xB1,0x66,0xA3,0x66,0x92,0x52,0xB8,0x1C,0xCE,0x31,0xA1,0x15,0xF0,0x63,0xB8,0x07,0x0C,0xF0,0x83,0x87,0x07,0x02,0xF0,0x83,0x47,0x00,0x9E,0xC9,0x32,0xC0,0x51,0x96,0x04,0x70,0xB1,0x98,0x00,0x31,0x63,0xC2,0x03,0x00,0x00};
//const uint8_t spLET[] PROGMEM ={0xA9,0x49,0xCA,0x79,0xC1,0xDA,0x96,0x26,0x5A,0xE3,0x06,0xEF,0xBD,0xEA,0x9C,0xA5,0x5C,0x73,0xD3,0xAE,0x67,0x35,0xAB,0x59,0xC4,0x1C,0x00,0xC0,0x01,0x4D,0x84,0x0B,0x60,0xCA,0x30,0x04,0xF8,0xEC,0xF4};
//const uint8_t spLIKE[] PROGMEM ={0xAA,0x96,0xB1,0x5F,0xB1,0xD3,0xC4,0xAA,0x36,0xB3,0xDE,0xD5,0x29,0x5C,0xCD,0xD6,0x68,0x27,0xB7,0x38,0x55,0xAC,0x31,0x6A,0xED,0xE4,0x34,0xB9,0x45,0x19,0xB7,0x9B,0xD6,0xA7,0xA5,0x49,0xB5,0x1A,0xD3,0x58,0xBA,0x18,0xFB,0x46,0x74,0x53,0x69,0xA8,0x16,0x55,0x0A,0x00,0x0C,0x90,0x73,0xA0,0x06,0x24,0xF0};
//const uint8_t spLIKES[] PROGMEM ={0xC4,0x75,0x20,0x6D,0x24,0x1D,0x99,0x4A,0x8B,0xF2,0x82,0x4C,0x16,0x5A,0x43,0xD7,0x12,0x66,0x6E,0x69,0x0C,0xCF,0x6C,0x88,0xD6,0xA5,0xB2,0xB2,0xAF,0x50,0x7A,0xCD,0x6A,0x15,0x26,0x6C,0x1B,0xD7,0x92,0x9D,0xCF,0xEC,0xE4,0xDE,0x4F,0x39,0x57,0x93,0x53,0x25,0x37,0x11,0xE2,0x4D,0x4F,0x9B,0x53,0x85,0x8B,0x37,0x1D,0x7D,0xF2,0x25,0x9E,0xD9,0xA8,0x8C,0xB1,0x88,0x46,0xD5,0xE4,0x38,0xFA,0x11,0x00,0x08,0xE0,0x97,0x88,0x00,0xDC,0x72,0x36,0xC0,0x96,0x95,0x06,0xF8,0x3E,0x27,0x00,0x3F,0xBB,0x3B,0xE0,0x07,0x55,0x03,0x7C,0xA3,0x62,0x80,0x2F,0x55,0x1E};
//const uint8_t spLINE[] PROGMEM ={0x00,0xA1,0xE2,0xEE,0x35,0x25,0xA2,0xA4,0x42,0x98,0xEE,0x81,0x88,0xD3,0x5A,0x65,0xFC,0x13,0xC6,0xF3,0x29,0x8C,0x8D,0x57,0xCC,0x2C,0xA7,0x30,0xB1,0x5E,0xA4,0xD2,0x9C,0xCA,0xE4,0x3E,0xC9,0x4E,0x73,0x2A,0x93,0x7B,0xD4,0xDA,0xCA,0xA9,0x4C,0xEA,0xB6,0x2A,0x2B,0xA7,0xB2,0xA9,0xCB,0x2D,0xAD,0x9C,0x2A,0x84,0x4A,0xB3,0xB0,0x72,0x9A,0x94,0x35,0x55,0x33,0xD6,0x6A,0x63,0xD5,0x90,0xCA,0x58,0xA3,0xCF,0x55,0x4D,0xA2,0x62,0x95,0x31,0x15,0x72,0xA9,0x8E,0x95,0xC7,0x32,0x26,0xAF,0x9C,0x56,0x29,0xCD,0xC8,0x9D,0x46,0x49,0xA5,0x34,0x23,0xB5,0x69,0xE5,0xE5,0xC8,0x8D,0x3E,0xA9,0xAA,0x76,0xCA,0x07,0x00,0x00};
//const uint8_t spLOAD[] PROGMEM ={0x21,0x37,0xCA,0x63,0xC1,0xBC,0xB5,0xDE,0x1B,0x9A,0x46,0xF3,0xD6,0xDA,0xE4,0xA0,0x87,0x32,0xDF,0xAA,0xA2,0x95,0x3D,0xCA,0x7C,0xAB,0x32,0xC6,0x7F,0x20,0xF3,0x8D,0x42,0x85,0xDE,0x02,0xC9,0x36,0x0A,0x1D,0x7B,0x0A,0xD1,0x7F,0xAB,0x94,0xEF,0x29,0x42,0xFF,0xAD,0x52,0xA6,0xA7,0x08,0xBB,0xB6,0x46,0x9B,0xD8,0x44,0xCC,0x57,0x3A,0xAB,0x7D,0xDD,0xA0,0x4F,0xEA,0xAD,0x8C,0x63,0x87,0xDE,0x69,0x74,0xCA,0x26,0x12,0xFA,0xA4,0xC9,0x5A,0x9E,0x71,0xF1,0x1C,0x26,0x6F,0xA8,0x2A,0x31,0x15,0x9B,0xA8,0x8A,0x6C,0xCB,0x54,0x6A,0xA2,0xB2,0xCA,0x7C,0x14,0xB1,0x89,0xCA,0xC8,0x74,0x75,0x12,0xA6,0xEE,0xC2,0x45,0x25,0xA9,0xED,0x44,0x9B,0x83,0xB9,0x73,0xA6,0x42,0x7D,0xB6,0x6E,0x06,0xA4,0xE4,0x01,0x00,0x00};
//const uint8_t spLONG[] PROGMEM ={0xA9,0x0D,0x16,0xBB,0x21,0xF3,0xA5,0x2E,0x39,0x98,0x81,0xD0,0x37,0x5A,0xAB,0xAD,0x1B,0x93,0xED,0xAA,0x55,0xEC,0x4F,0x88,0xB6,0xA3,0x92,0x63,0xC7,0x21,0x5A,0x8F,0x42,0xDB,0x3F,0x27,0xCB,0xBC,0x32,0xAB,0xFE,0x8D,0x2C,0xF3,0xC8,0xBC,0xD8,0x37,0x8C,0xD6,0x33,0x6F,0x85,0x8E,0x3F,0xAC,0x9D,0x61,0x54,0xAA,0x5E,0x8A,0x46,0xA2,0xD1,0xE8,0x78,0xAD,0xEA,0xAD,0x4F,0x6B,0xF2,0x96,0xAA,0xB6,0x6E,0x9D,0x49,0x9D,0x61,0xD4,0x39,0xF4,0x3E,0xC0,0xB9,0x5A,0x1D,0xDF,0xBB,0xDE,0x7A,0xF8,0x50,0x8D,0xED,0x3A,0xED,0xE8,0x5D,0x4D,0xB1,0xEF,0x6C,0xFF};
//const uint8_t spLOOK[] PROGMEM ={0xA6,0x91,0x3A,0x3B,0x20,0xEF,0xA4,0xC6,0x71,0xAF,0x02,0xED,0xD6,0xEA,0xA8,0x78,0x12,0x34,0x6F,0xCB,0x92,0xA2,0x6E,0xA4,0x7C,0x23,0x0B,0x3C,0x36,0x44,0x9A,0x8E,0xCC,0xB2,0x79,0x96,0x5C,0xD5,0x32,0x2D,0xBF,0x21,0xBB,0xD1,0x28,0xAC,0xD8,0x55,0xD5,0x2D,0xBD,0x2E,0x9D,0x93,0xDD,0xEE,0xB4,0xC7,0x0D,0xDA,0x56,0xA4,0x4A,0x67,0x00,0x50,0x40,0xDE,0xA6,0x0A,0x88,0xD1,0x48,0x00,0xC5,0x17,0x30,0xA0,0xC4,0x20,0x04,0x58,0x2F,0xFC};
//const uint8_t spLOOKS[] PROGMEM ={0xA6,0x91,0x3A,0x3B,0x20,0xEF,0xA4,0xC6,0x71,0xAF,0x02,0xED,0xD6,0xEA,0xA8,0x78,0x12,0x34,0x6F,0xCB,0x92,0xA2,0x6E,0xA4,0x7C,0x23,0x0B,0x3C,0x36,0x44,0x9A,0x8E,0xCC,0xB2,0x79,0x96,0x5C,0xD5,0x32,0x2D,0xBF,0x21,0xBB,0xD1,0x28,0xAC,0xD8,0x55,0xD5,0x2D,0xBD,0x2E,0x9D,0x93,0xDD,0xEE,0xB4,0xC7,0x0D,0xDA,0x56,0xA4,0x4A,0x67,0x00,0x20,0x80,0xBB,0xC5,0x0C,0xD8,0xCA,0x92,0x01,0x3F,0x7B,0x72,0x80,0x03,0x1C,0xE0,0x00,0x05,0x1E,0x00,0x00};
//const uint8_t spLOWER[] PROGMEM ={0xA9,0x2F,0x01,0x36,0x9D,0xF0,0xF7,0x6E,0x36,0xA3,0x92,0x21,0xBF,0x40,0xDB,0xCD,0x6A,0xA6,0x3D,0xAD,0x69,0xC8,0x79,0xA9,0x17,0xF0,0xBE,0xA9,0x12,0xD9,0x5E,0x94,0xF3,0x94,0x56,0x74,0xCF,0x49,0xCD,0x93,0x87,0x30,0xF1,0xE9,0xBD,0xE1,0x72,0xDD,0x22,0x9B,0xDA,0x07,0xA7,0x31,0x8B,0x6E,0xEC,0x5F,0xAA,0xC6,0x2C,0xA6,0xA8,0xE6,0x19,0x6D,0x77,0xF8,0x66,0x6C,0xDA,0xB6,0xE0,0x01,0x00,0x00};
//const uint8_t spM[] PROGMEM ={0x2D,0xCA,0x5E,0x34,0xAA,0x4A,0xAD,0x34,0x27,0x15,0xCF,0x1A,0x75,0xD3,0x95,0xE5,0x24,0x69,0x9E,0xB5,0x4E,0x11,0x5D,0xA6,0xAB,0xA6,0xD9,0xD5,0x68,0x4C,0x1A,0x77,0xB1,0x54,0xA9,0xD5,0x96,0xCA,0xB9,0xB3,0xE5,0x2E,0xF7,0xB1,0xB7,0xBD,0x1D,0xF4,0x08,0x0F,0x00,0x00};
//const uint8_t spMADE[] PROGMEM ={0x6A,0xD4,0x96,0xCA,0xB9,0xB3,0xB9,0xCE,0x3A,0x6C,0xD1,0x68,0x5B,0x1A,0x1F,0xB0,0x59,0x3C,0xED,0xA9,0xCA,0xF2,0x20,0xAD,0x34,0xB7,0xB8,0xF9,0xC9,0xEB,0x10,0xE5,0x9C,0x3A,0xBB,0x98,0xD5,0x6C,0x66,0x9B,0xFA,0x52,0x48,0xA4,0x67,0x72,0xEE,0xE3,0x00,0xC0,0x46,0xAA,0x32,0x2A,0xC2,0x89,0x1D,0xDD,0x18,0xB4,0xB9,0x95,0xCF,0x14,0x63,0xCC,0x62,0x2C,0x95,0x18,0x1E};
//const uint8_t spMAGENTA[] PROGMEM ={0xA2,0xA0,0x26,0xF2,0xCD,0x9D,0xB4,0x4E,0xC5,0x68,0xE7,0x4A,0xB4,0xBA,0x10,0xB5,0x83,0xBD,0xF7,0xE9,0x72,0xB4,0x54,0x93,0x4E,0xA5,0x8B,0x9E,0xCD,0xD8,0x72,0x8A,0x1E,0xDB,0xD8,0x71,0xB3,0xC9,0x06,0x2A,0x2B,0x33,0xCA,0x96,0x02,0x1A,0x41,0xB6,0xC0,0xAA,0x6A,0x34,0x13,0xF1,0x37,0x2B,0x0D,0x4E,0xD3,0xA3,0x2A,0xAD,0xD4,0x07,0x1D,0xB7,0x91,0xB9,0x52,0x1F,0x2D,0xD5,0xCB,0x76,0x4F,0x4D,0xCE,0x8D,0x5D,0x53,0x5A,0x36,0x40,0xB1,0x2A,0x06,0xF0,0xD8,0x6D,0xD5,0x21,0x49,0xAB,0x4E,0xEA,0xDB,0xAD,0xC9,0x27,0x9D,0x90,0x5C,0x92,0x66,0x17,0x3C,0x4A,0x35,0x72,0x5A,0x43,0x36,0x2F,0x8A,0x4A,0x69,0x8D,0x85,0x33,0x2C,0x94,0x9A,0xD9,0x26,0xB5,0xE0,0xB2,0xF2};
//const uint8_t spMAKE[] PROGMEM ={0xA2,0xE1,0x56,0x66,0xB8,0x13,0x87,0xCE,0x3A,0x2C,0xB7,0xF4,0x92,0x1A,0xE7,0xB1,0xC4,0xD2,0xCF,0xA9,0x4A,0xF1,0x70,0xA5,0xAD,0xA7,0x28,0xC5,0xDD,0xD4,0x97,0x9E,0xAC,0x64,0x33,0xD3,0x9E,0x73,0xB3,0x93,0xD5,0x6A,0xA2,0xBA,0xB3,0x4F,0xD5,0x46,0x88,0x70,0xBD,0x19,0x6D,0x49,0x42,0x56,0x3D,0xA9,0xF6,0x6E,0x2A,0x95,0x20,0x72,0x13,0x03,0x00,0x18,0x20,0x55,0x65,0x05,0xC4,0xA6,0x28,0x80,0x9C,0x13,0x1E};
//const uint8_t spME[] PROGMEM ={0xAC,0x53,0x96,0xB2,0x53,0x33,0x9B,0x36,0x0F,0x30,0x35,0xAE,0xDF,0xDB,0x59,0xAF,0xAA,0xF7,0x52,0x60,0x79,0xBB,0xAB,0x59,0xF5,0xAA,0xB7,0xBD,0xAD,0x6D,0x69,0x5B,0x0B,0x06,0xF3,0x27,0xA5,0xAD,0x45,0x48,0xB2,0x26,0x87,0x3E,0x7A,0xF0,0xEC,0x36,0x6C,0xFA,0x60,0xC1,0xB3,0x52,0x32,0xEB,0x53,0x42,0x66,0x6D,0x39,0x0F,0x00,0x00};
//const uint8_t spMEAN[] PROGMEM ={0xAE,0x35,0x0E,0xAA,0x2C,0x12,0xA7,0xD6,0x05,0x28,0x75,0x4B,0x3D,0xDA,0x94,0x54,0xD5,0xB4,0xCD,0xA9,0x5A,0x49,0x41,0xB5,0xD7,0xB7,0xBA,0xD5,0xAE,0x46,0x55,0xAD,0xB0,0xEC,0x04,0xDE,0x55,0xAF,0x67,0x33,0xDB,0xD9,0x85,0xCE,0x3A,0xA8,0xD2,0x96,0x1D,0xFB,0xD0,0x5B,0x87,0x6D,0x51,0x8A,0x55,0x2F,0xAD,0x4C,0x6A,0x5B,0x32,0x7D,0xD6,0x05,0x4A,0xD1,0xF8,0x01,0x00,0x00};
//const uint8_t spMEMORY[] PROGMEM ={0xA4,0x56,0x96,0x2D,0x29,0xF3,0xB2,0xC2,0x78,0xF4,0x90,0x4C,0x1B,0xAA,0x94,0x2D,0x54,0xAD,0xCD,0xAD,0x6E,0x75,0x8B,0x95,0x97,0x6A,0x6D,0x18,0xC9,0x5C,0xE5,0x12,0x15,0x71,0x24,0x33,0x95,0xCF,0x98,0x22,0xD2,0x38,0xD7,0xA9,0xB1,0x9B,0xCA,0x82,0xDD,0xE4,0x36,0x76,0xA1,0xB3,0x8B,0xCA,0x52,0xBC,0x84,0xDE,0x4F,0x4A,0x1E,0xE9,0x94,0xFA,0xD0,0xC5,0x35,0x7C,0x59,0x18,0x52,0xE1,0x90,0xEC,0xD9,0x6E,0x88,0x89,0xCC,0x6B,0x22,0xAB,0x21,0x5A,0xD6,0xEC,0x0A,0xAC,0x86,0x1C,0xC0,0x22,0x46,0xAC,0x19,0x4B,0x02,0x8B,0x18,0xA9,0x0F};
//const uint8_t spMESSAGE[] PROGMEM ={0xA6,0xD3,0x0E,0xAA,0x24,0x63,0x87,0xCE,0x05,0x68,0xD5,0x76,0xD2,0xDA,0x90,0x30,0x94,0x25,0xCB,0xA9,0x4B,0xF5,0x56,0xF1,0x36,0xB7,0x3A,0x55,0x2E,0x5E,0x4A,0x93,0x7A,0x54,0xDE,0x85,0x25,0x9F,0xE4,0x58,0x19,0xE0,0x29,0x57,0x03,0xBC,0x68,0x64,0x80,0xA7,0x5D,0x05,0x50,0x89,0xF3,0x68,0x72,0x51,0x57,0xF1,0xA7,0xBB,0x9B,0x43,0x1E,0xC3,0x14,0xB4,0xB1,0xBB,0x2F,0x70,0x93,0x94,0x2E,0x56,0x95,0x80,0x4D,0x5C,0xA6,0x97,0x87,0xED,0x32,0xED,0xAC,0x20,0x92,0x4E,0x14,0xB0,0xBB,0xA2,0x02,0xCE,0x08,0x52,0xC0,0xCA,0xC2,0x04,0x48,0x4A,0x05,0xE0,0x01};
//const uint8_t spMESSAGES[] PROGMEM ={0xAE,0x67,0xDE,0x35,0xAC,0x12,0xA6,0xDE,0x46,0x0C,0x95,0x48,0x9D,0x5A,0x9F,0xC4,0x45,0xB1,0xED,0x68,0x4A,0xCA,0x50,0xE3,0xA4,0xB7,0x1A,0x45,0x6E,0x51,0x86,0x99,0x76,0xA4,0xBE,0x9A,0x4B,0x8C,0xE2,0x92,0x26,0xD7,0xA4,0xD0,0x51,0x1C,0xB0,0xA0,0x8A,0x05,0x2C,0x10,0xC2,0xEA,0x42,0x55,0xB9,0xEB,0xAD,0x56,0xDD,0x43,0xA8,0x18,0xE4,0x0B,0x5D,0x91,0xAA,0xEC,0xD2,0x55,0xF4,0x16,0x5B,0x66,0x84,0x42,0x03,0x74,0x02,0x36,0xDA,0x96,0xDC,0xCC,0xB0,0xFB,0xED,0x76,0x37,0xFB,0xD2,0x7B,0x27,0x65,0x9A,0x4B,0xC3,0x10,0x68,0x86,0x7B,0xE4,0x4C,0xC3,0xA3,0x1C,0xE1,0x91,0x46,0x01,0x07,0xB0,0x30,0xE0,0x1B,0x56,0x02,0x7C,0x25,0xFA};
//const uint8_t spMIDDLE[] PROGMEM ={0xA9,0xCD,0x0D,0x82,0x55,0x92,0xB5,0x3A,0x66,0xB0,0x10,0xAD,0x7E,0x8A,0x98,0x34,0xD4,0x2F,0xD6,0xCD,0x6F,0xD6,0x72,0x1B,0xAD,0x8C,0x36,0x6A,0xAB,0x3D,0xAB,0x28,0xA3,0xB6,0xB3,0x6A,0x95,0xB4,0xDF,0xC6,0xD2,0xA6,0x37,0xB5,0x4B,0xBD,0x34,0xBF,0x22,0x9E,0x25,0x8C,0x5A,0xEE,0x3B,0x53,0x9F,0x30,0x69,0xF1,0xA3,0xC2,0x8B,0x1E,0x00,0x00};
//const uint8_t spMIGHT[] PROGMEM ={0xAE,0xB3,0x4E,0x9B,0x94,0x53,0x87,0xCE,0x59,0x69,0x56,0xB6,0x9B,0xDB,0x5C,0x9F,0x2A,0xA4,0xCE,0x90,0x8A,0x73,0xAB,0x53,0x85,0x5A,0xE9,0x52,0x71,0x4E,0x95,0x7A,0xA6,0x49,0x56,0x59,0x75,0x1E,0xE6,0x2A,0x1D,0x67,0xD4,0xB9,0xA8,0x98,0x57,0xE5,0x54,0x47,0x2F,0x92,0x9D,0x85,0x4D,0x15,0xA5,0xA9,0x8B,0x2B,0x06,0x00,0x06,0x24,0x1D,0xC4,0x80,0x6E,0xD4,0x08,0x10,0x83,0x32,0x3C,0x00,0x00};
//const uint8_t spMODULE[] PROGMEM ={0xAE,0x51,0x4E,0x5A,0xD4,0xD5,0x84,0xD6,0x3A,0x69,0x51,0x96,0x9B,0x5A,0xE3,0xB4,0x45,0x4C,0xE9,0x6C,0x4E,0x9D,0x42,0x74,0x50,0xD9,0xBD,0xD5,0xAD,0x4E,0x11,0x43,0x56,0x50,0xC5,0x39,0x45,0x72,0x23,0x8E,0x95,0xD4,0x55,0x2A,0x2A,0x45,0x8C,0x6D,0x56,0x21,0x3F,0x9E,0x9E,0x92,0x0D,0x90,0x08,0xEB,0x6A,0x52,0x30,0x95,0xD0,0x74,0xBB,0x19,0x4D,0xD0,0x16,0xDE,0x98,0x6E,0xB6,0xA5,0xB3,0x3A,0xDA,0x13,0xBA,0xA6,0x5E,0xA4,0x19,0x76,0xCB,0x9D,0x66,0x11,0x6B,0xD3,0xC8,0x9F,0x99,0x45,0x8A,0x6F,0x26,0x2F,0x0F};
//const uint8_t spMORE[] PROGMEM ={0xA1,0x4D,0x1E,0xC6,0x94,0xE5,0x85,0x36,0x58,0x68,0x57,0x91,0xD7,0xEB,0x54,0xB1,0xDB,0xC6,0x34,0x75,0x72,0x15,0x2A,0x76,0xB3,0x80,0x3F,0x49,0xAC,0x52,0xC5,0x47,0x1D,0xA3,0xB7,0x6D,0xB5,0xC8,0x39,0x29,0xEC,0x7E,0x34,0x3A,0x7B,0x95,0xB3,0xF2,0xD2,0xA9,0x29,0xB9,0xA2,0x59,0xF3,0x90,0x06,0xB3,0xC4,0xD7,0x24,0x8F,0x1B,0xF5,0x10,0x7B,0x4E,0x4D,0x61,0xB0,0x5D,0x64,0xCD,0x55,0x9B,0x3E,0x2C,0xE2,0xD0,0xD0,0xFC};
//const uint8_t spMOST[] PROGMEM ={0xAD,0x49,0x1E,0x53,0x8C,0xED,0x96,0xDA,0xBA,0x3C,0x63,0x5D,0xB3,0xAB,0x52,0x88,0xDD,0xC6,0xD5,0x11,0x6B,0x5E,0xF3,0x52,0x39,0x19,0x6B,0x0E,0x7D,0x6B,0x9D,0x5B,0xD3,0x8B,0x50,0x29,0x6E,0xAD,0x04,0xB0,0x54,0xA8,0x05,0x1C,0xF0,0x63,0x98,0x05,0x3C,0x60,0x01,0x09,0x50,0x80,0x00,0x56,0x88,0x19,0x60,0x19,0x72,0x01,0x54,0x15,0x0E,0x00,0x40,0xFA,0x6C,0xDD,0x5C,0x4D,0xF1,0x03,0x00,0x00};
//const uint8_t spMOVE[] PROGMEM ={0xA5,0x4A,0x0E,0x5D,0x13,0xF4,0x96,0x3A,0x7B,0x30,0x1B,0x48,0xD6,0x2A,0xE9,0x37,0x44,0xAB,0xD9,0xCE,0x66,0xDA,0x12,0x11,0xC7,0x55,0xB3,0x76,0x49,0x78,0x6D,0xB6,0xCC,0xCA,0x25,0x13,0xAD,0x84,0xBD,0x5B,0x95,0x4A,0x9A,0x1E,0x74,0xDB,0xD4,0xEA,0xC8,0xF4,0xD9,0xA4,0x7B,0xEB,0x82,0xD4,0xB1,0x84,0xEC,0x75,0xA8,0x43,0x1E,0xC2,0x64,0x55,0xB4,0x3A,0x74,0x75,0xB3,0x31,0xEE,0x61,0x21,0x07,0x01,0x54,0xA4,0x10,0x20,0xD8,0x50,0x01,0x04,0xE7,0x4A,0x00,0x9F,0x43,0xE0,0x01,0x00,0x00};
//const uint8_t spMUST[] PROGMEM ={0x6A,0x14,0x4A,0xB2,0xD4,0xDD,0xBA,0x26,0x58,0x2C,0x75,0x71,0x12,0xEA,0x68,0xB1,0xD5,0xD0,0xEE,0xA8,0xBD,0x8D,0x37,0xE1,0xCD,0xBB,0x5A,0x85,0x73,0x75,0xA6,0xD6,0x78,0x17,0xBB,0xDA,0xF5,0x68,0x5D,0xF0,0x52,0x6B,0x29,0xA1,0xCF,0x36,0x4D,0x30,0x95,0x30,0xE0,0xC8,0x54,0x09,0x68,0x40,0x03,0x04,0x80,0x21,0x1E,0x01,0xD0,0xA5,0x03,0x20,0x40,0xEA,0x34,0x05,0x1C,0xA9,0xFE};
//const uint8_t spN[] PROGMEM ={0xAB,0x48,0x3A,0x55,0x3F,0x62,0x9D,0x3C,0x15,0x57,0xB3,0x9A,0x7A,0xF2,0xD4,0x2C,0xD8,0x27,0xF6,0xCD,0x77,0xB1,0xAB,0xD3,0xA4,0xEC,0x21,0xEA,0xB3,0x77,0xDB,0x7A,0x13,0xD4,0x55,0xB3,0xB6,0x1F,0xEC,0x60,0x47,0x33,0x7A,0x4F,0xAE,0x9C,0x4E,0xF5,0xC4,0x26,0xA9,0xB9,0x5A,0xD2,0xF2,0x03,0x00,0x00};
//const uint8_t spNAME[] PROGMEM ={0xAE,0x0D,0x9A,0xCC,0x9F,0xE3,0xA4,0x2E,0x58,0xB0,0x68,0x6B,0x52,0xBA,0x14,0x40,0xBC,0xAD,0x5A,0xED,0x6A,0x9B,0xDB,0xD2,0x54,0x9F,0x26,0x66,0x8F,0x66,0xB5,0xAA,0x16,0xCA,0x44,0x6D,0xF1,0x2E,0x76,0x31,0x8A,0x11,0x52,0xD8,0x63,0xF1,0xAC,0x76,0x35,0x9A,0x9D,0xC2,0xC0,0x7C,0xD1,0xEC,0x5A,0x3F,0x73,0x2A,0xB8,0xAF,0x6E,0x43,0x9D,0x4E,0xEC,0x3E,0xCB,0x0D,0xC6,0xC1,0x38,0x77,0x12,0x3B,0x98,0xD1,0x7A,0x1C,0x91,0x4E,0x63,0x46,0x19,0x24,0x4C,0xB2,0xB5,0x1A,0xB9,0x95,0x4E,0x4D,0xD7,0xA6,0x93,0xD6,0x2D,0xC2,0x13,0xA9,0xD6,0x25,0x23,0xD6,0x88,0x26,0xDA,0xB0,0x82,0xD4,0xC2,0x32,0x3C};
//const uint8_t spNEAR[] PROGMEM ={0xA2,0x66,0x56,0x6E,0xC4,0x4C,0x99,0x8A,0x5B,0xEE,0xB4,0x28,0x6D,0x2A,0x69,0x39,0xCA,0x6D,0x74,0xA8,0x8C,0x61,0xAB,0xB0,0x4A,0x23,0x6F,0x25,0x99,0xD5,0x57,0xDF,0xEC,0x66,0x27,0x2B,0x3D,0x85,0xCC,0xFB,0xDE,0xFC,0x16,0xA7,0x4A,0x23,0x45,0x42,0xB2,0xDF,0xF6,0x76,0xBB,0x6F,0xBD,0x2B,0xA6,0xFA,0xE6,0xA6,0x0E,0x79,0xF0,0xBD,0xEA,0xAD,0x57,0x96,0x72,0x97,0xAA,0x0B,0xD5,0x89,0x58,0x1C,0x3D};
//const uint8_t spNEED[] PROGMEM ={0xA1,0x0B,0x0E,0x3C,0xDB,0xA2,0xE4,0xA6,0x54,0xDE,0x42,0x54,0x59,0xE4,0x55,0x55,0xA5,0x42,0x1D,0x8D,0x4F,0xD1,0x04,0xAB,0x7E,0x87,0xEA,0xD9,0xCC,0x66,0x36,0x8B,0x51,0xB5,0xA0,0x44,0x5B,0x93,0x57,0xBD,0x4A,0x28,0x58,0x3C,0x5D,0xCD,0x6C,0xAE,0xA0,0xF1,0x74,0x76,0xB3,0x2F,0x7D,0x2F,0x2A,0x10,0x79,0xA7,0xF5,0xAD,0x88,0x50,0xC4,0x62,0x31,0x44,0x2F,0x24,0x11,0x8B,0xD8,0x40,0x95,0x57,0xA4,0x3B,0xE1,0x83,0x1B,0x52,0x32,0x15,0xF1,0x45,0x7E,0xF0,0xE3,0x03,0x00,0x00};
//const uint8_t spNEGATIVE[] PROGMEM ={0x62,0xE0,0x5A,0x67,0xDD,0x13,0x89,0x8E,0x19,0xFD,0xD0,0x91,0x98,0xDA,0xE4,0x61,0x33,0x43,0xC9,0x68,0x4A,0xCA,0x70,0xF6,0x35,0xB7,0xBA,0xD5,0xC9,0x73,0x4E,0x57,0xCE,0x25,0x27,0x2B,0xCD,0x55,0xD5,0x96,0xC6,0xCA,0x54,0x39,0x38,0x4A,0x6B,0xE7,0x59,0xEC,0x6A,0xD4,0xC1,0x87,0x98,0xEB,0x66,0x35,0x70,0x53,0x1A,0x9E,0x89,0x48,0x17,0x4D,0x98,0x8B,0x3B,0x11,0x40,0xD4,0x45,0x16,0x58,0x55,0xAC,0xEE,0x2A,0xB6,0xF4,0xB4,0x29,0xA7,0x89,0xF1,0xDA,0xD5,0x86,0x94,0x26,0x2E,0x6B,0x5A,0xEF,0x92,0xB9,0x99,0xCD,0x75,0xBD,0x2E,0x6A,0x66,0x1D,0x5B,0xF5,0xC6,0xA4,0x98,0x46,0x26,0xD5,0xA7,0xD0,0xC6,0xA4,0x4E,0x7C,0x8F,0x00,0xED,0x43,0x30,0xF0};
//const uint8_t spNEXT[] PROGMEM ={0xAE,0xF6,0x16,0x3E,0x33,0x25,0x85,0xDA,0x5B,0x78,0x8F,0x34,0x5D,0xEA,0xE0,0x60,0x2C,0x5B,0xF6,0xA9,0x73,0xD6,0x50,0xED,0x3A,0xA7,0xCE,0x55,0x53,0x6C,0xEA,0x9E,0x3A,0x77,0x4D,0x8E,0x49,0x72,0x9A,0xDC,0x35,0xC4,0x37,0xC9,0x6C,0x52,0x53,0x2E,0xA9,0xF2,0x44,0x04,0x30,0xC0,0x91,0x51,0x06,0x78,0x29,0x42,0x03,0x12,0x90,0x00,0x08,0x60,0x04,0x55,0x02,0x9C,0xE0,0x82,0x81,0x07,0x00,0x00};
//const uint8_t spNICE_TRY[] PROGMEM ={0x66,0x54,0x86,0x66,0x3D,0x24,0x9B,0x41,0x1A,0xBA,0x53,0x93,0x1D,0x06,0xEF,0xE0,0x2B,0x9C,0xCA,0xE9,0xB2,0x4E,0xB7,0xD4,0xB4,0xA7,0xCD,0x36,0xCB,0x5D,0x93,0x9F,0x26,0xFA,0xA8,0x50,0x4F,0x76,0x2A,0x1F,0x33,0x42,0x23,0xD9,0x29,0x7C,0x4E,0xAE,0x88,0x2A,0x2B,0xF7,0xD1,0xAD,0x7C,0xCC,0xAC,0x3C,0x7A,0xD3,0xF4,0x33,0xBD,0xF2,0x42,0x5D,0xB3,0xC2,0x42,0x02,0xAE,0x60,0x0E,0xC0,0x9F,0x46,0x01,0x78,0x37,0x09,0x08,0x10,0x25,0x47,0x02,0x46,0x2D,0x2D,0x40,0x2B,0xE5,0x0E,0xC8,0x25,0xBD,0x44,0x7C,0x46,0x84,0xB9,0x9D,0x91,0xAA,0x11,0x5A,0x03,0x6D,0x5B,0xA2,0x7A,0x59,0x34,0x2E,0x69,0xB1,0x29,0xE9,0x95,0x70,0xAB,0xC5,0xD6,0x6D,0x68,0x53,0xA3,0x9E,0x8C,0xCA,0xE6,0xA8,0x74,0x6D,0x52,0x3A,0x5B,0xC2,0xDD,0xBC,0x74,0xE9,0x6D,0x4A,0xED,0xB2,0x18,0x69,0x70,0xCE,0x33,0x27,0x0C,0xA5,0x21,0x28,0x8F,0x69,0x0F,0xE9,0x86,0x14,0x55,0xCC,0x3A,0x14,0x03,0xB4,0x95,0x7A};
//const uint8_t spNINE[] PROGMEM ={0x80,0x52,0xAA,0x32,0x2B,0xDA,0xB6,0xA9,0xAC,0x95,0x69,0xCD,0x48,0xAE,0xB1,0x5E,0xC7,0xAD,0x4D,0xAE,0x3A,0xBA,0x0C,0x51,0xAA,0x72,0xAA,0xE0,0x3B,0x25,0xB0,0xCD,0xA9,0x6C,0x9C,0x34,0xCD,0x2A,0x2B,0x77,0x61,0xD2,0x2C,0xEB,0x8C,0xDC,0xFB,0x49,0xD2,0x29,0x32,0x0A,0x17,0xC7,0xCD,0x22,0xEA,0xA9,0x62,0xA8,0x70,0xC9,0x7A,0xA7,0x4D,0x39,0x33,0x58,0x9B,0x8E,0x2E,0x76,0x0D,0xD5,0xA8,0xD3,0xFA,0xD0,0x43,0xB4,0x35,0x76,0x19,0x52,0x96,0xD0,0xCC,0xC8,0x65,0x88,0x43,0x45,0x23,0xAA,0xBA,0x31,0x0C,0x23,0xCD,0x18,0xC3,0x46,0x19,0x25,0x52,0xB3,0xA6,0x1A,0xB4,0xE3,0x48,0xA9,0x88,0x66,0x14,0x56,0x3D,0x22,0x1B,0x86,0xD1,0x29,0x37,0xCA,0x8C,0x0B,0x00,0xF0};
//const uint8_t spNINETY[] PROGMEM ={0xA1,0x73,0x1A,0x3A,0xCA,0x6A,0xE5,0x36,0xB7,0xAB,0x0E,0xB9,0xCA,0xB4,0xEC,0xDC,0xEA,0x56,0xA7,0xCA,0xBD,0x4A,0x24,0x9C,0x9C,0xA2,0x0E,0x4F,0x34,0x4F,0xBC,0x8B,0x55,0xB4,0xC2,0x2C,0xD9,0x96,0x57,0x95,0x1C,0x6A,0x66,0x05,0xF1,0x95,0x6E,0x0D,0x50,0x94,0x4A,0x04,0x4A,0xD1,0xAB,0xA2,0xB1,0xB6,0x9D,0x4D,0xE9,0x3D,0xE7,0xEC,0x0D,0xDB,0xB9,0xF7,0x83,0x1B,0xAB,0x06,0xB7,0x2D,0x27,0x66,0x1A,0x59,0x18,0xDD,0x95,0x99,0x79,0x74,0x13,0x72,0xA3,0x03,0x08,0x90,0x56,0xE3,0x01};
//const uint8_t spNO[] PROGMEM ={0xA1,0xF2,0x0E,0x3E,0xD3,0xA9,0x94,0x3A,0x78,0xB8,0xA8,0xA0,0x93,0x6A,0xEF,0xE0,0xA3,0x9C,0xF1,0xAA,0xA2,0xE7,0x32,0xF3,0x24,0xA7,0xB0,0xDE,0xDB,0xDC,0xDB,0xDC,0xFC,0xE6,0x37,0x5F,0x95,0xF2,0xB9,0x61,0xD4,0x65,0x57,0xBB,0x6E,0x2D,0x8F,0xB3,0x6A,0xD4,0xA5,0x76,0xB5,0x0F,0x3D,0xDD,0x1B,0xAA,0x92,0xC8,0xF7,0x0F,0x00,0x00};
//const uint8_t spNOT[] PROGMEM ={0xAE,0xB1,0x1A,0x3E,0xC3,0x15,0x95,0x26,0x58,0x18,0xF3,0x70,0xDD,0x6A,0x57,0x3B,0x4D,0x4B,0xCE,0xAD,0x6E,0x75,0xAB,0x5B,0xDD,0x7A,0x34,0x76,0xA4,0xBA,0x07,0x93,0xDC,0x01,0x00,0x30,0xC0,0x90,0x70,0x07,0x0C,0x11,0x41,0x00,0x57,0x14,0x1F};
//const uint8_t spNOW[] PROGMEM ={0xA9,0x4D,0x9A,0xCD,0x9C,0xDB,0xD6,0xF6,0xD4,0xC9,0x77,0xAA,0x79,0x95,0x5B,0xDF,0xFA,0xD6,0xB7,0xB9,0xED,0xE8,0x9D,0xDF,0x66,0xF3,0xDA,0x7D,0x48,0x83,0x9C,0x15,0xE2,0x96,0x38,0x0E,0x69,0x50,0x65,0x83,0xDC,0x93,0xB8,0x51,0x86,0x1D,0x0C,0x73,0xEC,0x46,0xE9,0x7A,0xCD,0x58,0x96,0x19,0xB5,0xC9,0x54,0x61,0x37,0x6A,0xF0,0x3E,0xD2,0x85,0x64,0x3D,0x00,0x00};
//const uint8_t spNUMBER[] PROGMEM ={0xA9,0x0D,0x0E,0x2A,0xDD,0x12,0xA7,0xD6,0x5B,0xE8,0x70,0x8F,0xBB,0x9A,0xAC,0x2D,0xCD,0xA4,0xF5,0xA9,0xA2,0xAA,0x4A,0xE5,0xC5,0xB7,0x38,0x99,0x57,0xD3,0xA6,0xD2,0xAA,0x64,0xCA,0x57,0xB8,0x50,0xE6,0x98,0xB9,0x9C,0xA6,0xE4,0x70,0x4B,0xEB,0x2B,0x53,0xE3,0x98,0xEA,0x61,0x6E,0x5D,0x67,0x3A,0x7B,0x3A,0xB7,0xEB,0x5D,0xEF,0x7A,0x5F,0xFB,0x34,0xD8,0x4D,0x9A,0x29,0xAD,0xFD,0xE8,0x26,0xD3,0x44,0x32,0xD5,0xAB,0x9B,0x5C,0x37,0xB2,0xE6,0xAC,0x66,0x8A,0x2B,0xC4,0x44,0xED,0x3E};
//const uint8_t spO[] PROGMEM ={0xA7,0x72,0x3A,0xDF,0x95,0xF3,0xDE,0x6A,0x57,0xA3,0xB2,0x3C,0x3F,0x14,0xFD,0xCF,0xAA,0xD7,0xBD,0x49,0x9D,0xD2,0xF3,0x24,0xD4,0x2D,0xF6,0xBE,0x57,0x3D,0x8B,0x37,0xA2,0xD8,0xD8,0x0C,0xDC,0xD7,0x96,0x60,0x68,0x35,0x08,0x97,0xDB,0x28,0x92,0x45,0x2F,0x8D,0x57,0x71,0xC8,0x56,0x5D,0x4E,0xCC,0x2A,0xEE,0xE4,0x01};
//const uint8_t spOF[] PROGMEM ={0xA7,0x8A,0x36,0x3E,0xC9,0xB3,0x9E,0x2A,0xDA,0xF8,0x60,0xCF,0x72,0xAA,0xE8,0xE2,0x93,0x2D,0xCB,0xA9,0xA3,0x8F,0x37,0xD1,0x2E,0xA7,0x8E,0x2E,0xDE,0x44,0xDA,0x9C,0x26,0xDA,0x78,0x53,0x69,0xD3,0x1A,0xEF,0x6B,0xD9,0x6C,0x4D,0x6F,0x46,0xE3,0x7C,0x0D,0x99,0xAE,0x49,0x8D,0xF3,0xD9,0xAC,0xBC,0x58,0xB5,0x2A,0x87,0x8A,0x78,0x2A,0xD3,0x06,0x63,0x2A,0x62,0x4A,0x4C,0x3B,0x6D,0xB8,0xA1,0xC9,0x62,0x40,0x66,0xE6,0x04,0xF0,0x22,0x04,0x01,0xDA,0x85,0xC2,0x03};
//const uint8_t spOFF[] PROGMEM ={0x2B,0xD5,0xF5,0xC2,0xD4,0xEB,0x9E,0xCA,0x99,0x6B,0x53,0x5D,0x7A,0x2A,0x53,0x66,0x94,0x33,0xCD,0xAD,0x6E,0x75,0xAB,0xDB,0xB4,0x4E,0xFB,0x1C,0x65,0x4B,0x68,0x80,0x6A,0x33,0x3C,0x60,0x01,0x0F,0x38,0x20,0xDB,0x0C,0x03,0xE4,0x98,0xF6};
//const uint8_t spOH[] PROGMEM ={0xA7,0x72,0x3A,0xDF,0x95,0xF3,0xDE,0x6A,0x57,0xA3,0xB2,0x3C,0x3F,0x14,0xFD,0xCF,0xAA,0xD7,0xBD,0x49,0x9D,0xD2,0xF3,0x24,0xD4,0x2D,0xF6,0xBE,0x57,0x3D,0x8B,0x37,0xA2,0xD8,0xD8,0x0C,0xDC,0xD7,0x96,0x60,0x68,0x35,0x08,0x97,0xDB,0x28,0x92,0x45,0x2F,0x8D,0x57,0x71,0xC8,0x56,0x5D,0x4E,0xCC,0x2A,0xEE,0xE4,0x01};
//const uint8_t spON[] PROGMEM ={0xA7,0x36,0x7E,0xC6,0xD9,0x97,0x9E,0xC2,0xA4,0x2D,0xA5,0x4E,0x7A,0xAB,0x5B,0xED,0x6A,0x57,0xBB,0x9E,0xCD,0x68,0x75,0x4F,0x37,0x2F,0xBB,0xBD,0x2B,0x9D,0x6E,0x91,0xE6,0xE5,0xD8,0xF4,0xD2,0x49,0xB1,0x8D,0x1B,0xDB,0x99,0x4E,0x3A,0x69,0xB1,0x71,0xAC,0x3A,0x1E,0xB4,0x42,0xC7,0x76,0xE8,0x02,0x77,0x35,0xD7,0xC6,0xAE,0x0B,0x29,0x0C,0x31,0x5D,0x22,0x40,0x57,0xE2,0x07,0x00,0x00};
//const uint8_t spONE[] PROGMEM ={0xA6,0xA5,0x36,0xDF,0x89,0xEC,0xA5,0x86,0xDB,0xF9,0x42,0x56,0x9A,0x2A,0xE1,0xFB,0x0B,0x38,0x7D,0x6F,0x46,0x63,0x7C,0x9D,0x62,0x25,0x9E,0xCD,0x28,0x5C,0xAC,0x32,0xEA,0x38,0xBB,0x1A,0x4D,0x88,0x56,0x2A,0x53,0x67,0x76,0x79,0x70,0x83,0xF3,0x94,0x6C,0xE9,0xD6,0x0C,0xCE,0x61,0x8A,0xB4,0x3B,0x36,0xCA,0x20,0x1A,0xDC,0xAD,0xCD,0x28,0x8D,0x78,0x7B,0x5B,0x26,0x93,0x10,0x6A,0x95,0x9E,0xDA,0x4C,0x25,0x85,0x9A,0x5A,0x9A,0x07};
//const uint8_t spONLY[] PROGMEM ={0x2B,0xD5,0x6E,0x2E,0xC0,0xD3,0x8E,0x42,0xA6,0x79,0xE2,0x49,0x33,0x0A,0x65,0xE7,0x49,0x35,0x59,0xCF,0x6B,0x9E,0xF3,0x52,0x44,0x07,0x19,0x2E,0xF1,0x62,0x95,0xAB,0x56,0x67,0x65,0x61,0x45,0x6E,0x76,0xB3,0xDA,0x68,0xA3,0xD4,0xB9,0xED,0x6E,0x47,0x17,0x52,0x98,0x94,0xDF,0x29,0x7D,0x6C,0x14,0x9A,0x3D,0x35,0xF5,0x31,0x42,0x46,0xA7,0x99,0xD8,0xBB,0xDE,0x59,0x8E,0x4E,0x33,0x63,0x7A,0x67,0x29,0xBA,0xCC,0xC8,0x03};
//const uint8_t spOR[] PROGMEM ={0xAD,0x12,0xB9,0x1F,0x2C,0x66,0xB7,0x8A,0xCF,0x59,0xF0,0x6E,0x3C,0x2A,0x91,0xFB,0x51,0xA3,0xD5,0xA8,0x64,0xAF,0x25,0xF5,0x2E,0xAB,0x56,0x23,0xCB,0x54,0xB3,0x9D,0x46,0x4F,0xCF,0x14,0x69,0xBB,0x3A,0x73,0xA4,0x52,0x34,0xF3,0xE8,0xCC,0x91,0x6C,0xD1,0x2C,0xAD,0xB3,0x9B,0x2A,0x9D,0x5B,0xB4,0xD6,0x4D,0x17,0x1D,0xF4,0x59,0x5A,0x37,0x44,0x3D,0xD5,0x53,0x6A,0x7C,0x70,0xE1,0x70,0x35,0xA1,0xCD,0xA9,0x1A,0x49,0xA5,0x22,0x40,0x19,0xB5,0x07,0x00,0x00};
//const uint8_t spORDER[] PROGMEM ={0x29,0x15,0xF1,0x5B,0x98,0x56,0xD7,0x6C,0xE4,0xB2,0x8E,0xBB,0xD0,0x96,0x51,0xC8,0xA1,0x9D,0xAC,0x4D,0x4B,0xA5,0x16,0xAE,0x99,0x75,0x0A,0x8D,0x6C,0xCC,0x1E,0x91,0x76,0x54,0x2E,0xBB,0xB8,0xBB,0xF3,0x51,0xBB,0x89,0x65,0x66,0x6B,0x5A,0xED,0x06,0x9C,0x7A,0xB5,0x2A,0xAD,0x5B,0x70,0x6A,0xD5,0xB2,0x74,0x6E,0x41,0x94,0x4B,0xEF,0xD6,0xD9,0xA6,0x62,0xA7,0xEE,0x43,0x6F,0x07,0x6C,0xA9,0x27,0x74,0x03,0x2F,0xEE,0xA5,0x21,0xE7,0x01,0x00,0x00};
//const uint8_t spOTHER[] PROGMEM ={0x2B,0x8B,0xDE,0x37,0x38,0xB2,0xDC,0xEA,0x16,0x37,0x3F,0x79,0x34,0xB6,0x2A,0xDC,0xAA,0xD7,0xA9,0x75,0xDE,0x86,0x2D,0x1B,0xCD,0xFA,0xB4,0xC1,0xEB,0x88,0x66,0xAB,0xD6,0x99,0x22,0xA9,0x6D,0x4D,0x4A,0xAF,0x1B,0x75,0x85,0xB6,0xCD,0x43,0x18,0xEC,0x84,0x4E,0x8B,0x36,0xAE,0xF7,0x1B,0x4B,0xD5,0x33,0x84,0xCE,0x17,0x51,0x77,0x4D,0x6C,0xFA,0xD0,0xDC,0x00,0x45,0xE9,0x03,0x00,0x00};
//const uint8_t spOUT[] PROGMEM ={0xA7,0xCA,0xAE,0xDB,0x4C,0x96,0x9C,0xCA,0xFB,0x69,0xD3,0xA8,0x7B,0xAB,0x5B,0xAD,0xDA,0x84,0x1D,0x91,0xA8,0xDB,0x6A,0x6B,0xE6,0x59,0x6D,0x8E,0x6B,0x45,0x6F,0x97,0x0E,0xCB,0x00,0x00,0x0A,0xC8,0xDA,0x43,0x00,0x47,0xBB,0x31,0xC0,0x9B,0x30,0x04,0x18,0x17,0x02,0x0F,0x00,0x00};
//const uint8_t spOVER[] PROGMEM ={0xA7,0xD0,0xAE,0x2F,0x50,0xBA,0x9D,0x5C,0xDB,0xFA,0x24,0xCE,0x3A,0x72,0x19,0xFA,0x15,0x25,0x73,0xCB,0x45,0xAE,0x67,0xB4,0x2E,0xAD,0x10,0xB1,0x4E,0xC1,0x3D,0xB7,0x3A,0x1A,0x57,0x95,0x70,0xD4,0x9A,0x6C,0x4C,0x85,0xCD,0x4D,0xAF,0x5A,0xA5,0x7D,0x9A,0x9B,0xBB,0x1B,0x8D,0x69,0x66,0xE9,0xDC,0xAD,0xB5,0xA6,0x84,0xD8,0xA8,0xB6,0xD4,0xE9,0x2E,0x56,0x23,0x7E,0x42,0xAF,0xBB,0xC8,0x94,0x78,0x76,0xBD,0x99,0x2C,0x59,0xEC,0xCB,0xF5,0xB2,0x98,0x64,0xA6,0xE4,0x07,0x00,0x00};
//const uint8_t spP[] PROGMEM ={0x60,0x00,0xEB,0x4C,0x05,0xE0,0xAC,0xE0,0x49,0x72,0x14,0xD1,0xCC,0xB9,0x27,0x9D,0x45,0x99,0x3C,0x9F,0xEE,0x6C,0x17,0xB3,0x6E,0x4D,0x8F,0xCC,0x5C,0x75,0x27,0x75,0xC5,0xA0,0xFA,0x64,0x15,0xD7,0x3B,0x41,0xDD,0x19,0x76,0x4C,0x1F,0x15,0x44,0x77,0x88,0x31,0x83,0x57,0x64,0x1D,0x66,0xFB,0x01};
//const uint8_t spPART[] PROGMEM ={0x20,0x01,0x09,0x48,0xA0,0x25,0xBA,0x56,0x3B,0x79,0xDC,0x93,0x9B,0xD2,0x19,0x22,0x4B,0x4F,0x61,0x7B,0x45,0x1A,0x37,0x3D,0x95,0x9B,0xE1,0xE5,0xD4,0x78,0x34,0xEE,0x68,0x94,0xC8,0xEC,0xD6,0xF9,0x43,0x6B,0xD2,0x91,0x4B,0xEF,0x17,0x76,0x4A,0x26,0x48,0xBD,0x6F,0xAC,0xAE,0xAD,0x12,0x00,0x1C,0x50,0xB5,0xBB,0x00,0xA2,0x75,0x85,0x07};
//const uint8_t spPARTNER[] PROGMEM ={0x0A,0x10,0x39,0x92,0x03,0x16,0x68,0xB1,0x49,0xEB,0x51,0xD8,0x65,0xA4,0x2E,0xAE,0xDB,0x60,0xB6,0x95,0xB9,0xD2,0x6A,0x4B,0xFE,0x56,0x16,0x72,0x1B,0x9D,0x78,0x6F,0xB9,0x5F,0xA2,0x61,0xE6,0x07,0x00,0xC0,0x14,0xD6,0x61,0x07,0x9F,0xC2,0xD2,0x85,0x19,0xA2,0x89,0xC9,0x67,0x3F,0x87,0x32,0xBA,0x61,0x6A,0x4D,0x6D,0xC3,0xE8,0x0F,0x45,0x38,0x2F,0x4C,0x53,0x98,0xA4,0x19,0xEA,0xC9,0xCD,0xE1,0x30,0xBB,0x59,0xE2,0x07};
//const uint8_t spPARTS[] PROGMEM ={0x0A,0x70,0xC6,0x8D,0x02,0x1C,0x68,0x89,0x2E,0xDD,0x41,0x5A,0x7B,0x65,0x26,0x4D,0x86,0xF1,0x9A,0x91,0x9B,0xBA,0xEE,0x49,0x6B,0x5A,0x61,0x5B,0x6B,0x0C,0x6C,0x99,0x75,0x69,0xEC,0x08,0xF6,0x67,0xEF,0xAE,0x75,0x8B,0xB4,0x53,0x32,0xB1,0x4E,0x46,0x65,0x8B,0x92,0x83,0xFC,0xA0,0x83,0x5D,0xC3,0x31,0x30,0xE0,0x65,0x75,0x0D,0x58,0xC0,0x00,0xBF,0x86,0x5B,0x40,0x00,0xBF,0x9A,0x33,0xE0,0x28,0xF5,0x07,0x00,0x00};
//const uint8_t spPERIOD[] PROGMEM ={0x06,0x08,0xDE,0x44,0x03,0x23,0xCE,0xCE,0x94,0x23,0x5B,0x8F,0x34,0x84,0x10,0x59,0xCF,0xBA,0xD3,0x91,0xBA,0x14,0xA2,0xCB,0xFE,0x67,0xDE,0x0A,0x57,0x5C,0xB4,0xD9,0xDF,0xA8,0x42,0x77,0xD1,0x10,0xFF,0xA3,0x8A,0x39,0x94,0x3C,0xBA,0x8E,0xA6,0xC4,0x10,0x36,0xFB,0x3C,0xDB,0xD5,0xE6,0x9C,0xCA,0xA6,0x6F,0x76,0x37,0xFB,0xD6,0x07,0xEF,0xA6,0xE1,0x9B,0xCD,0x60,0x9C,0xA9,0x86,0xB5,0x62,0x3D,0xB6,0x1D,0x11,0xA1,0x98,0xF5,0x44,0x57,0xA4,0xA5,0x62,0xD3,0x67,0x61,0xA2,0x66,0x4E,0x09,0x60,0x64,0xD9,0x03,0x00,0x00};
//const uint8_t spPLAY[] PROGMEM ={0x06,0xC8,0x55,0x54,0x01,0x49,0x69,0x94,0xC4,0xA4,0x1C,0xE3,0x8A,0xD3,0x93,0x19,0xAF,0x24,0xE4,0x68,0xE1,0x4D,0xBC,0x92,0x58,0x22,0x95,0x27,0xF1,0x4A,0x53,0xF5,0x10,0x99,0x26,0xB3,0x68,0x75,0x29,0x12,0xE2,0x53,0xBB,0x74,0x31,0x52,0x64,0x4F,0xD8,0xDA,0xA7,0x3E,0x3A,0xF6,0xAC,0x2C,0x13,0xFA,0xA0,0x39,0xBA,0x33,0x88,0xEB,0x8D,0x92,0xB9,0x70,0xA1,0x0F,0x00,0x00};
//const uint8_t spPLAYS[] PROGMEM ={0x0A,0x68,0x51,0x4D,0x00,0x49,0x7A,0x97,0x48,0xD9,0x69,0x15,0xF7,0xB4,0x92,0x10,0xA2,0x9C,0xAB,0xF1,0x4E,0x56,0x12,0x4A,0xA4,0xF0,0xD4,0xD9,0xC9,0x48,0x53,0x51,0x53,0x9D,0xBA,0xA3,0xC8,0x45,0x4C,0xAD,0x9B,0x8C,0xBA,0x96,0x20,0x36,0x7F,0x3A,0xDB,0xDA,0xA5,0x3E,0x25,0x74,0xCB,0xA9,0x5D,0xFB,0xDA,0xA7,0x3E,0x24,0x76,0xF5,0x99,0x9B,0x7A,0x97,0xC5,0x24,0xAA,0x4E,0xE9,0x93,0x0A,0x31,0x8D,0x4E,0x69,0xFC,0x29,0x4D,0x48,0x94,0x1A,0x60,0x09,0x33,0x06,0x5C,0xA6,0xE2,0x80,0x6B,0x4C,0x04,0xD0,0x84,0xE9,0x03,0x00,0x00};
//const uint8_t spPLEASE[] PROGMEM ={0x0E,0xC8,0x81,0xD4,0x01,0x59,0x9B,0x8F,0xB0,0x48,0x69,0x57,0x73,0x3B,0xD2,0x24,0x2D,0x3D,0x24,0xCD,0x4A,0xBD,0x33,0x8F,0xF0,0xC7,0x3B,0x6B,0x79,0x4D,0x86,0x9C,0xFE,0x64,0x56,0xA3,0xAA,0x59,0x89,0x3D,0xBE,0xCC,0xA6,0xB7,0xA5,0xCF,0x9D,0x85,0xA5,0xDE,0xE6,0x3E,0xF5,0x29,0xB1,0x98,0xC5,0xE3,0xD2,0x07,0x13,0x10,0x56,0x1D,0xCB,0xF0,0x35,0x87,0x51,0xAE,0x75,0xC0,0x04,0xAC,0x06,0xF8,0x46,0xCD,0x00,0x3F,0x1A,0x19,0xE0,0x7B,0x0B,0x01,0x7C,0xA7,0xF6};
//const uint8_t spPOINT[] PROGMEM ={0x0A,0xB0,0x5A,0x8B,0x00,0x5A,0x47,0x23,0x40,0x99,0x29,0x91,0x7A,0xE9,0xD3,0x12,0x8C,0x4A,0x22,0x7D,0xBF,0x82,0xB6,0x19,0xA9,0xD1,0xFD,0x86,0x92,0x66,0xE5,0x41,0xD6,0xAB,0x58,0xB6,0x53,0x25,0xDD,0x2B,0xC6,0x59,0x4E,0x93,0x7D,0x87,0x1A,0xB5,0x3E,0x7D,0xCE,0x65,0xAA,0xBC,0xBA,0x0D,0x29,0x99,0x5A,0xC4,0xCC,0x32,0xE6,0x10,0x2C,0x6A,0x4D,0xDC,0x94,0x99,0x98,0x84,0x39,0x43,0x80,0x45,0x1C,0x08,0xC8,0x98,0x3A,0x00,0x49,0xA6,0x79,0x40,0x00,0x22,0x84,0x3D,0x00,0x00};
//const uint8_t spPOSITION[] PROGMEM ={0x06,0x70,0x2E,0x58,0x03,0xAE,0x8A,0xA1,0x42,0x49,0x3C,0xAD,0xC2,0xC5,0x48,0xD6,0x58,0x72,0xAA,0x60,0x23,0x55,0x65,0xCD,0xAE,0x77,0xE3,0x80,0x0A,0x28,0x23,0x30,0xAA,0x68,0xD3,0x58,0x6D,0xF6,0x2E,0x6E,0xBA,0x92,0x98,0xDD,0x99,0x7B,0x76,0x4F,0x14,0x70,0x66,0xA6,0x07,0x3C,0x20,0x00,0xEE,0x3D,0x56,0x51,0x5D,0x35,0x2B,0xA5,0xBB,0xCD,0xED,0xDA,0x90,0x12,0xA5,0xA0,0xA6,0xCF,0x63,0x1A,0x83,0xA7,0x30,0x36,0xEF,0x61,0x54,0x5E,0xCD,0xB8,0x9A,0xBA,0xD1,0x18,0xF1,0xE0,0x4A,0x6E,0x26,0x63,0xD9,0x5C,0x32,0x8D,0x9A,0x9C,0x15,0x53,0x6E,0xD7,0x0F};
//const uint8_t spPOSITIVE[] PROGMEM ={0x02,0x90,0xC6,0x9D,0x03,0x08,0x10,0x26,0x73,0xC4,0xBA,0x77,0x9A,0x66,0x94,0x95,0xD9,0x3C,0xA3,0x92,0xB5,0x77,0xB6,0xB3,0x95,0x7B,0x57,0xE5,0xEA,0x71,0x5A,0x6E,0x63,0xA9,0xBB,0x57,0x49,0xD5,0x17,0xAC,0x61,0xE9,0x38,0x74,0xBF,0x85,0x1A,0x88,0xDC,0xD0,0x59,0x1F,0xEE,0xEE,0x2D,0x6B,0x95,0x6A,0x6F,0xC2,0xD4,0xAD,0xA7,0xE8,0x94,0x4C,0x76,0x8B,0x56,0xA4,0xF3,0xD2,0x35,0xD4,0x15,0x33,0x20,0x01,0x0D,0x57,0x9B,0xCC,0x15,0x39,0x91,0x63,0x13,0x7B,0x33,0x48,0x97,0x19,0x23,0x35,0xC4,0x20,0x7C,0x44,0xBA,0xC5,0x14,0xA3,0xD6,0xEE,0x1E,0xEE,0x58,0x8C,0xC1,0xB8,0x9A,0xA8,0x6A,0x40,0x80,0xD7,0xCE,0xAA,0x6B,0xA9,0x2D,0x48,0xD5,0x3C,0x00,0x00};
//const uint8_t spPRESS[] PROGMEM ={0x04,0xC0,0x36,0x4C,0x01,0x2E,0xA9,0x2B,0xC0,0x36,0xAF,0x16,0xB9,0x22,0xE5,0x96,0xC9,0x6E,0x7A,0x32,0xDF,0x2D,0x2C,0x32,0xCE,0xCE,0x77,0x35,0xDB,0xD4,0x9B,0xE4,0xE5,0xBA,0xB6,0xEC,0xA8,0x80,0xEF,0x45,0x34,0x60,0x01,0x03,0xFC,0x28,0x6A,0x80,0x1F,0x4D,0x15,0xF0,0x15,0x99,0x04,0x38,0x00,0x0F,0x00,0x00};
//const uint8_t spPRINT[] PROGMEM ={0x0A,0x30,0xC5,0x43,0x02,0x18,0x68,0x91,0x5F,0x52,0x52,0xD0,0x76,0x45,0xB1,0xB8,0x6A,0xC4,0xAC,0x1D,0xED,0x78,0xE7,0xAB,0x4E,0x29,0x55,0xDD,0x56,0xB5,0x2E,0x34,0x4B,0x91,0x6C,0x14,0x86,0x2C,0x44,0xB5,0xCC,0x9D,0x1A,0x93,0x76,0x73,0x77,0xC5,0x00,0x0A,0x28,0xDA,0x42,0x00,0x76,0x44,0x10,0x40,0x86,0xB0,0x07};
//const uint8_t spPRINTER[] PROGMEM ={0x0A,0x30,0xC5,0x43,0x03,0x1A,0x28,0xB1,0x5F,0x52,0x52,0xD0,0xF6,0xC4,0xB1,0xB8,0x6A,0xC4,0xAC,0x1B,0xDF,0x24,0xE6,0xA5,0x2A,0x8E,0xD5,0xCC,0x9D,0x18,0x40,0x24,0xAB,0x93,0xC7,0x64,0xCE,0x65,0x4D,0x6F,0xBD,0xDA,0x30,0x4D,0xA5,0xA4,0x7D,0xEB,0x5D,0x33,0xD1,0xD3,0xF6,0x69,0x70,0x83,0x34,0x5B,0xD6,0xB8,0xD1,0x54,0x51,0x1B,0x97,0xE5,0xA6,0x50,0x8D,0xC9,0xD5,0x8B,0x99,0xC2,0x51,0x51,0x91,0xCC,0xF0};
//const uint8_t spPROBLEM[] PROGMEM ={0x0C,0xC0,0x36,0x4C,0x01,0x2E,0xA9,0x0B,0xC0,0x36,0x2F,0x02,0xB8,0x0E,0xB1,0x62,0x1B,0x3B,0x22,0x28,0xDD,0x4D,0x4E,0xEA,0xFD,0x54,0x70,0xB8,0xB9,0xE9,0xCD,0x56,0x66,0x63,0x55,0xB0,0x35,0x31,0x15,0xF7,0xD6,0x2A,0xEA,0x59,0xD4,0x38,0x66,0x19,0xB7,0x1D,0xD7,0x08,0xE3,0xE1,0x1E,0x4A,0x5B,0xE5,0x9D,0x8C,0xB3,0xD9,0x1F,0x75,0x34,0x39,0x29,0x94,0xFE,0x36,0xB7,0xDD,0xDD,0xE8,0x7C,0xA8,0x0A,0x81,0xA6,0x61,0x88,0x0E,0x5B,0x54,0xD5,0xC6,0x3E,0xF6,0x7E,0x70,0x83,0x77,0x34,0x22,0xAA,0xC5,0x0C,0xDA,0x6A,0x09,0xA7,0x9A,0x07};
//const uint8_t spPROBLEMS[] PROGMEM ={0x0C,0xB0,0xCD,0x8B,0x00,0xAE,0x43,0x9C,0xD8,0xC6,0x8E,0x08,0x4A,0x77,0x52,0xEF,0xA6,0xDD,0xA4,0xED,0xC9,0xBC,0x9F,0x76,0x95,0x25,0x27,0xF3,0xA1,0x26,0xD8,0x96,0x9E,0xCC,0xC6,0xEE,0x20,0x5F,0xB2,0x72,0xE3,0xA6,0x92,0xB5,0xAD,0xAA,0x70,0x2A,0x0F,0x76,0xD7,0xA2,0x46,0xB1,0x3D,0x38,0x9C,0x94,0xCA,0x59,0x8D,0x88,0x92,0x5A,0x9A,0xA8,0xB8,0x5A,0xD8,0xDD,0x6A,0x83,0xF6,0x4E,0x15,0xA5,0xAB,0x75,0xB6,0xC6,0x45,0xB2,0x8C,0xDE,0x84,0x2E,0x55,0xCD,0x9A,0x7A,0x67,0xB3,0x4C,0xA1,0xAD,0x1B,0x82,0x83,0x31,0x53,0xAD,0x6E,0x08,0x0E,0xC6,0x35,0xB8,0xBA,0xC1,0x5B,0xE8,0x96,0x60,0x16,0x86,0x22,0x38,0x5D,0x4D,0x2D,0x01,0x3C,0x90,0x12,0xC0,0x57,0xC0,0x0A,0xF8,0x9E,0x59,0x00,0x97,0x83,0x09,0x60,0x11,0x71,0x01,0x24,0x6A,0xF9};
//const uint8_t spPROGRAM[] PROGMEM ={0x0A,0x30,0x3E,0x55,0x00,0xAE,0x43,0xB8,0x3C,0xB5,0x54,0x77,0x95,0x7B,0x52,0x67,0x62,0x3C,0xA8,0xCD,0x4D,0x4F,0xEA,0x94,0x9F,0x3B,0xA7,0xDF,0x69,0xC9,0x8C,0xC9,0x11,0xA1,0xF4,0x26,0xE3,0xA9,0x92,0xC4,0xBC,0x8A,0x8A,0xDB,0x8C,0x10,0x73,0xE2,0x2A,0x9D,0xA4,0x83,0xCC,0x49,0xAA,0x4C,0xC5,0x55,0x8F,0x74,0xAB,0x0A,0x93,0x9A,0x43,0xDB,0x9F,0x3A,0x2C,0x4D,0x97,0x68,0x72,0x9B,0xDB,0xDE,0x76,0x77,0xA7,0x0B,0x39,0x32,0x54,0xE7,0xEE,0x7E,0xF4,0x21,0x7A,0xA4,0x72,0x9D,0x30,0x3A,0xCF,0xAD,0x18,0x69,0xDD,0x60,0x1C,0xA7,0x8A,0x66,0x55,0x83,0xF4,0x9A,0xCA,0x99,0x45,0x8D,0x5A,0x4B,0xA6,0x64,0x12,0x35,0x3A,0xAD,0xE6,0x54,0x4E,0xC4,0xE4,0xB5,0x69,0xB0,0xB9,0x05,0x52,0x45,0x1F,0xEE,0xEC,0xAE,0x1F};
//const uint8_t spPUT[] PROGMEM ={0x0A,0x30,0x3E,0x55,0x02,0x1C,0x20,0x80,0x0A,0x65,0x27,0xF2,0x3A,0xB2,0xC4,0x96,0xDD,0x74,0x65,0x26,0x94,0xB9,0xF5,0x9C,0x55,0x58,0x1F,0xEE,0xDA,0x6D,0x4A,0x65,0xBD,0x87,0x7A,0x6D,0x04,0x00,0x07,0x0C,0xE3,0x61,0x80,0x69,0xC2,0x18,0x10,0x5C,0x32,0xC0,0x03};
//const uint8_t spPUTTING[] PROGMEM ={0x06,0xB0,0xCE,0xCC,0x02,0x1A,0x30,0x91,0x8F,0x5D,0xCE,0x6C,0x67,0x25,0x3A,0x56,0x18,0x67,0xE7,0x93,0x18,0x17,0x19,0x96,0x99,0x4F,0x1A,0x5C,0x58,0x50,0x77,0x12,0x00,0x95,0xDD,0x0A,0x20,0xC1,0x7C,0x44,0x31,0x38,0xA9,0x79,0xA3,0x53,0xE7,0x1E,0xAC,0xE6,0x4B,0x56,0x53,0x5B,0x31,0xBB,0xAE,0x6E,0x5D,0x9D,0x81,0x1C,0xBE,0x30,0xF4,0x29,0x33,0xE4,0x58,0x44,0xD3,0x3B,0x23,0x78,0x49,0x51,0x44,0x2F,0x8D,0xD4,0x8A,0x2A,0x12,0xBD,0xD0,0x1E,0xA3,0x6A,0x49,0xF4,0x46,0xB2,0xB6,0xB9,0x63,0xD1,0x7B,0x23,0x92,0x6A,0x8E,0x59,0x17,0xB4,0x4A,0xAA,0x38,0x02,0x40,0x51,0x52,0xE1,0x69,0xE9,0xF8,0x01,0x00,0x00};
//const uint8_t spQ[] PROGMEM ={0x0E,0xB0,0xD1,0x38,0x02,0x06,0x80,0xBE,0xDD,0x01,0xCC,0x58,0x6B,0x60,0x45,0x25,0x2A,0x53,0xF8,0x9A,0x13,0x15,0xEF,0x0C,0xED,0x5D,0x6E,0xB4,0xE2,0xEC,0x9D,0xA9,0x74,0xCF,0x4A,0x93,0x71,0xA5,0x92,0xBD,0x33,0x1F,0x55,0xE0,0x9E,0x5C,0xDA,0xB5,0xD7,0xA9,0xE3,0xA1,0xDC,0x42,0x17,0xC5,0xCE,0x75,0x2C,0xB6,0x87,0xE9,0x02,0xD3,0x09,0xDB,0x6E,0x46,0x33,0x55,0xAB,0xAC,0xF4,0x90,0xC6,0x79,0x00,0x00};
//const uint8_t spR[] PROGMEM ={0xA7,0x70,0xB1,0xCE,0x29,0xD2,0xDD,0xFC,0xE6,0x37,0xBF,0xC5,0xA9,0x7C,0xC8,0x4E,0x95,0xE6,0xB7,0x3A,0x8D,0xAF,0x1E,0x19,0x9C,0xFC,0x76,0xAD,0xB3,0x43,0x32,0xDD,0xEA,0xE4,0xCE,0xF5,0xBE,0x2A,0x6B,0x73,0x22,0xD3,0xC5,0xE9,0x2C,0xCA,0xAE,0x1E,0x00,0x00};
//const uint8_t spRANDOMLY[] PROGMEM ={0xAA,0xA5,0x35,0xCD,0xAD,0x9C,0x84,0x56,0x0C,0xEE,0x2C,0xD3,0xBC,0x1A,0x97,0xA5,0xAD,0xAC,0xF9,0xA9,0x62,0xB4,0x48,0x8B,0x36,0xA7,0x4A,0xC5,0xD2,0x65,0x93,0x9C,0x3C,0x35,0x4B,0x93,0x71,0x72,0xF2,0xD4,0x3C,0x4D,0xDA,0xC9,0xC9,0x63,0xF1,0x30,0x69,0x27,0x2B,0x0F,0xD1,0x2D,0xB8,0x92,0xA4,0x3C,0x7A,0x18,0xF3,0xD2,0x14,0x0A,0x6B,0x68,0x5D,0x5B,0xB5,0xAB,0x8C,0xE2,0x5C,0x95,0x5A,0xA9,0x89,0x54,0xD5,0x43,0x93,0x8E,0xC2,0x1B,0x8F,0x52,0x6B,0x33,0x2A,0x6B,0xA3,0xC2,0x65,0x49,0xA9,0x8D,0xD7,0x09,0x95,0xB9,0xA1,0x31,0x0E,0xCF,0xD4,0x9C,0x87,0xC6,0x3B,0xB8,0x50,0x75,0x9E,0x5A,0xEB,0x70,0x4D,0xDC,0x5E,0xE9,0x9C,0xB6,0x8A,0xC0,0xE6,0xA5,0xB3,0x22,0x47,0x83,0xDB,0x8D,0xD6,0x05,0xAB,0x34,0x5F,0xB6,0xBA,0x10,0x35,0x22,0x62,0xC9,0xE8,0x73,0x22,0x8F,0xCE,0xC6,0xA5,0xCF,0x05,0xDD,0xA7,0x4B,0x85,0x3E,0x26,0xC8,0x9C,0x0E,0x64,0x7A,0x6F,0xB1,0x3B,0x43,0x90,0xEA,0x53,0x04,0x8B,0x2A,0xD3,0x0F,0x00,0x00};
//const uint8_t spREAD[] PROGMEM ={0xA1,0x13,0x31,0x5C,0x3C,0x95,0x95,0x4E,0x56,0x33,0x75,0x93,0xDF,0x1A,0x3D,0xC4,0xC5,0x45,0xFD,0xAA,0x5D,0x67,0xE7,0xB0,0x6C,0xA7,0x0A,0x9E,0x53,0xD3,0x97,0x9C,0xBC,0x28,0x15,0x9D,0x6A,0xB4,0xB2,0x2A,0x59,0x7D,0xAB,0xE6,0xCA,0x9B,0x11,0x96,0xE9,0x85,0xAB,0xE8,0xD9,0x18,0x22,0xDF,0xDC,0xEA,0x56,0xB7,0x59,0x4D,0xAB,0x21,0xA0,0xFA,0x35,0x74,0x4A,0xA8,0xA7,0x56,0x6C,0xDF,0x99,0x8E,0x4B,0xCB,0xB0,0x8A,0x9D,0xFA,0x6A,0x43,0x18,0x25,0x65,0xED,0x5D,0x9F,0xB2,0xA9,0x90,0xC7,0xCE,0xD3,0x03};
//const uint8_t spREAD1[] PROGMEM ={0xA6,0xE5,0x4D,0xDD,0x33,0xE4,0x87,0xC6,0x0C,0x0C,0x4B,0xD3,0x3E,0x2A,0x3F,0x39,0xC5,0x2D,0xEF,0xA9,0x52,0x77,0x17,0xED,0x36,0x37,0xBF,0xF9,0x29,0x52,0xF7,0x10,0xA9,0xD6,0xB7,0xDA,0xF5,0x6E,0x67,0xE7,0x06,0xEB,0x55,0xC5,0xBC,0x91,0x1D,0xEC,0x40,0x02,0xA2,0x32,0xD3,0xD2,0x56,0x18,0x4A,0x6C,0x13,0x51,0xC7,0x0F,0x00,0x00};
//const uint8_t spREADY_TO_START[] PROGMEM ={0xAE,0x91,0x85,0xD3,0x32,0xB8,0xB5,0xC6,0x35,0x4E,0x09,0xCA,0x7E,0x6A,0xDF,0xB9,0xCC,0xB4,0xFB,0xA9,0xE2,0xD4,0x30,0xD5,0xEE,0xB7,0x5A,0x55,0xEA,0x5A,0x10,0x99,0xA5,0x55,0x31,0x1B,0x1B,0x4E,0xA6,0x55,0xE5,0xAE,0xCA,0xD2,0x9D,0x5A,0x55,0xA6,0x08,0x49,0x2D,0x8D,0xB5,0x6C,0x11,0xB0,0x54,0x9A,0x06,0x0C,0xB0,0x8C,0x45,0x29,0xBC,0x4A,0x53,0xCB,0x4E,0xA5,0xA9,0xC2,0x4C,0xD5,0xF2,0x1A,0xA0,0x03,0x35,0x05,0xFC,0xA9,0x6C,0x01,0x05,0xFC,0x1D,0x0C,0x10,0x80,0xA6,0xD2,0x4F,0x1E,0x43,0x44,0x86,0xB4,0xBD,0xC5,0xAD,0x4E,0xE5,0x8B,0x77,0x18,0x37,0x59,0x85,0x9F,0xE6,0xA5,0xBA,0x78,0x67,0x33,0x6D,0x91,0x9F,0x22,0x1D,0xE6,0xD0,0x45,0xDA,0x49,0x46,0xB8,0x2C,0x00,0x03,0x64,0x19,0xCA,0x80,0x26,0x9B,0x11,0xE0,0x12,0x33,0x00,0xC0,0x03,0x00,0x00};
//const uint8_t spRECORDER[] PROGMEM ={0xA4,0x72,0x3A,0x44,0xC5,0xE4,0xA4,0x4A,0x57,0x4E,0x2B,0xF7,0x76,0x9A,0x34,0xAC,0x48,0xC5,0xF9,0xA9,0x4B,0x89,0x64,0xC7,0xEE,0xB7,0x5E,0x75,0xAB,0x1D,0x10,0xE2,0x9E,0xB4,0x59,0x84,0xB1,0x84,0x5B,0x40,0x80,0x67,0xE5,0x0C,0xD0,0xB3,0x09,0x54,0x2A,0xD2,0x96,0x13,0x77,0xAF,0x69,0x4D,0x4B,0x26,0x53,0x77,0x0A,0xF9,0x6F,0x99,0x8E,0x5E,0x99,0x90,0xB5,0x64,0xB6,0x71,0xA5,0x63,0x93,0x50,0xD8,0xCB,0xEE,0x22,0xEA,0x4C,0xE3,0x97,0x98,0x25,0xB7,0xCB,0x4D,0x6F,0x5A,0xE7,0xB7,0xAA,0x27,0xB7,0x2B,0xBD,0x5B,0xCA,0x51,0xDC,0x2D,0x0D,0x6E,0x2B,0x47,0x49,0x7E,0x33,0xF9,0x8B,0x9A,0xCA,0xAD,0xCC,0x6C,0x87,0x50,0x98,0xBB,0x79,0x00,0x00};
//const uint8_t spRED[] PROGMEM ={0xA6,0xE5,0x4D,0xDD,0x33,0xE4,0x87,0xC6,0x0C,0x0C,0x4B,0xD3,0x3E,0x2A,0x3F,0x39,0xC5,0x2D,0xEF,0xA9,0x52,0x77,0x17,0xED,0x36,0x37,0xBF,0xF9,0x29,0x52,0xF7,0x10,0xA9,0xD6,0xB7,0xDA,0xF5,0x6E,0x67,0xE7,0x06,0xEB,0x55,0xC5,0xBC,0x91,0x1D,0xEC,0x40,0x02,0xA2,0x32,0xD3,0xD2,0x56,0x18,0x4A,0x6C,0x13,0x51,0xC7,0x0F,0x00,0x00};
//const uint8_t spREFER[] PROGMEM ={0xA1,0xB6,0x03,0x53,0x4B,0xFC,0x9C,0x2A,0x56,0x2D,0x0E,0xCE,0x37,0x2A,0x1B,0x75,0x34,0xAA,0x71,0xA9,0xB4,0xF5,0x09,0x4B,0x07,0x02,0xF0,0x5A,0x84,0x01,0xD5,0x86,0x52,0x40,0x03,0x02,0x88,0x21,0xB5,0x44,0xB6,0xA9,0x55,0x63,0xE7,0x99,0xF6,0xB4,0x67,0x3D,0xEF,0x55,0xAF,0x5B,0xEB,0x26,0x47,0x26,0x7F,0xA9,0x7D,0x1D,0xD2,0x68,0xBB,0xA9,0x1F,0x77,0x73,0xA3,0xED,0xD4,0x19,0x96,0x2A,0x8C,0x6E,0x50,0xA6,0x59,0x23,0x33,0xB9,0x46,0x91,0x6A,0x89,0xD8,0x28,0x83,0x4A,0x68,0xA4,0x79,0x00,0x00};
//const uint8_t spREMEMBER[] PROGMEM ={0x22,0x34,0xD2,0x2D,0xC4,0x9D,0x84,0xDA,0x2E,0x48,0x73,0xF7,0xB7,0xAA,0x54,0xB4,0xC8,0xA5,0xDB,0xAD,0x4E,0x15,0xA3,0xA7,0x53,0xB6,0x29,0xB5,0x0D,0x54,0xCA,0xED,0xD6,0xD7,0xB1,0x4A,0x55,0x4C,0x91,0x81,0xD5,0xE4,0xE6,0x37,0xDB,0x69,0xC9,0xBD,0x73,0x0B,0xE1,0xBA,0x3E,0x8F,0x95,0xA8,0x59,0x50,0x2F,0xB5,0x2C,0xA6,0xB7,0x55,0xCD,0x8A,0xB3,0xD4,0xAA,0xB5,0xA1,0x9B,0xE9,0x60,0xF6,0x34,0xB8,0x85,0xE5,0xC1,0x6F,0xD3,0x68,0x3A,0x45,0x97,0x66,0x89,0x93,0x99,0x6D,0x63,0xCB,0x96,0xAC,0x66,0x31,0x45,0x6D,0xC2,0x6D,0xAB,0xC9,0x4F,0x36,0x33,0x77,0x0B,0x00,0xF0};
//const uint8_t spRETURN[] PROGMEM ={0x00,0x60,0x12,0x15,0xC9,0x27,0x9C,0xF1,0xA8,0xBC,0x93,0xD4,0xD2,0x65,0xAB,0x4A,0x51,0x43,0x25,0x7B,0xDF,0x6A,0x54,0x3E,0x98,0x99,0x76,0x2B,0xD3,0x19,0x19,0x91,0x1A,0x4E,0x00,0x12,0xD0,0x4C,0xB8,0x07,0x14,0xE0,0x9D,0x19,0x02,0x78,0xB5,0x5C,0x91,0x4F,0x2E,0x95,0xEA,0x7A,0x27,0x2B,0x0D,0xA5,0xC9,0x8B,0x3C,0xEF,0x74,0x67,0x23,0x0F,0xDB,0x38,0x55,0x32,0xCF,0x6A,0xD4,0x61,0x3A,0x87,0x8B,0xAF,0xD6,0x84,0x6B,0x66,0x4E,0x9D,0x4A,0x1B,0x0F,0xBB,0x86,0xA4,0x09,0x5D,0x58,0x90,0x66,0xE5,0xCA,0x75,0x2C,0x58,0x9B,0xB4,0x69,0xDF,0xF9,0xEE,0x01};
//const uint8_t spREWIND[] PROGMEM ={0x62,0xE4,0xC5,0xB4,0x42,0x95,0x86,0x36,0x5C,0x0E,0x68,0xCE,0xBA,0x9A,0x32,0x3C,0x49,0xA9,0xFD,0x6D,0x4E,0x53,0x46,0x1A,0x18,0x77,0x5F,0x4D,0xC9,0x2E,0x98,0x92,0xBD,0x34,0x41,0xA9,0xDB,0x89,0x7B,0xD3,0xD2,0xD8,0x69,0x22,0x49,0x6D,0x13,0x1A,0xEE,0x6B,0x4D,0xD8,0x4D,0xAB,0x9D,0x89,0x0F,0xA1,0x2C,0xBB,0x5A,0x95,0x77,0x3D,0x89,0x91,0x64,0x57,0xBB,0x5A,0x55,0x8C,0x99,0x41,0x65,0xE7,0x56,0xAB,0x4E,0x23,0x5A,0xB8,0xDC,0xEC,0x66,0xB5,0x79,0xBB,0x33,0x57,0x93,0xDD,0xCE,0xAE,0x75,0xF9,0x98,0xB3,0x54,0x13,0xD7,0x6B,0x47,0x15,0x96,0x76,0x6C,0xA7,0x3B,0xD1,0x71,0x2F,0x9D,0x96,0x96,0x59,0x4F,0x4D,0x66,0x46,0xD8,0x0C,0xC3,0xD0,0xA3,0xAA,0xE5,0x1A,0x01,0x5E,0xB6,0x60,0xE0,0x01,0x00,0x00};
//const uint8_t spRIGHT[] PROGMEM ={0xA2,0x65,0x21,0xDD,0x39,0x1C,0x8B,0x9A,0x8E,0x90,0xB0,0x74,0xAC,0x6A,0x3A,0x5C,0xA2,0x43,0x89,0x69,0xF8,0x52,0x8E,0x31,0x27,0xA9,0xD1,0x07,0xB3,0x54,0xDC,0xAF,0xDA,0xC4,0x1A,0x67,0x9D,0x77,0xEB,0x53,0x85,0x9C,0xE9,0xDC,0x71,0x6E,0x75,0xAA,0x58,0x33,0x4D,0x3A,0xEE,0xA9,0xD3,0xF0,0x64,0xCF,0xBA,0xA7,0xC9,0x45,0xC4,0xA2,0x2A,0xCD,0x2E,0xF5,0x29,0xB3,0x44,0x57,0x61,0x33,0x18,0x69,0x92,0xE9,0x16,0x00,0x40,0x01,0x5D,0x79,0x3C};
//const uint8_t spROUND[] PROGMEM ={0xAA,0xA2,0xA5,0x4D,0xBD,0x64,0x85,0x5A,0x0D,0x0E,0x2F,0x63,0x3F,0x2A,0x9B,0xB5,0xAD,0xF8,0xFA,0xA9,0x42,0xF0,0x72,0xB5,0xDC,0xA7,0x0A,0x29,0xD2,0xA9,0x1B,0x9F,0x2A,0xE6,0x28,0xA7,0x8E,0x73,0xAA,0x90,0xA3,0x9C,0x36,0xF6,0xA9,0x42,0xCA,0x08,0x6A,0xC7,0xA7,0xF6,0x31,0x2B,0xB0,0xA2,0xAC,0xDA,0xC5,0xAA,0xC0,0x8C,0x33,0x1A,0x93,0x27,0x9C,0x2A,0xCA,0x6A,0x6D,0x98,0x74,0xF4,0x2A,0xA3,0x35,0x61,0xC2,0x28,0x6A,0xB7,0x4E,0xFB,0x49,0xA3,0xA8,0xDD,0x3A,0xA3,0x27,0x94,0x23,0x76,0xEA,0xA5,0x49,0x33,0x73,0xDB,0xA9,0xD7,0x4E,0xDD,0xD5,0xE2,0xA6,0xDE,0x38,0xCE,0x30,0x8B,0x93,0x7A,0x65,0xB9,0x92,0x23,0x71,0xE8,0xB9,0xD5,0x2A,0xB6,0x84,0x6E,0xA0,0xDE,0x2B,0x25,0x62,0x94,0x51,0x73,0xF7,0x0C,0xB7,0x9D,0xC6,0xAE,0x82,0xD3,0x34,0x35,0x03,0x78,0x10,0x65,0x80,0xB6,0xA6,0xF0};
//const uint8_t spS[] PROGMEM ={0x04,0x48,0x49,0x74,0x14,0x21,0x4A,0x7A,0x6D,0xAC,0x53,0xA5,0xA2,0x29,0xB1,0x4D,0x4E,0x15,0xB3,0x34,0x6D,0x27,0x3A,0x55,0xC8,0xDA,0x12,0xEB,0xFA,0x56,0xA7,0x8E,0x29,0xC2,0xF1,0xDD,0x84,0xD6,0x3B,0x6D,0x91,0x97,0x25,0x80,0xA3,0xC3,0x2C,0x60,0x80,0x2B,0x53,0x34,0x60,0x01,0x07,0x7C,0xEB,0xEE,0x80,0xEF,0xCC,0x1C,0xF0,0x8D,0x85,0x02,0xBE,0x30,0xC3,0xC0,0x03};
//const uint8_t spSAID[] PROGMEM ={0x06,0x38,0xBA,0xCC,0x02,0x16,0xF0,0x80,0x04,0x4E,0x94,0x63,0x98,0xB1,0xBF,0xB9,0xD1,0x8D,0x6F,0x72,0xF2,0x5C,0xC2,0x8C,0x73,0xCB,0xAD,0x4E,0x9D,0x92,0xBB,0x6B,0xAC,0xB9,0xDD,0xE8,0x63,0x34,0x37,0x8B,0x25,0xAE,0xA7,0x2E,0xD4,0xB3,0x6D,0xF1,0x81,0x0D,0xD4,0xA5,0x7A,0xB6,0x2C,0x36,0x30,0x95,0x9E,0x11,0x8E,0x5D,0x37,0xA4,0xA9,0xBA,0xBB,0x56,0x5D,0x1C,0x26,0xCC,0x59,0x1B,0xE0,0x01,0x00,0x00};
//const uint8_t spSAVE[] PROGMEM ={0x0A,0x78,0x46,0xD4,0x02,0x16,0x90,0x40,0x4B,0x7C,0xF2,0x50,0xEF,0x26,0x3B,0x39,0x49,0xEC,0x11,0x22,0xD5,0xF4,0x24,0xB1,0xB8,0x8B,0x4D,0x93,0x95,0xA6,0xAC,0xA6,0xB6,0x4D,0x76,0x36,0xF2,0x5C,0x44,0xD5,0xB7,0xF1,0xAA,0x72,0x15,0x55,0x9F,0x25,0xA3,0xCE,0x59,0x58,0xB3,0x6E,0x8F,0x26,0x67,0x61,0x8D,0x7C,0xDC,0x9A,0x9C,0x85,0x34,0x73,0xF6,0x68,0x4A,0x77,0x22,0xB3,0xA7,0xA3,0x29,0x31,0x98,0xC2,0xD6,0x94,0x36,0x06,0x55,0x73,0x69,0x12,0x3A,0x1F,0xC5,0x8D,0xB5,0x8D,0xEA,0x8C,0x34,0x09,0x33,0x37,0x66,0xE8,0x31,0xDD,0x58,0x69,0x33,0x20,0x84,0x14,0x04,0xE8,0xE8,0x81,0x00,0xED,0x5C,0x1F,0x00,0x00};
//const uint8_t spSAY[] PROGMEM ={0x08,0x78,0xDE,0x5C,0x03,0x16,0xB0,0x80,0x05,0x2C,0x60,0x01,0x0D,0xAC,0x38,0xE5,0x70,0xD1,0x9A,0x7B,0x93,0x9B,0x9C,0x34,0xD5,0x30,0xD1,0x9A,0x7B,0xB3,0x93,0xD7,0x1C,0xA4,0x1A,0x6F,0x6E,0xBD,0xBA,0x52,0x59,0xD5,0xB7,0x76,0x1F,0xEA,0x90,0x07,0x37,0xE4,0x82,0x9A,0xF1,0x51,0xDC,0x98,0xAD,0x62,0x74,0x07,0x7A};
//const uint8_t spSAYS[] PROGMEM ={0x0C,0xF8,0x0C,0x42,0x01,0xDF,0x8B,0x28,0xE0,0x2B,0x35,0x05,0x5C,0xAD,0x66,0x80,0x17,0xCC,0x2C,0xA0,0x80,0xEF,0x4D,0x39,0x70,0xA2,0x18,0xDC,0x4D,0xAA,0xF1,0x4D,0x57,0x1A,0xAA,0x85,0xC4,0x24,0x99,0xE9,0xCE,0x76,0xB1,0xEB,0xDD,0xAC,0xD6,0x45,0x4F,0xB5,0x5A,0xBC,0xDB,0xD9,0xF6,0xA6,0x35,0x3E,0x58,0x0A,0x67,0x9B,0xD2,0x78,0xEB,0xEE,0x18,0x9D,0x53,0xBB,0xB8,0x9A,0x87,0xEA,0x15,0xC0,0x33,0xA4,0x12,0x30,0xC0,0xD5,0x62,0x1A,0x10,0x40,0x63,0xA1,0x0F};
//const uint8_t spSCREEN[] PROGMEM ={0x04,0xF8,0x4A,0x4D,0x00,0x57,0xAB,0x29,0xE0,0x05,0x33,0x0D,0x80,0x01,0x3C,0x2B,0x17,0x80,0x9E,0x4D,0x12,0x28,0xB1,0x19,0x18,0x96,0xA6,0xBD,0xA7,0x23,0xF1,0x93,0x53,0xDC,0xF2,0xAE,0x24,0x4E,0x35,0xA5,0x88,0xBF,0x92,0x11,0x83,0xD0,0x7D,0xCD,0x4E,0x6E,0xBA,0xB3,0x51,0x8C,0x1C,0x0C,0x9A,0x8B,0x77,0xB5,0x9B,0xD1,0xF6,0x9A,0x0C,0xEA,0x8B,0x4B,0x57,0xAB,0x23,0x9B,0x3D,0x76,0x9D,0x73,0x50,0x66,0x65,0xDB,0x77,0xBE,0x77,0xBD,0xF5,0x58,0x6A,0xE5,0xD8,0xF6,0xBA,0x97,0xC3,0x03,0x00,0x00};
//const uint8_t spSECOND[] PROGMEM ={0x0C,0x88,0xC4,0xC2,0x01,0xDF,0x08,0x3B,0xE0,0x17,0x22,0x07,0xFC,0x22,0x1C,0x80,0x5F,0x14,0x1C,0xF0,0x83,0x4A,0x88,0x3A,0x73,0x33,0x31,0x5B,0x3B,0x1D,0x99,0xCB,0x11,0x6E,0x59,0x67,0x64,0xB1,0xB8,0x86,0x66,0x65,0x20,0x80,0xF6,0x26,0x18,0x40,0x80,0x28,0x1A,0xAB,0x0E,0x25,0xCC,0xD4,0x27,0xEF,0x66,0x74,0xDE,0x97,0x6A,0x58,0xEC,0xD0,0x07,0x0F,0xA5,0x29,0x49,0x62,0x1F,0xFB,0xD8,0xBB,0xDE,0x58,0x38,0x0F,0x93,0x62,0x7B,0x31,0xE0,0x90,0x95,0x5A,0x36,0xD3,0x10,0xB3,0x87,0x70,0xC4,0xF4,0xCD,0x03,0x00,0x00};
//const uint8_t spSEE[] PROGMEM ={0x08,0xD0,0xB4,0x42,0x00,0x8B,0x88,0x3A,0xE0,0x2B,0xD5,0x00,0xFC,0x18,0xE6,0x81,0x08,0x78,0xC0,0x00,0x4F,0xAB,0x1C,0xA7,0xF8,0x60,0x31,0x7D,0x73,0xE2,0x1A,0x93,0xD8,0xED,0xEB,0x8D,0x6F,0x72,0xB3,0x51,0xF4,0x9A,0x02,0x1A,0x6F,0x77,0xB5,0xEB,0xD9,0x94,0xB6,0x34,0x22,0xA9,0xA9,0x93,0xBB,0xD0,0x25,0xC7,0x94,0x97,0xA1,0x4D,0xE7,0x95,0xF0,0x9E,0x18,0x35,0x5D,0xF4,0xA0,0xD3,0x29,0x4C,0x75,0xC1,0x82,0x86,0xB9,0xB3,0x07};
//const uint8_t spSEES[] PROGMEM ={0x08,0x30,0x2C,0x45,0x01,0x3F,0x87,0x7B,0xC0,0x03,0x11,0x88,0x80,0x03,0x8E,0x09,0x1B,0x49,0xB2,0xA6,0x66,0xD1,0xE9,0xC4,0xCD,0x87,0xA2,0xCB,0xD7,0x95,0xF4,0xE8,0x0C,0x11,0x6F,0x77,0x3A,0xB3,0x59,0xF5,0x6A,0xB4,0xBD,0x95,0x02,0xCB,0xB6,0xD2,0x97,0xCA,0x82,0x51,0x4F,0xCA,0x90,0x0A,0x8B,0x58,0xBD,0xCD,0x7D,0x1A,0x62,0x62,0x91,0xC8,0xC7,0x69,0x08,0x91,0x55,0xB5,0xEE,0x84,0x3E,0x68,0x53,0x75,0x5F,0xA1,0x80,0x04,0x34,0x3D,0x60,0x01,0x09,0x50,0xE0,0x01,0x00,0x00};
//const uint8_t spSET[] PROGMEM ={0x06,0xF8,0x4E,0xC9,0x00,0xD7,0x29,0x2B,0xE0,0x3B,0x25,0x0B,0x58,0x40,0x01,0x5B,0xAA,0xB4,0x28,0xA5,0x50,0xD3,0x9C,0x77,0x93,0x9B,0xDE,0xEC,0x54,0x31,0x5B,0x8B,0x4F,0xE2,0x5B,0xF7,0x96,0x01,0x32,0x69,0x03,0x80,0x02,0xBC,0x4C,0xF3,0x00,0x02,0xA8,0x2D,0x05,0x80,0x07};
//const uint8_t spSEVEN[] PROGMEM ={0x0C,0xF8,0xDE,0x4C,0x02,0x1A,0xD0,0x80,0x05,0x2C,0xB0,0x62,0x17,0x2D,0x43,0x2B,0xF1,0x4D,0x6E,0xB2,0xD3,0x92,0x19,0x1F,0x6E,0xEC,0x51,0x5C,0xE5,0xB9,0x5A,0x58,0x3A,0x76,0x95,0xF7,0x9E,0x1E,0x30,0xAF,0x77,0x65,0xB2,0x29,0x42,0x2C,0xA6,0xB8,0xD9,0x64,0xCD,0x90,0x8A,0xE5,0x66,0x13,0x38,0x8C,0xD3,0x9D,0x58,0xB4,0x17,0x1B,0x29,0xF7,0x62,0x31,0x5E,0xC5,0x24,0xD3,0x88,0xCD,0x79,0xD6,0x90,0x71,0xF7};
//const uint8_t spSEVENTY[] PROGMEM ={0x0E,0xF8,0x41,0x38,0x02,0x1E,0xF0,0x80,0x07,0x2C,0xC0,0x81,0x13,0xBB,0xEC,0xA5,0x31,0xF1,0x6E,0x7C,0xE3,0x96,0xC6,0x64,0x6D,0xA4,0xB1,0x4D,0xE5,0x42,0xB8,0xAB,0x2D,0xEE,0x55,0xAB,0xBC,0x4F,0x33,0xD5,0xD9,0xA5,0x71,0x2E,0xC5,0x95,0x66,0x85,0xD6,0x58,0x98,0x94,0x8C,0xED,0x5B,0xD5,0x09,0x47,0x97,0x5C,0x96,0x44,0x2F,0x64,0x7A,0x84,0x5B,0x06,0x70,0x40,0xD1,0x69,0xA9,0xF6,0x4E,0xB8,0xD6,0x43,0xD5,0x3E,0x0F,0x71,0xB4,0x03,0x3C};
//const uint8_t spSHAPE[] PROGMEM ={0x00,0x0C,0x58,0x69,0x43,0x03,0x16,0x88,0x80,0x07,0x3C,0xE0,0x01,0x0F,0x9C,0x24,0x67,0x57,0xD5,0x6E,0x7A,0xD3,0x9B,0xDF,0xEA,0x54,0x2D,0x06,0x89,0xD6,0xD2,0x59,0x87,0xBA,0x06,0x43,0x8B,0xBE,0xE3,0x9A,0x18,0x51,0x2A,0x7B,0x34,0x6E,0x00,0xC0,0x00,0xC1,0x25,0x33,0x80,0xBB,0x30,0x80,0x07};
//const uint8_t spSHAPES[] PROGMEM ={0x0A,0x58,0x69,0xC3,0x02,0x1E,0x88,0x80,0x07,0x3C,0xE0,0x81,0x15,0xE5,0xEC,0xAA,0xDA,0x4D,0x6F,0x7C,0xE3,0x9B,0x9C,0xB4,0xC5,0x20,0xD1,0x5A,0x7A,0xF3,0x51,0xD5,0x60,0x68,0xD1,0x77,0x4A,0x1B,0x23,0x4A,0x65,0x8F,0xD6,0x2D,0x00,0x80,0x01,0x7E,0x76,0xB7,0x80,0x03,0x7E,0x72,0x75,0xC0,0x2F,0xA1,0x06,0xF8,0xD9,0xD5,0x00,0x3F,0xB9,0x32,0xE0,0x07,0x16,0x01,0x2C,0xE9,0xF9};
//const uint8_t spSHIFT[] PROGMEM ={0x08,0x98,0x6D,0x53,0x03,0x1E,0xF0,0x40,0x02,0x56,0xDA,0x88,0x40,0x04,0x2C,0x70,0x92,0xAA,0x42,0x65,0x7C,0xF3,0x4D,0x6F,0x76,0x8A,0x22,0xC3,0x74,0x6C,0xD3,0xAC,0x7C,0x4B,0x00,0x2B,0x9C,0x39,0xC0,0x01,0x0E,0x70,0x00,0x00,0x40,0x01,0x99,0x87,0x11,0x40,0xB8,0x30,0x78};
//const uint8_t spSHORT[] PROGMEM ={0x0E,0x18,0x63,0xDB,0x01,0x63,0xEC,0x3A,0x60,0xF4,0x19,0x0B,0x50,0x60,0xA4,0xCA,0x56,0xBA,0x9B,0x9F,0x99,0x8E,0x54,0xDB,0x8D,0x70,0xD5,0xBE,0xF3,0x55,0x99,0x30,0x66,0x29,0xFA,0x57,0xE5,0x42,0x8B,0xB6,0xEA,0x5B,0x95,0xAF,0xC5,0x52,0xAE,0x2F,0x55,0xAE,0x0B,0x7B,0x54,0x5C,0xD6,0x27,0x67,0x1E,0x12,0x6E,0x00,0x0C,0x50,0xBC,0xAB,0x02,0x52,0x2E,0x41,0x80,0x0E,0x16,0x0F};
//const uint8_t spSHORTER[] PROGMEM ={0x08,0x18,0x63,0x5B,0x03,0x16,0x30,0xC0,0x18,0xBB,0x0E,0x18,0x7D,0xC6,0x02,0x14,0x18,0xA9,0x33,0xE1,0x9E,0xAA,0x76,0xA4,0xCA,0x55,0x65,0x90,0xF6,0x91,0xCA,0xB8,0x5D,0x0E,0xEE,0x47,0x2A,0xD3,0x56,0x3A,0xBA,0x5F,0xA9,0x0E,0x13,0x9E,0xEC,0x7D,0xA5,0xD6,0xA7,0xF9,0xB2,0xB6,0x91,0xFA,0xA9,0x1A,0xE6,0x7A,0xC0,0x00,0x21,0x2A,0x07,0xA0,0x0C,0x97,0x92,0xBB,0x24,0x9E,0x16,0x49,0x46,0xE5,0x17,0x85,0xBB,0x67,0x1B,0x8D,0x9F,0xEC,0x96,0x96,0xBD,0x75,0x7E,0xB1,0x5B,0x6A,0xF6,0xD2,0xDB,0x41,0x11,0x19,0xE9,0x42,0x6F,0x07,0x54,0x59,0x24,0x76,0x83,0xED,0xAC,0x99,0xE1,0xC4,0x74,0xF1,0xB2,0xB8,0x9A,0x63,0x00,0x00,0x94,0x26,0x93,0xE2,0xE1,0x6A,0x1E};
//const uint8_t spSHOULD[] PROGMEM ={0xE0,0x80,0xD9,0x36,0x23,0x10,0x81,0x04,0xAC,0xB4,0x91,0x81,0x08,0xAC,0x38,0xE8,0x10,0x4D,0xEF,0x77,0x12,0x6F,0x3C,0x23,0x29,0xEF,0x4E,0x57,0xEA,0x74,0xA4,0x87,0xE4,0xBD,0xC5,0xAD,0x6E,0x77,0xBB,0xDD,0x97,0x3E,0x06,0x09,0x37,0x79,0x6B,0x7B,0x3D,0x88,0x5E,0xF0,0xF0,0xB2,0x70,0x9D,0x86,0x6A,0x4C,0x3C,0xCD,0xB5,0xEB,0x53,0x14,0x57,0xD1,0x47,0x08,0xE0,0xDA,0xE3,0x01};
//const uint8_t spSIDE[] PROGMEM ={0x04,0xF8,0xC5,0xC4,0x02,0x16,0xB0,0x80,0x05,0x28,0xB0,0x2A,0xEF,0xAB,0x5D,0xA2,0xF1,0x4D,0x6F,0x7A,0xD3,0x93,0x85,0x58,0x65,0x12,0xB3,0x6F,0x7E,0xAA,0x90,0xB3,0x4C,0x7C,0xCE,0xAD,0x4F,0x9B,0x8A,0x85,0x69,0xCD,0xD9,0xDD,0xE8,0x63,0x12,0xD7,0xE8,0xD9,0xBD,0x2F,0x7D,0x8A,0x6C,0x6E,0x75,0x47,0x0C,0x54,0x67,0x84,0x7B,0x62,0xD9,0xB3,0x9E,0xC9,0xF2,0xB4,0x50,0x92,0xFA,0xE5,0xD2,0x4C,0xCD,0xB1,0x69,0xA3,0x57,0x55,0xB1,0x4E,0xAA,0x8F,0x55,0x8D,0x69,0x12,0x3E};
//const uint8_t spSIDES[] PROGMEM ={0x08,0xF8,0x56,0x58,0x03,0x1E,0xF0,0x80,0x05,0x24,0xA0,0x81,0x93,0x86,0x5C,0x65,0x92,0x75,0x6E,0x7E,0xF3,0x5B,0xDC,0xE2,0x54,0xA1,0x56,0xAA,0x46,0x9D,0xD3,0xC4,0xA2,0x61,0x56,0x53,0x77,0x3B,0xBA,0x94,0xC5,0xDC,0x6B,0xCA,0xEC,0x7B,0x5F,0xFA,0xE0,0x54,0x3C,0xE2,0x91,0xE8,0xB0,0xA9,0xF0,0x4A,0x99,0xB2,0x93,0x9D,0xEA,0x9F,0x15,0x74,0x31,0xBB,0xBE,0x57,0xC0,0xE6,0x22,0x0E,0xF8,0x4E,0x39,0x02,0x1A,0x78,0x00,0x00};
//const uint8_t spSIX[] PROGMEM ={0x06,0x98,0xB6,0xC4,0x01,0x2F,0x66,0x46,0x20,0x01,0xD3,0x96,0x18,0x40,0x04,0xAF,0x96,0xA4,0x60,0xA1,0x52,0x8B,0x6F,0xB2,0x92,0x58,0xC4,0xC5,0x67,0xC9,0x4E,0x46,0x95,0x9A,0xB8,0x44,0x2D,0x76,0x7D,0x48,0xD8,0x13,0x15,0x03,0x00,0x10,0x60,0xA2,0x8B,0x00,0x8E,0xAD,0x52,0xC0,0xCF,0x9E,0x1A,0x10,0xC0,0x8F,0xE6,0x0F,0x00,0x00};
//const uint8_t spSIXTY[] PROGMEM ={0x06,0xF8,0x8A,0x5C,0x03,0x0E,0xF8,0xCE,0x44,0x01,0x4F,0x98,0x9D,0x24,0x3A,0x37,0xB7,0x78,0x72,0xE2,0x9C,0xCD,0xCC,0xE2,0xC9,0x8A,0x73,0x57,0x51,0xCD,0xBB,0x00,0x0C,0x30,0x25,0x28,0x00,0xC7,0x54,0x04,0xE0,0x5B,0x57,0x05,0x5C,0xC1,0x8C,0x00,0x0F,0xAA,0xC0,0x01,0x35,0x16,0x8D,0x2C,0xEA,0xA0,0xB4,0x6A,0xBC,0xAA,0x92,0x8C,0x39,0xE2,0x4D,0x69,0x4B,0x57,0xA6,0xA8,0xDB,0xA1,0x4F,0x41,0xD0,0xAE,0x63,0x9B,0x31,0x19,0xE2,0xAA,0x0A,0xFD};
//const uint8_t spSMALL[] PROGMEM ={0x0C,0xF8,0xD9,0x44,0x02,0x12,0xD0,0x80,0x05,0x34,0x10,0x52,0x69,0x35,0x4A,0xCC,0x5E,0xCC,0x56,0x66,0xDC,0xAD,0xB1,0x37,0xDD,0xD9,0xCC,0x67,0x31,0xAB,0xD9,0x94,0x46,0xD6,0x19,0xC5,0x76,0x52,0xBB,0xD0,0x89,0xB5,0xAD,0x50,0xCA,0x62,0xEF,0x7A,0x7E,0x2F,0x14,0x53,0x99,0xE9,0x79,0x7B,0x52,0x75,0xBB,0x0F,0x00,0x00};
//const uint8_t spSMALLER[] PROGMEM ={0x04,0xF8,0xD5,0x48,0x02,0x1A,0xD0,0x80,0x06,0x38,0x00,0x29,0xD6,0x46,0xBA,0x59,0x93,0x94,0xD4,0x8B,0x9E,0x64,0x4E,0x3A,0xD3,0x99,0xEC,0x64,0xA7,0x3B,0x2D,0x95,0xD6,0xD3,0x49,0x6A,0xAF,0xD4,0xDA,0xFB,0xAB,0x9A,0xE6,0xD4,0xEA,0xCE,0xD3,0x62,0x89,0x63,0xEF,0x06,0x77,0xD0,0xC6,0xB4,0x91,0x1F,0xDC,0xE8,0x2E,0xAB,0x57,0x78,0xB1,0xD3,0x03};
//const uint8_t spSMALLEST[] PROGMEM ={0x0A,0xF8,0x06,0xC5,0x02,0x1E,0xF0,0x00,0x05,0xC0,0xA5,0x34,0x25,0x87,0x5B,0xDA,0x96,0x79,0x95,0x1F,0xAC,0xAD,0x77,0x76,0xB3,0x95,0x59,0x53,0xEF,0xE4,0x8D,0x57,0x66,0xCC,0x97,0xAA,0xA5,0xDD,0x79,0xAD,0x5A,0xE3,0xD8,0x95,0x39,0x35,0x19,0xAD,0xB5,0x13,0xA6,0xBE,0x68,0xF4,0x36,0x44,0x86,0x54,0x93,0x32,0xD8,0xE6,0x6C,0x35,0x2E,0xF3,0x10,0x86,0x10,0xCA,0x18,0x22,0x93,0x01,0xBE,0x15,0xF2,0x40,0x00,0x7E,0x35,0x70,0xC0,0x1F,0x0A,0x18,0x00,0x70,0x40,0xE5,0x16,0x06,0x38,0x4E,0x0C,0x1E,0x00,0x00};
//const uint8_t spSO[] PROGMEM ={0x06,0xF8,0x51,0x38,0x01,0xDF,0x29,0x07,0xE0,0x47,0xE5,0x04,0x7C,0xA7,0x1C,0x80,0x1F,0xCD,0x22,0x70,0xE2,0xC8,0xA3,0xD3,0x34,0xCF,0x8D,0x6F,0xB2,0x52,0xAB,0xBA,0xCA,0xD9,0xEF,0xCE,0x76,0x35,0xDB,0xD2,0x8B,0x50,0x9B,0x46,0x59,0xC3,0x40,0x57,0x77,0x92,0xA5,0xB4,0x83,0x1A,0xC9,0x99,0x30,0xF1,0xD4,0x62,0x64,0xBD,0x43,0xC5,0xDD,0x3C,0x00,0x00};
//const uint8_t spSOME[] PROGMEM ={0x0C,0x78,0x55,0x40,0x02,0x12,0xD0,0x80,0x06,0x2C,0x10,0x92,0x64,0xAA,0x2D,0x38,0xED,0x4D,0x6E,0x76,0x32,0x17,0xBA,0xD5,0xB8,0xC9,0xCD,0x76,0xDE,0x2A,0x9B,0xA5,0x54,0x28,0x4D,0xAC,0x63,0x1B,0xDB,0xD8,0xFA,0xCE,0x76,0xB2,0xA7,0xFD,0x03};
//const uint8_t spSORRY[] PROGMEM ={0x06,0x38,0xD6,0xD4,0x03,0x01,0xF8,0x5E,0x35,0x00,0x3F,0xBA,0x45,0x20,0x03,0xCB,0x77,0xD6,0xDA,0x35,0x6D,0x9F,0xD8,0x27,0xDF,0x10,0x4F,0x7B,0xE3,0x13,0x87,0x6C,0xE7,0xA6,0x69,0x6E,0x7C,0x12,0x57,0xEC,0xCC,0xB5,0xED,0xCA,0x4C,0xB3,0xB3,0x94,0x2C,0xA3,0xB2,0x4D,0xC7,0x06,0xD7,0x8E,0xC6,0x57,0x69,0x19,0x69,0x37,0xFB,0xD1,0xA7,0xCA,0x66,0x31,0x0D,0x7B,0xDF,0xFA,0x32,0xC8,0x35,0x36,0x56,0xE9,0x72,0x03,0xB3,0x38,0x49,0xA5,0xAD,0xD5,0x21,0xB4,0x4B,0x9B,0xC6,0x19,0xE6,0xF7,0x90,0xF2};
//const uint8_t spSPACE[] PROGMEM ={0x0C,0x78,0x46,0x54,0x03,0x1E,0x88,0x00,0x06,0x00,0xC0,0x00,0xAA,0x4A,0x9F,0x3C,0x34,0x73,0xB1,0x4A,0x7D,0xF3,0x53,0xA4,0x66,0xA6,0x1A,0x4B,0x57,0x95,0x93,0xB2,0x46,0xAC,0x9E,0x75,0x6B,0x63,0x10,0x31,0xAF,0xC5,0xB5,0x53,0xC0,0xD7,0xA6,0x11,0x88,0x80,0x07,0x22,0xE0,0x81,0x07};
//const uint8_t spSPACES[] PROGMEM ={0xC0,0x80,0x09,0xAC,0x0C,0xF0,0x8C,0x86,0x03,0x7E,0x50,0x77,0xC0,0x8F,0x16,0x0E,0xF8,0x2E,0xD3,0x00,0xCC,0xA5,0x03,0x9C,0x24,0x34,0x73,0xB1,0x4A,0x7D,0xB3,0x93,0xA7,0x66,0xA6,0x1A,0x4B,0x4F,0x9E,0x93,0xB2,0x46,0xAC,0xDE,0x59,0xCB,0x62,0x10,0x31,0xAF,0xC5,0x3D,0x33,0xC0,0xB7,0xA4,0x0E,0xF8,0x4E,0x24,0x00,0xDF,0x98,0x1B,0xA0,0x31,0xF3,0x34,0x98,0xE0,0x66,0x19,0xB7,0xF2,0x90,0xA7,0x38,0x99,0xC9,0x04,0x73,0x8D,0x7A,0x10,0xA6,0xAB,0x3D,0x54,0x58,0xBF,0x01,0x36,0x66,0xD5,0x80,0x02,0x2E,0x23,0x55,0xC0,0x67,0xA8,0x02,0xF8,0x92,0x4D,0x00,0x93,0x98,0xC1,0x03};
//const uint8_t spSPELL[] PROGMEM ={0x01,0xF8,0x5E,0x2D,0x01,0x3F,0x9A,0x27,0xE0,0x27,0x0B,0x07,0x5C,0x4D,0x0E,0x00,0x0C,0xB0,0x22,0xEC,0xA4,0x26,0xA4,0xAB,0x57,0xAA,0x93,0xD9,0x98,0xE1,0xDE,0xA9,0x4F,0xEE,0x62,0x86,0x79,0xA5,0x3E,0x85,0x4F,0x19,0xEA,0xD1,0xE6,0x54,0x3E,0x64,0x9A,0x46,0xE6,0x53,0x85,0x90,0x15,0x12,0xBE,0x57,0x6D,0x72,0x65,0xD0,0x7A,0x1A,0xAD,0xCA,0x53,0x4E,0xE3,0xB9,0x0D,0xB2,0x4F,0x06,0xA7,0xE7,0x32,0x8A,0xDE,0xD9,0x10,0x9E,0xD3,0xC4,0x7B,0x47,0x83,0xDB,0xF6,0x93,0x99,0xA4,0x7F,0x2B,0xA2,0x54,0x66,0x16,0x39,0x2C,0x2C,0x2C,0x3D};
//const uint8_t spSQUARE[] PROGMEM ={0x0A,0xF8,0x01,0xC5,0x02,0x11,0xC8,0x00,0x06,0x00,0x10,0x20,0xE6,0x18,0x02,0x78,0x6F,0x2B,0x89,0x8C,0x5D,0x69,0x94,0x75,0xA6,0x3B,0x3D,0x69,0x28,0x66,0xA1,0xBE,0xE6,0x66,0x3B,0xDF,0xC5,0xAA,0x62,0x73,0xF1,0xB4,0xAE,0xAD,0xF3,0x87,0x3D,0xCC,0xBB,0xD4,0x21,0x8F,0x69,0xF4,0xDB,0x29,0x42,0x66,0x87,0x29,0x5C,0xD7,0x40,0x4E,0xE6,0xA6,0x70,0xD8,0x92,0x3C,0x91,0x9D,0x1E};
//const uint8_t spSTART[] PROGMEM ={0x0A,0xF8,0x41,0xC2,0x00,0x3F,0x59,0x78,0xC0,0x02,0x00,0x01,0xA8,0xCE,0xED,0x84,0xC1,0x65,0x98,0x45,0xEA,0x93,0xD8,0x12,0xE3,0x9C,0x99,0x6F,0x7A,0x32,0x97,0x63,0x82,0xAD,0xCD,0xCA,0x7D,0x0B,0x2F,0xC7,0xA5,0xB7,0x5E,0x9D,0x1F,0xAE,0x19,0xB4,0xA4,0x0F,0x6D,0x0C,0x8D,0x3C,0xC3,0x62,0x87,0x21,0x74,0xD0,0xF0,0x48,0x0C,0x90,0x80,0x61,0x22,0x1C,0xA0,0xB5,0x0B,0x06,0x1E};
//const uint8_t spSTEP[] PROGMEM ={0x06,0x78,0xC1,0xD3,0x02,0x11,0xB0,0x00,0x40,0x02,0xAA,0x4A,0x39,0x69,0x88,0xA1,0xA6,0xD5,0xFA,0xA4,0xA1,0x5B,0x88,0x75,0xD3,0x9B,0xDF,0x62,0xB4,0xB6,0x59,0xB9,0x75,0xAC,0x30,0x98,0xA9,0xA5,0xB6,0xB1,0x01,0x80,0x01,0x32,0x04,0x63,0xE0,0x01,0x00,0x00};
//const uint8_t spSTOP[] PROGMEM ={0x0E,0xD8,0x5A,0x3D,0x02,0x11,0xF0,0x00,0x40,0x00,0xBA,0x0F,0x5F,0x85,0x4F,0xBD,0x2A,0x91,0xE4,0x16,0xB7,0xBA,0xD5,0x6D,0x6E,0x33,0x3A,0xDB,0xA7,0x94,0xC7,0xAE,0xEF,0x01,0x00,0x04,0xA0,0xBD,0x39,0x06,0xE0,0x01,0x00,0x00};
//const uint8_t spSUM[] PROGMEM ={0x0C,0x78,0x55,0x40,0x02,0x12,0xD0,0x80,0x06,0x2C,0x10,0x92,0x64,0xAA,0x2D,0x38,0xED,0x4D,0x6E,0x76,0x32,0x17,0xBA,0xD5,0xB8,0xC9,0xCD,0x76,0xDE,0x2A,0x9B,0xA5,0x54,0x28,0x4D,0xAC,0x63,0x1B,0xDB,0xD8,0xFA,0xCE,0x76,0xB2,0xA7,0xFD,0x03};
//const uint8_t spSUPPOSED[] PROGMEM ={0x06,0xD8,0xCA,0xC5,0x03,0x11,0x88,0x80,0x07,0x46,0x62,0x74,0x96,0xB9,0xB7,0x9A,0x59,0x2D,0x70,0x05,0x0E,0xB0,0x35,0x6D,0xA5,0xC6,0x65,0x9B,0x6A,0xEB,0x93,0x39,0x93,0x63,0xAA,0x59,0x46,0xA6,0x6D,0x8D,0xAA,0x75,0x99,0xD9,0x2C,0x5A,0xA5,0x4C,0xB7,0x9A,0x76,0x1E,0xB5,0x36,0x55,0x62,0xD6,0x65,0xD4,0xC6,0x54,0xAA,0x6B,0x97,0xD5,0x58,0x9D,0x25,0xAE,0x5D,0x46,0xE3,0x55,0xA6,0x98,0x76,0x6D,0xAD,0xB3,0x15,0x64,0xD6,0x46,0x01,0x15,0x90,0x7B,0x20,0x02,0x11,0x00,0x60,0x80,0x13,0x1E,0x06,0x68,0x22,0x0C,0x1E,0x00,0x00};
//const uint8_t spSUPPOSED_TO[] PROGMEM ={0x04,0x78,0x4D,0xC8,0x02,0x0E,0xF8,0x45,0xD0,0x01,0xBF,0x9A,0x7A,0xE0,0x14,0x51,0x66,0xB2,0x47,0xEB,0x5B,0xED,0x0A,0x0C,0xE0,0xB5,0x65,0x4B,0xB4,0x9B,0x52,0xF5,0xD6,0x3B,0xBD,0xD9,0xCE,0x46,0x2E,0xDD,0x26,0x47,0xB5,0x9A,0x79,0xCF,0x6B,0xE5,0x80,0x5B,0x98,0x3D,0x60,0x80,0x3F,0x98,0x00,0x12,0xB0,0x9C,0x7A,0x00,0x96,0x74,0x1F,0x55,0x71,0x6E,0x9C,0x9C,0xED,0x36,0xB7,0x1B,0xBD,0xF1,0x1A,0x19,0x3A,0xBB,0xF6,0x61,0x94,0xC1,0x33,0xD3,0x1A,0xB9,0x51,0x24,0xB7,0x4C,0xAF,0x6D,0x46,0x65,0xCB,0xAD,0xA4,0xA1,0x19,0x8D,0x31,0x6B,0xD6,0x44,0x0F};
//const uint8_t spSURE[] PROGMEM ={0x00,0x00,0x00,0x40,0x80,0x2C,0x45,0x0D,0xB0,0xE6,0x54,0x04,0x22,0xB0,0xD2,0x5E,0x76,0xAE,0x52,0xF1,0x09,0x4A,0xAC,0x40,0x54,0xAD,0x2B,0x4D,0x3E,0x8C,0x22,0xB5,0xAF,0x34,0xF8,0x30,0x19,0xF7,0xBE,0x72,0xE7,0x43,0x6D,0xDD,0xFD,0xAA,0xBC,0x2B,0xB1,0x55,0xF7,0xA3,0x72,0x39,0x38,0x86,0xBD,0xB7,0xDA,0x54,0x97,0x1C,0x4D,0x9F,0x5B,0xD7,0xD9,0x49,0x5E,0x66,0x5D,0x54,0xAF,0x8A,0x7A,0x5A,0x30,0x52,0xBD,0x2B,0xA2,0xAE,0xA1,0x51,0xF4,0xBE,0x99,0x18,0xBB,0x6B,0x00,0x00,0x78};
//const uint8_t spT[] PROGMEM ={0x09,0x58,0xCC,0x3C,0x00,0x2F,0x85,0x96,0x70,0xC6,0x50,0x62,0x69,0xB2,0x92,0x91,0x82,0xC1,0xE3,0xED,0x4D,0x4E,0x3A,0xA2,0x32,0x46,0x3E,0xD9,0xF9,0xAC,0x5A,0x3D,0x2C,0x33,0x77,0xCE,0x4E,0x4D,0x51,0xCC,0xB6,0x59,0xC6,0x35,0x46,0x88,0x4F,0xAB,0x55,0xD5,0x38,0x26,0x3E,0x23,0x66,0x1F,0x00,0x00};
//const uint8_t spTAKE[] PROGMEM ={0x09,0xE8,0xDA,0x3D,0x00,0xCD,0xB5,0x18,0x20,0x15,0xB5,0x11,0xA7,0xA6,0x2E,0x31,0xAE,0x6F,0x72,0xD2,0xD2,0xD5,0x28,0xAA,0xE9,0xCD,0x76,0x31,0xEA,0xE8,0xC0,0xB6,0xD2,0x74,0xEC,0xCD,0x98,0x64,0x6A,0x98,0x29,0x06,0x08,0x40,0x74,0x4E,0x16,0x10,0x40,0x0A,0x06,0xF0};
//const uint8_t spTEEN[] PROGMEM ={0x01,0x58,0x36,0x25,0x02,0x16,0x38,0x7E,0x0B,0x26,0xE4,0x31,0xF7,0x26,0x37,0x1D,0xD9,0x8C,0xCC,0xD2,0x39,0x69,0x16,0xB3,0xEA,0xCD,0xEC,0x5A,0x37,0xA2,0x30,0x67,0x54,0x09,0xBD,0xB6,0xB4,0x69,0x25,0xC5,0x0E,0x66,0xD0,0x86,0x2E,0xB4,0x6C,0x9B,0x41,0x6A,0x99,0x94,0x74,0xA4,0x06,0x61,0x64,0x53,0xCB,0xB6,0x19,0x3C,0x35,0xCB,0xF2,0x54,0x00,0xF0};
//const uint8_t spTELL[] PROGMEM ={0x90,0x80,0xA5,0x42,0x1C,0xD0,0x6C,0x48,0x89,0x63,0x75,0x93,0xA8,0xB8,0x37,0xBD,0xE9,0x4D,0x4F,0x16,0x5A,0x84,0x78,0xD5,0xB9,0xF9,0x29,0x5C,0xCE,0x56,0xC9,0x26,0xB7,0x1A,0xB5,0x6E,0xD5,0xAA,0x31,0x7B,0xB6,0xAD,0x95,0xA3,0x5A,0x34,0x1B,0xD7,0xAE,0x74,0x62,0x55,0x29,0x67,0xE2,0xD0,0xF1,0x9B,0xA9,0xD4,0x51,0x4D,0xCF,0x6E,0xB8,0x4A,0xCB,0x71,0xBD,0x4A,0x16,0xE1,0x25,0xE9,0x01};
//const uint8_t spTEN[] PROGMEM ={0x0A,0xB0,0xDC,0xD4,0x01,0x83,0x86,0x28,0x20,0x85,0x10,0x01,0xB8,0x28,0x72,0xE2,0x34,0xCB,0x55,0xA2,0xEE,0x4D,0x6E,0x7A,0xB3,0x9B,0x9F,0x22,0x2E,0x77,0xF6,0x88,0x73,0xEB,0xDD,0xCE,0x2E,0x74,0xDE,0x42,0x4B,0x7A,0xA3,0xD8,0x85,0xDE,0x5B,0x18,0x89,0x4C,0xE9,0x7A,0x67,0xB0,0xC5,0x2B,0xA5,0xE9,0x95,0xE1,0x96,0xE8,0x84,0xAA,0xE7,0x4E,0xC3,0xEC,0x63,0x3F,0x00,0x00};
const uint8_t spTEXAS_INSTRUMENTS[] PROGMEM ={0x0E,0xA8,0xCA,0xD4,0x01,0x59,0xA4,0xAE,0x24,0xE8,0xD4,0xF0,0x88,0x74,0x92,0x90,0x4B,0xCD,0xA3,0xDE,0x49,0x62,0x29,0x31,0x8F,0xA5,0x2B,0x49,0x3B,0xD9,0x34,0x9A,0xB8,0x3C,0x24,0x07,0xD1,0x8C,0x63,0x92,0x15,0xB7,0x0C,0x59,0x96,0x01,0x7E,0x51,0xF5,0x80,0x03,0x7E,0x33,0x6A,0xC1,0x5F,0x29,0xC2,0x26,0x7F,0xE5,0xD1,0x94,0x99,0xD8,0xEB,0x95,0x45,0x5D,0xE6,0xEC,0x8F,0x57,0x16,0x6D,0x9A,0xA3,0x3F,0x69,0xF9,0xE2,0x92,0x26,0x96,0xD5,0x01,0xCF,0xB0,0x58,0xC0,0x03,0x1A,0x58,0x59,0x72,0xA5,0x41,0x3C,0x7B,0xE7,0x3B,0x9F,0x45,0x2B,0x9C,0xA6,0x6C,0xAA,0x7A,0xB1,0x0A,0xC0,0xEB,0x01,0x1E,0x70,0xC0,0xAB,0x0E,0x08,0x30,0x44,0x4B,0x00,0xC5,0x81,0x05,0x60,0x14,0x8F,0xD5,0x44,0xE7,0x2E,0x1A,0xCE,0x76,0x93,0x3A,0xE3,0xCC,0x25,0x54,0x79,0xEA,0xB5,0x75,0x17,0x33,0xB7,0xA5,0x77,0xBE,0x0A,0x3C,0x1C,0xF7,0xB1,0x4C,0xDE,0x55,0x70,0x78,0x4A,0x33,0x5B,0xA7,0xE1,0x90,0x71,0xED,0x24,0x67,0xB1,0x26,0x67,0x16,0xE8,0x89,0x15,0x30,0x05,0x9B,0x01,0x7E,0x51,0xF0,0x80,0x00,0x9E,0x47,0x92,0x80,0x02,0x7E,0x01,0x7C};
//const uint8_t spTHAN[] PROGMEM ={0xA5,0xC9,0xDE,0xDD,0x88,0x9C,0xE6,0xA6,0xB4,0x22,0xAA,0xA9,0x76,0xE2,0xD4,0x70,0x17,0xAC,0xD6,0x6E,0x72,0x7D,0xEA,0x14,0xBC,0x44,0x6D,0xE9,0xA9,0x72,0x8F,0x64,0xE9,0x24,0xB7,0xBA,0xC5,0x2D,0x6E,0x71,0xAB,0x5B,0x9D,0x36,0x77,0x2F,0xD6,0x88,0x73,0xBB,0xDB,0xED,0xBE,0x0F,0x69,0xB0,0x51,0xD2,0xDC,0x1D,0x87,0xC1,0x79,0x4C,0xD7,0x74,0xED,0x06,0xEB,0x30,0x4D,0xCB,0xAD,0x1F,0x6C,0xAF,0x3B,0xD6,0xC5,0x18,0x22,0x58,0x36,0x01,0xE5,0xC5,0x84,0x86,0xBA,0x9C,0x07};
//const uint8_t spTHAT[] PROGMEM ={0x22,0x57,0x51,0x55,0x7D,0x12,0x99,0x46,0x73,0x77,0x73,0x6F,0x65,0x3A,0x2F,0x38,0x35,0xB9,0x91,0xEA,0xB5,0x73,0x21,0xCF,0x56,0xA1,0x4F,0x3E,0x5C,0xC8,0x32,0x97,0x3A,0x45,0x4B,0x35,0x7B,0x7A,0xEA,0x50,0x3D,0x24,0x6A,0xEE,0xA9,0xE3,0xF0,0x94,0xC8,0x3A,0xA7,0x4A,0x33,0x4B,0x2C,0xE2,0x9C,0x2A,0xEE,0x48,0xF1,0xB4,0x73,0xAA,0x30,0x23,0xD4,0xDA,0xF6,0xA9,0x7C,0xF1,0x30,0x2B,0x49,0xAB,0x4A,0xCE,0xCC,0xC5,0x1C,0x97,0xD6,0x18,0x63,0x93,0x4A,0x0A,0x16,0xB0,0x00,0x07,0xE0,0x01,0x00,0x00};
//const uint8_t spTHAT_IS_INCORRECT[] PROGMEM ={0xA5,0x2B,0x51,0x25,0xC8,0x7C,0x9F,0x2A,0x78,0xCD,0xD0,0x7A,0x7A,0x0A,0x1F,0x2D,0xDD,0x7B,0xEE,0x29,0x6C,0x48,0xCF,0xE8,0x29,0xA7,0x30,0x21,0x3D,0x63,0xCA,0x0A,0x40,0xB8,0xA8,0x15,0x67,0x6F,0xEA,0xEA,0x6B,0x4E,0x93,0x42,0x88,0xAA,0xBF,0x3D,0x6D,0x49,0x2E,0x26,0xFE,0x76,0x75,0x39,0x9A,0xA8,0xC6,0xD7,0xD1,0x97,0x6C,0x2A,0x6A,0x7B,0xDA,0x90,0xA3,0x29,0x8B,0x6D,0x6E,0x43,0x49,0xA6,0x4A,0xDC,0xAF,0xF5,0xC5,0x99,0x38,0xF3,0xE7,0xD2,0x17,0x19,0xE2,0x2C,0xBD,0x15,0x70,0x04,0xB1,0x06,0x0C,0xF0,0xB3,0x72,0x00,0x06,0x63,0x63,0x00,0x37,0xD6,0x02,0xD0,0x81,0x67,0x15,0xB9,0x98,0xAA,0xD6,0xE2,0x9B,0x9C,0x38,0x47,0xD3,0xE0,0x6E,0xB2,0xA2,0x64,0x9C,0x8A,0x62,0x76,0x89,0xA2,0x87,0xF1,0x74,0x35,0x25,0xB2,0x52,0xDC,0x27,0x6C,0xAB,0x88,0x19,0xCF,0x37,0x77,0x02,0x01,0x88,0xD9,0x3A,0x44,0xBA,0x72,0x5B,0x52,0xAA,0x1A,0xA5,0x48,0x2E,0x4E,0x4F,0xEA,0x62,0x62,0xB6,0x24,0x32,0x55,0xAB,0x89,0xF9,0xA6,0x2A,0x17,0xB7,0x25,0xD2,0x93,0x26,0xD4,0x73,0x8F,0x50,0xE7,0xF4,0x92,0x6C,0xB6,0x22,0xEF,0xCA,0x4B,0x6A,0xF2,0x8A,0x7D,0xF4,0x0A,0xFD,0x58,0xA7,0xF1,0xD1,0xB2,0x6C,0x6B,0xEF,0xBE,0x4F,0x75,0x06,0x00,0x00,0x03,0x4C,0x27,0x2A,0x80,0x61,0xD4,0x18,0x50,0xB4,0xF2,0x03,0x00,0x00};
//const uint8_t spTHAT_IS_RIGHT[] PROGMEM ={0xA6,0xD1,0xC6,0x25,0x68,0x52,0x97,0xCE,0x5B,0x8A,0xE0,0xE8,0x74,0xBA,0x12,0x55,0x82,0xCC,0xF7,0xA9,0x7C,0xB4,0x74,0xEF,0xB9,0xB7,0xB8,0xC5,0x2D,0x14,0x20,0x83,0x07,0x07,0x5A,0x1D,0xB3,0x06,0x5A,0xCE,0x5B,0x4D,0x88,0xA6,0x6C,0x7E,0xA7,0xB5,0x51,0x9B,0xB1,0xE9,0xE6,0x00,0x04,0xAA,0xEC,0x01,0x0B,0x00,0xAA,0x64,0x35,0xF7,0x42,0xAF,0xB9,0x68,0xB9,0x1A,0x96,0x19,0xD0,0x65,0xE4,0x6A,0x56,0x79,0xC0,0xEA,0x93,0x39,0x5F,0x53,0xE4,0x8D,0x6F,0x76,0x8B,0x53,0x97,0x6A,0x66,0x9C,0xB5,0xFB,0xD8,0xA7,0x3A,0x87,0xB9,0x54,0x31,0xD1,0x6A,0x04,0x00,0x06,0xC8,0x36,0xC2,0x00,0x3B,0xB0,0xC0,0x03,0x00,0x00};
const uint8_t spTHE[] PROGMEM ={0xA1,0xB5,0x86,0xD3,0xD8,0x1B,0xB9,0xD6,0x1A,0x0E,0x61,0x5F,0x18,0xDA,0xE2,0x58,0xC5,0xA0,0xCF,0x2A,0x6A,0x31,0x15,0xE5,0x2D,0x27,0x6F,0x23,0x94,0x85,0xF6,0xAE,0xBC,0x25,0x21,0xAE,0xBC,0x3D,0xAB,0x59,0xF5,0x26,0x75,0xDD,0x09,0xD1,0xD5,0x4D,0x37,0x44,0x4E,0xD6,0xEF,0x61,0x7C,0x6F,0x86,0xE4,0x41,0xEB,0x4A,0xB4,0x1D,0x1E,0x00,0x00};
//const uint8_t spTHE1[] PROGMEM ={0xA9,0x73,0x5E,0x93,0xC9,0x53,0xC7,0x6E,0xB4,0xC9,0x6A,0xBB,0xE9,0xD6,0x5B,0x9D,0x2A,0x3A,0xEF,0x64,0x6F,0x7A,0xAB,0x55,0x45,0xEF,0x93,0xEC,0x49,0x5B,0x6D,0x72,0xA7,0xD1,0x5A,0x49,0x4D,0x72,0x1E,0x8E,0x6A,0xE9,0x01};
//const uint8_t spTHEIR[] PROGMEM ={0xA2,0x66,0x3E,0xCC,0x6D,0x62,0x8B,0x9A,0xF9,0x30,0x97,0x8D,0x2C,0x1A,0x6A,0x53,0x53,0x2A,0x09,0x6F,0x58,0x2D,0x45,0x98,0x5B,0x39,0x76,0x75,0xF2,0xE6,0x01,0xD3,0x74,0xE7,0x37,0x3F,0x79,0xAE,0xE6,0xA2,0xD3,0xE6,0xE6,0x37,0xBF,0xC5,0xA9,0xD2,0x50,0x35,0xEB,0x2E,0xA7,0x8A,0x53,0xCD,0xDC,0xBB,0xDC,0x66,0xB5,0xE1,0x52,0x86,0x46,0x93,0xD9,0xB5,0xCE,0x1F,0xCA,0x34,0x6F,0x92,0x3A,0xBF,0x71,0x5C,0xDA,0x45,0xE8,0xFC,0xC0,0x0A,0x6E,0x9B,0xA6,0x0B,0x87,0xCC,0xC8,0x53,0xA9,0x36,0x4C,0x46,0x15,0x73,0x23,0xDA,0x98,0x5C,0x85,0x3D,0x11,0x3C,0x00,0x00};
//const uint8_t spTHEN[] PROGMEM ={0xA2,0xA1,0x2E,0x2C,0xAC,0x13,0x8B,0x86,0xE9,0xF0,0xD0,0x49,0x2D,0x6A,0xC1,0xD3,0xD3,0xCA,0xB1,0xA8,0x8D,0x30,0x73,0x0F,0xC7,0xA1,0xAA,0xDC,0x54,0x4C,0x53,0x9F,0x3C,0x25,0x37,0xA5,0x6E,0x7D,0xB2,0x54,0xCD,0x59,0xAE,0xCD,0xC9,0x72,0x75,0x53,0x9E,0xD6,0x27,0xCB,0x3D,0x4C,0xA8,0x1B,0x9F,0xAC,0xB4,0x30,0xA5,0x6A,0x7C,0x8A,0xDC,0xC2,0x85,0xA6,0xF1,0xA9,0x72,0x0B,0x53,0xEA,0xC4,0xA7,0x4E,0xCD,0x43,0x69,0x92,0x9C,0x26,0x55,0x4F,0xE5,0x4E,0x72,0xDA,0x90,0x3D,0x4C,0x2A,0x71,0xE9,0xBC,0x85,0x55,0x4F,0x55,0xBE,0x77,0xBD,0xB3,0xB0,0xAE,0xE5,0xDA,0xF4,0xCA,0xE0,0xBA,0xB4,0x6D,0xD5,0x0B,0x2B,0x6D,0xB2,0x91,0x42,0xAF,0x6D,0x48,0xE8,0xD8,0x74,0x7D,0xF4,0xCA,0x4A,0xE5,0x04,0x01,0x3A,0x8A,0x00,0x00,0xC9,0x93,0xF6,0x34,0x71,0xDB,0x0F};
//const uint8_t spTHERE[] PROGMEM ={0xA2,0x66,0x3E,0xCC,0x6D,0x62,0x8B,0x9A,0xF9,0x30,0x97,0x8D,0x2C,0x1A,0x6A,0x53,0x53,0x2A,0x09,0x6F,0x58,0x2D,0x45,0x98,0x5B,0x39,0x76,0x75,0xF2,0xE6,0x01,0xD3,0x74,0xE7,0x37,0x3F,0x79,0xAE,0xE6,0xA2,0xD3,0xE6,0xE6,0x37,0xBF,0xC5,0xA9,0xD2,0x50,0x35,0xEB,0x2E,0xA7,0x8A,0x53,0xCD,0xDC,0xBB,0xDC,0x66,0xB5,0xE1,0x52,0x86,0x46,0x93,0xD9,0xB5,0xCE,0x1F,0xCA,0x34,0x6F,0x92,0x3A,0xBF,0x71,0x5C,0xDA,0x45,0xE8,0xFC,0xC0,0x0A,0x6E,0x9B,0xA6,0x0B,0x87,0xCC,0xC8,0x53,0xA9,0x36,0x4C,0x46,0x15,0x73,0x23,0xDA,0x98,0x5C,0x85,0x3D,0x11,0x3C,0x00,0x00};
const uint8_t spTHESE[] PROGMEM ={0xA9,0xF5,0xD6,0x4C,0x89,0xB3,0xC4,0x36,0x36,0xA5,0x4E,0xC6,0x4D,0x98,0xB2,0x8C,0x2A,0xCB,0x30,0x09,0xDB,0x34,0x52,0xEB,0x5C,0xA2,0x63,0xD4,0x4A,0x82,0x70,0xB1,0x8F,0x86,0x23,0xE9,0x21,0x10,0x2A,0x37,0xCF,0xB4,0x67,0xB5,0x28,0x55,0x8F,0x46,0x18,0xB9,0x66,0x36,0xAD,0x2B,0x49,0x91,0x32,0x17,0xF7,0xBE,0xF5,0xD5,0x1B,0x71,0xFA,0x96,0xDE,0x97,0xBE,0x38,0x67,0x0E,0xFD,0xD2,0xFA,0x69,0x2C,0x50,0x3C,0x5F,0xEB,0x7F,0x35,0x09,0x50,0x6F,0x01,0xB8,0x9A,0x38,0x00,0xBF,0x2A,0x39,0xE0,0xAF,0x14,0x03,0xFC,0xCC,0xC2,0x80,0x28,0x5C,0x1F};
//const uint8_t spTHEY[] PROGMEM ={0xA6,0x11,0x51,0x4D,0xB5,0x13,0xAB,0x96,0xBB,0x60,0xB5,0x76,0xE3,0x9A,0xA8,0x55,0x59,0xDD,0x49,0xAA,0x53,0xF0,0x12,0xB5,0xA5,0xB7,0xBA,0xD5,0xA9,0x72,0xCD,0x10,0xF1,0xA5,0xB7,0xBA,0xD5,0xA9,0x4B,0x0F,0x15,0xC9,0xA5,0xB7,0x39,0x5D,0x6E,0x2E,0xEA,0x35,0xA7,0xF4,0x29,0x63,0xD8,0x6C,0xE4,0x32,0x24,0x63,0x12,0xEF,0xB5,0xD2,0x90,0xA4,0x6A,0x4E,0x84,0x0E,0x43,0x0E,0xC4,0xD5,0x19,0xC8,0x0D,0xC9,0x0A,0xE6,0x7A,0x68,0x33,0x06,0xCD,0xD2,0xE5,0x51,0x1E};
//const uint8_t spTHING[] PROGMEM ={0x40,0x00,0x6D,0xDD,0x11,0xE0,0x85,0x3B,0x01,0x9C,0x34,0x16,0x40,0x70,0xA6,0x27,0x89,0xD1,0xD5,0xAD,0x16,0xDE,0xE4,0x24,0xB9,0xB8,0xA8,0xC6,0xE2,0x93,0xD6,0x9E,0x22,0xE2,0x8B,0x4F,0x56,0x67,0x89,0xB0,0xAE,0x3E,0x79,0x5B,0x29,0x2C,0xBA,0xF8,0x54,0x75,0x05,0xB1,0xF9,0xA2,0x51,0xD7,0x69,0xA0,0x1E,0xB3,0x5A,0x5D,0x1A,0x43,0x64,0x54,0x4C,0x4D,0x08,0x60,0xEB,0x6E,0x26,0x34,0xCE,0xC1,0x87,0x39,0x9D,0xD0,0x78,0x07,0x97,0x9A,0x4C,0x42,0x13,0x1C,0x5C,0x68,0x28,0x0D,0x8D,0xB5,0x70,0xA1,0x29,0x27,0x35,0x51,0x39,0x45,0x79,0xC9,0xD0,0xA5,0x60,0xA8,0x6A,0xB3,0x1F};
//const uint8_t spTHINGS[] PROGMEM ={0x00,0x08,0x60,0xBA,0x93,0x01,0xDA,0x99,0x33,0x40,0x5B,0x77,0x03,0x78,0xE1,0xAE,0x00,0x27,0x8D,0x2D,0x70,0xE2,0x18,0x4D,0x8D,0x3A,0xF6,0x89,0x4B,0x76,0x76,0xE9,0x5A,0x37,0xBE,0xF1,0xCA,0xCA,0x0E,0x56,0xCE,0x46,0xB7,0xBE,0xED,0x18,0xCA,0x31,0x56,0xA9,0x9A,0x61,0x34,0x16,0x7B,0x25,0xA9,0xD8,0xC9,0x4E,0x66,0x8A,0x1E,0xA6,0xBC,0x18,0xDB,0xC9,0x4D,0xD1,0xC3,0x94,0x27,0x5C,0x37,0x55,0xA1,0x90,0xB1,0x52,0xEC,0x64,0x26,0x2D,0xD2,0x5C,0x25,0x8D,0x00,0x7E,0x0D,0x93,0x80,0x04,0x38,0xC0,0x81,0x07,0x00,0x00};
//const uint8_t spTHINK[] PROGMEM ={0x08,0xB0,0xD4,0x14,0x01,0x19,0xBB,0x50,0x80,0x03,0x27,0x8E,0xDE,0xDC,0xA5,0x67,0x9F,0x28,0xDA,0x90,0xF0,0x9C,0xB9,0x92,0x3A,0x5B,0x8C,0xAC,0xF3,0xCD,0x6E,0xB5,0xDA,0xB2,0x12,0x55,0xBC,0x65,0x19,0xB5,0x25,0x9F,0x0C,0x27,0x79,0xB4,0x13,0x69,0x83,0x0A,0x35,0x2B,0xC7,0x60,0x80,0xBC,0x4D,0x1D,0x10,0xA3,0x91,0x02,0x8A,0x2F,0x50,0x40,0x89,0x41,0x08,0xB0,0x5E,0xF8,0x01};
//const uint8_t spTHIRD[] PROGMEM ={0x08,0xE0,0x3C,0x9D,0x00,0x92,0x56,0x30,0x40,0x12,0x0F,0x05,0x64,0x6B,0x72,0xFC,0xE4,0x24,0x4B,0x32,0xF3,0x89,0x9D,0xF5,0x4C,0x8B,0xCE,0x23,0x76,0x5D,0x24,0xD3,0xF2,0xCC,0x64,0xA6,0xB3,0xD8,0xED,0xEE,0x46,0x1F,0xA6,0x89,0x94,0xE4,0x9F,0x7D,0x1B,0xE2,0x16,0x95,0x94,0xEE,0x79,0x14,0x23,0xF1,0x61,0x95,0x65,0x8B,0x4D,0xCC,0x84,0xA5,0x4F,0xE2,0x30,0x45,0xA5,0x9A,0x11,0x2D,0xDC,0x54,0x8A,0x06,0x73,0x67,0x44,0x80,0xB2,0x6A,0x0F};
//const uint8_t spTHIRTEEN[] PROGMEM ={0x00,0x60,0x80,0xA6,0x42,0x18,0x60,0x4D,0xD8,0x8A,0x8C,0xCD,0x28,0xD3,0x46,0x27,0x31,0x21,0xBC,0x5A,0xFD,0xAE,0xD4,0xA4,0x90,0x18,0xF3,0x37,0x32,0x53,0x8D,0x63,0xCC,0x6F,0xC9,0xFC,0x56,0x16,0x0F,0xF7,0xA4,0x20,0x66,0x22,0x32,0x2D,0x01,0x10,0x40,0x0A,0xCF,0x04,0x54,0xA3,0x1C,0xFC,0x56,0x47,0x15,0x24,0xF1,0x4A,0x4A,0x72,0x21,0xCB,0xDB,0x23,0x49,0x5E,0xD8,0xBA,0x4A,0x8D,0xAC,0x19,0x65,0xAD,0x2C,0xD5,0x8A,0xE6,0x94,0xB4,0xB2,0xF4,0xA8,0x5B,0x50,0x94,0xC8,0x4A,0xAD,0x6B,0x4E,0x49,0x32,0x2B,0x97,0xBE,0x79,0x25,0xC9,0x2C,0x1D,0x86,0xEC,0x48,0x2C,0x2B,0x94,0x1B,0x83,0x21,0xF3,0x2E,0x29,0x6E,0xD4,0x46,0xAC,0xD3,0xA4,0xB8,0xD9,0x58,0x8C,0x09,0xB5,0x13,0xE6,0x94,0x21,0x4A,0x53,0x8E,0x5B,0x72,0x83,0x70,0x6F,0x25,0x76,0x81,0x07};
//const uint8_t spTHIRTY[] PROGMEM ={0x20,0x80,0x62,0x5D,0x35,0xA0,0x01,0x0B,0x9C,0x38,0x8A,0xB2,0xB4,0x68,0x75,0x12,0xE7,0xDC,0xB3,0x2C,0xCF,0x4A,0x4C,0x51,0xEB,0xD4,0x5C,0x33,0x29,0x89,0x5F,0x10,0x6E,0xD9,0x09,0x57,0x10,0x80,0xE6,0x8C,0x2C,0xB0,0x8A,0x32,0x94,0xD9,0xAA,0xCD,0x68,0xEB,0x0C,0x05,0xB6,0x77,0xBE,0xD3,0x03,0x1F,0xE9,0xF8};
//const uint8_t spTHIS[] PROGMEM ={0xA4,0xE6,0x32,0xB2,0x39,0x65,0xB3,0x9A,0xC9,0x8C,0x92,0x70,0x24,0x1A,0x65,0x42,0x9D,0x2A,0xA3,0x6A,0x8D,0x56,0x0B,0xC8,0x56,0xAA,0x35,0xCA,0x34,0xC8,0x7B,0xBB,0xA6,0x04,0x13,0x55,0x6D,0xD2,0xAB,0x93,0x85,0x20,0xE1,0xDE,0x63,0x77,0xBC,0x92,0xE8,0x25,0xDD,0x6A,0xD5,0x4D,0x77,0x5E,0xF3,0x5A,0x19,0xE0,0x69,0x16,0x0F,0x58,0xC0,0x03,0x1E,0xB0,0x80,0x05,0x2C,0xF0};
//const uint8_t spTHREE[] PROGMEM ={0x0C,0x08,0xCA,0x44,0x02,0x1A,0xB0,0x40,0xC8,0x4D,0x15,0x73,0xCB,0xB4,0x39,0x0F,0xB9,0xE9,0x14,0xE6,0xAD,0xBE,0xE4,0x7E,0x50,0x50,0xA9,0xDF,0x91,0xE5,0x25,0x05,0x21,0x79,0x47,0x5E,0x7A,0x18,0x09,0xBD,0x5F,0x45,0xCB,0xC1,0xA8,0xF6,0x76,0x56,0xAD,0x2D,0x41,0x98,0xB3,0xEF,0xD4,0x2E,0x0C,0x5E,0x89,0xE5,0x66,0x65,0x3F,0xB8,0xC1,0x6B,0xF2,0x9A,0x0E,0x63,0x46,0xAF,0x38,0xAB,0x53,0xCC,0x03};
//const uint8_t spTHREW[] PROGMEM ={0x08,0xB0,0xDC,0x18,0x01,0x41,0xBB,0x50,0x80,0x03,0x16,0x48,0x81,0x6E,0x9C,0x9A,0x92,0x25,0x67,0x35,0x6D,0x89,0x1A,0x52,0x12,0xDA,0x77,0xC4,0x3A,0x4B,0x6B,0xA9,0xAF,0x95,0xD8,0x20,0x15,0x16,0x5E,0x47,0x1A,0xB4,0x7A,0x0E,0xB6,0x9B,0xF9,0xAC,0x5B,0x9F,0x94,0xBA,0x1F,0x66,0x0F,0x83,0x91,0xDE,0xB9,0xD0,0xC6,0x4E,0x7A,0xD6,0x8B,0x5C,0x1E};
//const uint8_t spTHROUGH[] PROGMEM ={0x08,0xB0,0xDC,0x18,0x01,0x41,0xBB,0x50,0x80,0x03,0x16,0x48,0x81,0x6E,0x9C,0x9A,0x92,0x25,0x67,0x35,0x6D,0x89,0x1A,0x52,0x12,0xDA,0x77,0xC4,0x3A,0x4B,0x6B,0xA9,0xAF,0x95,0xD8,0x20,0x15,0x16,0x5E,0x47,0x1A,0xB4,0x7A,0x0E,0xB6,0x9B,0xF9,0xAC,0x5B,0x9F,0x94,0xBA,0x1F,0x66,0x0F,0x83,0x91,0xDE,0xB9,0xD0,0xC6,0x4E,0x7A,0xD6,0x8B,0x5C,0x1E};
//const uint8_t spTIME[] PROGMEM ={0x00,0x1E,0x90,0x80,0x03,0x72,0x28,0x17,0x80,0x9D,0x61,0x1E,0x38,0xB1,0xAF,0x5D,0xE6,0x5E,0xE7,0x26,0x37,0xB9,0xE9,0x4D,0x4F,0x16,0x66,0x96,0x5A,0xC4,0x3B,0x55,0x5A,0x19,0x2A,0x19,0xF7,0x56,0xA7,0xC9,0x3D,0x55,0x35,0xAB,0xEC,0x76,0x76,0xA9,0xB3,0x0E,0xDB,0xC4,0x1A,0xF9,0xDE,0x74,0xDA,0xE1,0x18,0x97,0x5B,0xDB,0xE9,0xCE,0xF4,0xD2,0x71,0x07,0x65,0xD2,0x07};
//const uint8_t spTO[] PROGMEM ={0x02,0xD8,0x51,0x3C,0x00,0xC7,0x7A,0x18,0x20,0x85,0xE2,0xE5,0x16,0x61,0x45,0x65,0xD9,0x6F,0xBC,0xE3,0x99,0xB4,0x34,0x51,0x6B,0x49,0xC9,0xDE,0xAB,0x56,0x3B,0x11,0xA9,0x2E,0xD9,0x73,0xEB,0x7A,0x69,0x2A,0xCD,0xB5,0x9B,0x1A,0x58,0x2A,0x73,0xF3,0xCD,0x6A,0x90,0x62,0x8A,0xD3,0xD3,0xAA,0x41,0xF1,0x4E,0x77,0x75,0xF2};
//const uint8_t spTOGETHER[] PROGMEM ={0x09,0x68,0x22,0xD4,0x00,0x5E,0xA6,0x9E,0x3C,0x25,0x77,0x71,0xED,0x72,0xAA,0x1C,0xC3,0x28,0xB4,0x5F,0x6B,0x72,0x75,0xC6,0x94,0x6C,0xAE,0x4D,0x9D,0x50,0x53,0x57,0x8D,0x2A,0xAF,0x60,0x74,0xDD,0x7B,0xAA,0xD2,0xCB,0x59,0xB9,0xDF,0xA9,0x72,0x76,0x57,0xF3,0x2D,0xA7,0x88,0xC9,0x53,0x35,0x96,0xDC,0x62,0x14,0xCE,0x59,0x07,0xE7,0x62,0xD7,0x46,0xA7,0xEE,0x62,0x49,0x66,0xB7,0xDA,0xEC,0xCD,0xDD,0xA8,0x7B,0x19,0x7C,0xD2,0x62,0xF3,0x65,0x65,0x74,0x31,0x9C,0x32,0xEA,0x86,0x49,0x17,0xF5,0xAC,0x4C,0x66,0x56,0x53,0xD9,0xDB,0xC3,0x89,0x58,0x4D,0x30,0x4B,0x6F,0xCB,0x0F};
//const uint8_t spTONE[] PROGMEM ={0x09,0x98,0xCA,0xD2,0x01,0x4B,0x5B,0x09,0x20,0xC4,0xB2,0x13,0x06,0x53,0x9D,0x22,0x59,0x6F,0xBC,0xE2,0xA0,0x7A,0x9C,0x25,0xED,0x48,0x82,0x9C,0x35,0xD2,0xA6,0x23,0x75,0x72,0x56,0xD9,0x92,0x96,0xCC,0xCA,0x5D,0x35,0x55,0x5A,0x2A,0x23,0xB7,0x2D,0xC8,0x4D,0xAA,0x1D,0xEF,0xF1,0x40,0xD7,0xA9,0xD5,0x76,0xD2,0x8D,0x62,0x87,0x4E,0xA6,0x0E,0x57,0x8E,0x9B,0x7A,0xA7,0xB3,0x82,0xDC,0x9E,0xEA,0x75,0xD5,0x62,0x09,0x3B,0xAA,0xB7,0x81,0x53,0xB9,0xDC,0xEA,0x5E,0xF5,0x2A,0xA8,0x1B,0x77,0x62,0x31,0x48,0xE7,0x6E,0x92,0x69,0xD8,0xC0,0x75,0x7A,0x58,0xBA,0x7E,0x00,0x00};
//const uint8_t spTOO[] PROGMEM ={0x02,0xD8,0x51,0x3C,0x00,0xC7,0x7A,0x18,0x20,0x85,0xE2,0xE5,0x16,0x61,0x45,0x65,0xD9,0x6F,0xBC,0xE3,0x99,0xB4,0x34,0x51,0x6B,0x49,0xC9,0xDE,0xAB,0x56,0x3B,0x11,0xA9,0x2E,0xD9,0x73,0xEB,0x7A,0x69,0x2A,0xCD,0xB5,0x9B,0x1A,0x58,0x2A,0x73,0xF3,0xCD,0x6A,0x90,0x62,0x8A,0xD3,0xD3,0xAA,0x41,0xF1,0x4E,0x77,0x75,0xF2};
//const uint8_t spTOP[] PROGMEM ={0x00,0x10,0x80,0x64,0x43,0x03,0xD0,0x59,0xAA,0x01,0x8A,0x1A,0x1D,0x51,0x30,0xDD,0xC1,0xD6,0xE4,0xC6,0x37,0xB9,0xE9,0xCD,0x6E,0x35,0x5A,0x9B,0xA7,0x02,0xA3,0x31,0x02,0x48,0x48,0x07,0x50,0x80,0x94,0x91,0x1C,0x00,0x80,0x07,0x00,0x00};
//const uint8_t spTRY[] PROGMEM ={0x0E,0x28,0xA1,0xA2,0x02,0x0E,0x28,0x6D,0xCC,0x03,0x2D,0x56,0x23,0x34,0x9A,0xD2,0x8D,0x44,0xA7,0x71,0x6B,0xD8,0x72,0x12,0x6F,0xA6,0xAC,0xB0,0xCB,0x49,0x82,0x9D,0x4A,0x91,0x26,0x37,0xB9,0xE9,0xC9,0x93,0xED,0x0A,0xD5,0xC6,0xB7,0x3A,0x6D,0xCC,0xE1,0xE6,0x3E,0x67,0x77,0xB3,0x9F,0x7D,0x19,0x42,0x51,0x8B,0xE8,0xB0,0x65,0x88,0xC1,0xC5,0x3B,0xC2,0xA4,0x21,0x38,0xB5,0xCC,0x0A,0xEC,0x86,0x54,0x84,0xD4,0x3B,0xF4,0x03,0x00,0x00};
//const uint8_t spTRY_AGAIN[] PROGMEM ={0x0E,0x28,0xA1,0xA2,0x02,0x0E,0x28,0x6D,0x6C,0xC4,0xB6,0xAB,0xA5,0x8B,0xDB,0x15,0xEB,0xEE,0x5E,0xCE,0x6B,0x4E,0xE2,0xED,0x84,0xB9,0x26,0xBE,0xD1,0x0D,0x57,0x10,0x8B,0x9B,0xEB,0x44,0xD9,0xC1,0x0E,0x57,0x1C,0x8B,0x99,0xDB,0x46,0x39,0x69,0x8E,0xA6,0xEE,0x35,0x7B,0x64,0x35,0x26,0xF2,0x44,0xA7,0x94,0xE7,0x24,0x60,0x1B,0x15,0x55,0xCE,0x45,0x66,0x35,0x3B,0x29,0x45,0xD1,0xCC,0x6E,0xE1,0x66,0x64,0xD5,0x39,0x53,0x74,0x9B,0x13,0xE7,0xE0,0xAC,0x55,0xB3,0x4F,0x5C,0x5D,0x98,0x45,0xCC,0xBE,0xD1,0x8D,0x6E,0x72,0xF3,0x5B,0xAD,0x36,0x46,0x4F,0x95,0x8C,0x32,0xFB,0xDE,0x87,0xDE,0x66,0x35,0xD7,0x70,0xE5,0x06,0x4F,0x53,0xCC,0xBC,0x95,0x1A,0xA4,0xD5,0x08,0x19,0xC7,0x0F};
//const uint8_t spTURN[] PROGMEM ={0x0A,0xE8,0x3A,0x35,0x02,0x02,0xF0,0x39,0x84,0x00,0x22,0xB5,0x9C,0x28,0xEA,0x31,0x5E,0x57,0x77,0xA3,0x1B,0xDF,0xE4,0x66,0xAB,0x88,0x7E,0x05,0x27,0xB8,0xCF,0x6A,0x54,0xB1,0x0C,0x73,0xAB,0xF6,0x59,0xF7,0x3A,0x35,0x29,0x40,0x4B,0x58,0xE2,0xDC,0xD4,0x36,0xB5,0xD1,0x41,0x6B,0x59,0xAC,0xDC,0x3E,0x00,0x00};
//const uint8_t spTWELVE[] PROGMEM ={0x0C,0x70,0x33,0x5D,0x01,0xAE,0x64,0x84,0x80,0xD5,0x5E,0x11,0xDA,0x1A,0x93,0x95,0x9A,0x98,0x95,0xE4,0x6D,0x6F,0xBA,0xD3,0x9B,0xAE,0x5C,0xA7,0x49,0xC7,0x4A,0xB2,0x8B,0x5D,0xED,0x7A,0xD4,0x3A,0x4C,0x1B,0x59,0xE6,0x59,0xF7,0x26,0x35,0xDA,0x65,0x0B,0x4B,0x1C,0xD3,0x48,0x93,0x21,0x6A,0x6A,0x4B,0x9B,0x4D,0x98,0xA2,0xD9,0x51,0x80,0xB3,0xA9,0x0C,0x30,0x21,0x91,0x00,0xD2,0xA7,0x3E};
//const uint8_t spTWENTY[] PROGMEM ={0x0A,0x30,0x21,0xDC,0x03,0x0A,0xD0,0x51,0x1D,0x56,0xA4,0xF3,0x94,0x98,0xE5,0x39,0x69,0x0C,0x95,0xEA,0xDC,0xE4,0xA4,0x39,0x85,0x9B,0xD9,0xDC,0x93,0x96,0x1A,0xEE,0x98,0xF5,0x5A,0x61,0xBD,0xBA,0xC9,0x59,0x31,0x85,0x12,0xAE,0xE3,0x66,0x4B,0x54,0xD9,0x1B,0x67,0xB8,0xD3,0x00,0x14,0x13,0xEC,0x80,0x6C,0x93,0x4A,0x9C,0x87,0x93,0x50,0x34,0x6E,0x75,0xAA,0x10,0x32,0x17,0x25,0xF5,0x65,0xA2,0x51,0xCD,0xEC,0x30,0xC4,0x88,0x5C,0x53,0x81,0xED,0xF8};
//const uint8_t spTWO[] PROGMEM ={0x02,0xD8,0x51,0x3C,0x00,0xC7,0x7A,0x18,0x20,0x85,0xE2,0xE5,0x16,0x61,0x45,0x65,0xD9,0x6F,0xBC,0xE3,0x99,0xB4,0x34,0x51,0x6B,0x49,0xC9,0xDE,0xAB,0x56,0x3B,0x11,0xA9,0x2E,0xD9,0x73,0xEB,0x7A,0x69,0x2A,0xCD,0xB5,0x9B,0x1A,0x58,0x2A,0x73,0xF3,0xCD,0x6A,0x90,0x62,0x8A,0xD3,0xD3,0xAA,0x41,0xF1,0x4E,0x77,0x75,0xF2};
//const uint8_t spTYPE[] PROGMEM ={0x02,0xC8,0xCA,0xDC,0x03,0x06,0x48,0x36,0xBC,0xC4,0xD9,0xA4,0xA5,0x4A,0xAC,0x93,0xBA,0x52,0x19,0x5C,0x51,0x4F,0x1A,0x53,0x65,0xB2,0xCF,0x39,0x59,0xAC,0x91,0xC1,0xD5,0xE4,0x14,0x69,0x84,0xB9,0x66,0x9D,0x55,0xE5,0x69,0xAA,0xDA,0x75,0x47,0x53,0xBA,0xA8,0x59,0x55,0x0D,0x6D,0x48,0x6C,0xEE,0x71,0x19,0x00,0x10,0x40,0x72,0x05,0x02,0x64,0x8C,0x44,0x80,0x8E,0xA9,0x08,0x50,0x29,0xF4,0x01,0x00,0x00};
//const uint8_t spU[] PROGMEM ={0xA5,0xDA,0x0D,0x98,0x23,0x6F,0xF4,0x6A,0x55,0x33,0xA9,0x82,0xC6,0xEB,0x91,0xF5,0x68,0x02,0x11,0x5B,0x67,0x36,0x32,0x2B,0xA2,0x24,0x75,0x75,0xCF,0x7B,0xD5,0x9B,0xD6,0x5A,0x61,0xE5,0x49,0xDD,0x6A,0x97,0xFB,0xD8,0xFB,0x5E,0x77,0xA2,0xB3,0x2C,0x45,0x25,0x8D,0x3C,0x00,0x00};
//const uint8_t spUHOH[] PROGMEM ={0x2B,0xB5,0x31,0x46,0x3C,0x6D,0x9D,0x38,0xB8,0x6A,0xE7,0x5C,0x7C,0x7C,0x53,0xCA,0xCD,0xD7,0xEA,0x76,0xBA,0x45,0x00,0xAD,0xAB,0x00,0x10,0x20,0x6A,0x46,0x08,0xBC,0xCB,0x31,0xB5,0x3A,0x2B,0xF7,0x3A,0x37,0x9C,0xBA,0xDD,0xE2,0x56,0xB7,0xBA,0xD5,0xAA,0x8C,0xAA,0x0B,0xC7,0xB4,0xB3,0x1A,0x95,0x56,0xFD,0x62,0x92,0xB6,0x55,0x8E,0xF5,0x9B,0x29,0xFB,0x52,0xC9,0x38,0x1E,0x46,0x4E,0x44,0xC5,0x9B,0xB7,0xB1,0xC9,0x79};
//const uint8_t spUNDER[] PROGMEM ={0xA7,0xC8,0x3A,0xAB,0x54,0x9A,0xDE,0xE2,0x16,0xA7,0x48,0x3E,0x4B,0xC9,0xE7,0x94,0xC2,0x04,0x49,0xB2,0xF4,0x1D,0x33,0x9F,0xBB,0x4A,0x7A,0x29,0xD7,0x89,0x6D,0x2A,0x66,0xC3,0xD2,0x7D,0x61,0x69,0x5B,0xB5,0x22,0x66,0x39,0xB7,0x3E,0x6D,0x4C,0xE1,0x64,0xD6,0x7E,0x74,0x2E,0xBB,0xC8,0x46,0xF2,0xDE,0xD7,0x31,0x8C,0xAE,0xB1,0x44,0x5B,0x56,0x37,0x9A,0x81,0x5E,0x1D,0x8E,0xDD,0xE8,0x87,0x92,0x46,0xBA,0x56,0x63,0x9C,0x21,0x28,0xA2,0xF6,0x01,0x00,0x00};
//const uint8_t spUNDERSTAND[] PROGMEM ={0xAB,0xF0,0xC9,0x8F,0xA3,0x1C,0x9F,0xCA,0xA7,0x2A,0xD5,0xA8,0x73,0xAB,0x53,0xA5,0xD0,0xA1,0xE4,0x4D,0x52,0xA5,0x83,0x06,0x45,0x36,0x09,0x95,0x08,0xDA,0xE6,0xED,0xD0,0x54,0xB8,0x7A,0xB4,0xA5,0xC4,0xD2,0x44,0xAD,0xCA,0x16,0x71,0x5A,0xED,0xAB,0x09,0xB7,0xA7,0x9F,0xF5,0x6C,0x46,0x13,0xA6,0x2B,0xA6,0x79,0x4B,0x40,0xE7,0xA0,0x01,0xF8,0x49,0x35,0x02,0x0E,0xF8,0xD1,0x58,0x00,0xDF,0x30,0x82,0x00,0x78,0xF1,0x5A,0xB1,0x8F,0x6E,0xE6,0x13,0xF7,0xE4,0x31,0x87,0xA9,0x4D,0xD3,0x9B,0xEF,0x62,0x56,0xB3,0x1A,0x8D,0x2F,0xE6,0xE6,0x6D,0xB9,0xF7,0xA5,0xB7,0xCD,0xD4,0xAD,0xAD,0xD4,0x3E,0xF4,0xD6,0x51,0x9B,0x95,0x66,0xDF,0x9B,0x9E,0x79,0x9B,0x92,0x92,0x9C,0x7B,0xD7,0x63,0x5F,0x99,0xE6,0x32,0xC3,0x50,0x94,0x8B,0x78,0x6C,0xB0,0xC3,0x03,0x00,0x00};
//const uint8_t spUNTIL[] PROGMEM ={0xA7,0x72,0xBE,0xDA,0x25,0xEB,0x9C,0x2A,0xB8,0x2A,0xE7,0xAA,0x7D,0xAB,0x56,0x19,0xA7,0x6E,0x6A,0xCD,0x72,0x95,0xAB,0x54,0x5B,0x8B,0x6D,0x9E,0x9A,0x6D,0x2B,0xFA,0x60,0x4D,0x43,0xD4,0x71,0x02,0xAA,0x4A,0x49,0xC0,0x92,0x29,0x02,0x90,0x3E,0x72,0x25,0xC9,0xB9,0x98,0xFB,0x93,0x9B,0xDC,0x74,0x65,0x31,0x86,0xA9,0xD9,0x93,0x95,0x7B,0xEF,0xE5,0xEA,0x6B,0x56,0x65,0x5D,0x8C,0x6B,0x74,0x4A,0x35,0x9F,0x3D,0x42,0x9D,0x2A,0x37,0xB1,0x0D,0x2D,0xDF,0xDD,0x2C,0x99,0xDA,0xB5,0xEC,0x74,0x18,0x96,0x63,0xD5,0xD2,0x3B,0x6C,0x92,0xB1,0x55,0x4B,0xDB,0xA6,0x41,0x39,0x79,0x00,0x00};
//const uint8_t spUP[] PROGMEM ={0x2B,0xB1,0x29,0x47,0xBC,0x1A,0xDF,0x6C,0x65,0xA6,0xD4,0x88,0x4E,0xE3,0x5D,0xB4,0x4A,0xE5,0x5A,0x97,0x6C,0xED,0x2B,0x00,0x60,0x40,0x4C,0xAE,0x08,0x50,0xCE,0x0D,0x03,0x0F,0x00,0x00};
//const uint8_t spUPPER[] PROGMEM ={0x27,0xCF,0x2E,0xD6,0x55,0xF2,0x9C,0xCC,0x85,0x1A,0xF6,0x4C,0xD5,0x32,0x55,0x73,0xA8,0xCA,0x36,0x00,0x01,0x48,0x6C,0x77,0x40,0x4C,0x6E,0x29,0xB3,0x8B,0xCA,0x5D,0xD6,0xF6,0xAA,0xD5,0x76,0x63,0xA4,0xC9,0xE2,0xDA,0xA6,0xCE,0x2E,0xD2,0x4A,0x5E,0x1C,0x7A,0x33,0xB1,0x5A,0xBD,0xA6,0x1B,0xDC,0x60,0xA9,0x90,0x94,0x0F,0x00,0x00};
//const uint8_t spUSE[] PROGMEM ={0xAD,0x3A,0x3D,0x03,0x80,0xB7,0xAD,0xA2,0xB7,0x49,0x60,0xCE,0x7F,0x8A,0x9E,0xD2,0xC0,0xB8,0xFF,0x2D,0x4E,0x51,0xAD,0x29,0x27,0xEF,0x9B,0xC5,0xAC,0x5A,0x55,0x99,0xB4,0xA6,0xF4,0xEB,0xD5,0xAC,0x66,0xDD,0x9B,0xD2,0x38,0xE1,0xA1,0x2E,0x8F,0x6B,0x43,0x00,0xA4,0x3F,0x04,0xB0,0x0D,0x82,0x00,0x7E,0x53,0x60,0xC0,0xF7,0x2C,0x0C,0x38,0x16,0xED,0x01,0x00,0x00};
//const uint8_t spV[] PROGMEM ={0xA5,0x4A,0x3E,0x44,0x58,0x9D,0xAD,0xAA,0xA4,0x10,0x56,0x69,0x7A,0x8B,0x5B,0x9C,0xA2,0x95,0x20,0xD4,0x78,0xBA,0x8A,0x96,0x9C,0xC8,0xF3,0xE9,0xA8,0x5A,0x76,0xC4,0xA8,0xA7,0xA3,0x6A,0xD1,0x11,0x33,0xEF,0xB4,0xBA,0x07,0x23,0xAA,0xBA,0xDD,0x9A,0x16,0x14,0x29,0xEB,0x4E,0x68,0x6A,0x14,0x94,0xAA,0x29,0x0F,0x00,0x00};
//const uint8_t spVARY[] PROGMEM ={0xA6,0xD5,0xDA,0x4C,0x39,0xB2,0xA6,0x2E,0xB8,0x08,0x15,0xDB,0x7C,0xAB,0x53,0xD8,0x14,0xEE,0x3E,0x8D,0x6F,0x7E,0xD3,0x9B,0x9E,0x2C,0xA4,0xD4,0x70,0x5B,0xBD,0x2A,0xD7,0x5D,0xC3,0x6D,0xCD,0x6D,0x5A,0x6B,0x16,0x57,0x98,0xB4,0xE9,0xDD,0xE8,0xFD,0x56,0xD7,0xE4,0xEE,0x6D,0x48,0x9D,0x52,0x22,0xDA,0x96,0x29,0x36,0x61,0xAB,0x78,0x93,0xC6,0xA4,0x8D,0xB5,0x6A,0x4E,0x1C,0xDD,0x94,0xBC,0x81,0x76,0x57,0xD6,0x93,0x9E,0xF4,0xF8};
//const uint8_t spVERY[] PROGMEM ={0xAE,0x31,0xC6,0x8D,0x4C,0x36,0x95,0x26,0x3B,0x57,0x75,0xDF,0x7A,0xF3,0x9B,0xDF,0xFC,0x64,0xC9,0xBB,0xAA,0x67,0xD7,0x93,0xA7,0x14,0x2A,0x61,0xF9,0x4E,0xE1,0x87,0xB3,0x07,0xE7,0xDB,0xD5,0xAE,0x57,0xEB,0x67,0x88,0x06,0x67,0x5F,0x5D,0xE8,0x2E,0x1A,0xD2,0x7D,0x0E,0x65,0x88,0x49,0x45,0xC7,0x5F,0x97,0x31,0x79,0x65,0x8B,0x5C,0x95,0xA7,0x3C,0x3D,0x00,0x00};
//const uint8_t spW[] PROGMEM ={0xAC,0xC1,0xAA,0xA2,0xB2,0x1C,0x0F,0x67,0x98,0x08,0x56,0x4F,0x77,0x0A,0x5B,0xD5,0xA3,0xBA,0xD5,0xC8,0x74,0xB7,0xF4,0xDA,0x58,0x23,0x55,0x2D,0xD3,0xAC,0x67,0xC6,0xD4,0xE4,0xC2,0x7F,0xA8,0x7A,0xCB,0x5E,0x8C,0x4A,0xA9,0x6D,0x73,0xE9,0x35,0x2A,0xAB,0x33,0x2D,0xF0,0xCF,0x6A,0xAA,0xF1,0xE4,0x20,0xFF,0xAD,0x9D,0x9E,0x1C,0xB5,0x5B,0xF7,0x2E,0xF5,0xC5,0xAB,0x42,0xFB,0xEB,0xDE,0xB7,0x3E,0x15,0x61,0x29,0xDB,0x53,0x86,0x98,0x54,0xE4,0xE4,0x4B,0x19,0xAC,0x75,0xD7,0x95,0xCF,0x61,0xD0,0xD6,0xDD,0x47,0x76,0xBB,0x51,0x86,0xD4,0x32,0xDB,0x6D,0x46,0xA5,0xDB,0x3A,0xD4,0xAF,0x19,0x9D,0x71,0x99,0x54,0x37,0xAA,0xF5,0x5A,0xA5,0x5C,0x94,0x3C};
//const uint8_t spWAIT[] PROGMEM ={0xA6,0x61,0xB6,0x5E,0x14,0xDD,0xB8,0x9A,0xF9,0x7E,0x16,0xF2,0xE3,0x2A,0x56,0x7B,0x45,0x68,0x6B,0x2B,0x94,0x8F,0x0D,0xE3,0x2D,0x27,0x8F,0xD1,0xDC,0x43,0xB6,0x9C,0x22,0x66,0x35,0xF3,0x9C,0x73,0xAA,0x1C,0x94,0xB5,0x72,0xF6,0xAC,0x7B,0xEB,0x7A,0x6B,0x38,0xB2,0x3A,0x8C,0xEE,0x01,0x00,0x1C,0x50,0x99,0x87,0x02,0x9A,0x2A,0x79,0x00,0x00};
//const uint8_t spWANT[] PROGMEM ={0xA1,0x56,0x3C,0xDE,0x99,0x2D,0xBB,0x9A,0xDB,0x7D,0x47,0x4A,0xDC,0x6A,0x11,0xFE,0x0D,0xA4,0xED,0xA8,0x8C,0xFE,0x55,0xD2,0x66,0xBB,0x3A,0x55,0x54,0x33,0xC1,0xD2,0xE6,0xD6,0xB7,0x59,0xAD,0x8B,0x93,0xC6,0x5E,0xA7,0x77,0xA9,0xB3,0x25,0x34,0xA4,0xA2,0xA4,0xCE,0xAB,0x30,0x33,0x75,0x1A,0x7B,0x00,0x07,0x78,0xE5,0x24,0x01,0x78,0x00,0x00};
//const uint8_t spWANTS[] PROGMEM ={0xAA,0xC2,0xB1,0x5F,0xD1,0xE5,0xA6,0x9A,0xFB,0x7A,0x07,0x49,0xD7,0x2A,0xE9,0xEB,0x0D,0x34,0xEF,0xA8,0x8C,0xC9,0x77,0xF0,0xB6,0xAD,0x30,0xBE,0x5F,0xB0,0x1A,0xCD,0x7C,0x14,0x66,0x8D,0x48,0xA4,0xD9,0x5E,0xF5,0x26,0xB5,0x66,0xB4,0xB2,0x95,0xD9,0xD0,0xDA,0xAB,0xA6,0x9E,0x8A,0x4D,0xA7,0x62,0x71,0x70,0xDB,0x62,0xB9,0xB3,0xAA,0x41,0x9E,0x14,0x80,0x00,0x41,0xB8,0x0A,0x60,0xB2,0x0C,0x01,0xFC,0x6E,0xCE,0x80,0x3F,0x4C,0x08,0xF0,0x8D,0x2A,0x02,0x3E,0x17,0x7F,0x00,0x00};
//const uint8_t spWAY[] PROGMEM ={0xAA,0xC1,0x69,0x2A,0xD4,0x98,0xB8,0x9A,0xB9,0x7E,0x55,0x56,0x52,0x6A,0x69,0xEA,0x85,0x31,0xEB,0xAA,0xB4,0xCE,0x37,0x92,0xBC,0xA7,0xB2,0x2E,0x47,0x54,0xB7,0x9C,0x22,0x67,0x73,0xD3,0x58,0x7A,0xF3,0x53,0x94,0xEC,0x6C,0x5E,0x8B,0x6F,0x75,0xAB,0x5B,0xDF,0xE6,0x74,0x2D,0x3A,0x49,0xE4,0xE2,0xDD,0x8D,0xBE,0xE7,0x20,0xF2,0x7A,0xD5,0xFA,0x5A,0x84,0x34,0x66,0x52,0xEA,0x4B,0x64,0x8C,0x9C,0xC2,0xAE,0xF7,0x5C,0x75,0xC6,0x83,0xA8,0x5E,0x73,0xB7,0x6B,0x15,0xAB,0x7A,0xA3,0x38,0xCE,0xDC,0xAA,0xE8,0x8C,0x34,0x6A,0x33,0xA7,0x0F};
//const uint8_t spWE[] PROGMEM ={0xAC,0xC5,0x63,0x23,0x90,0x9D,0xC8,0x36,0xB5,0xD2,0x77,0x89,0x50,0x9F,0x55,0xA7,0xC0,0x9C,0x5D,0x33,0x77,0x3D,0xEA,0xE6,0x8D,0x61,0x7A,0xF2,0xAC,0x67,0x35,0xAB,0x59,0x8F,0xA6,0x55,0x63,0xB0,0xBA,0x93,0x1B,0xDD,0xC8,0xC6,0xB4,0xC9,0x81,0x75,0x95,0x99,0x07};
//const uint8_t spWEIGH[] PROGMEM ={0xAA,0xC1,0x69,0x2A,0xD4,0x98,0xB8,0x9A,0xB9,0x7E,0x55,0x56,0x52,0x6A,0x69,0xEA,0x85,0x31,0xEB,0xAA,0xB4,0xCE,0x37,0x92,0xBC,0xA7,0xB2,0x2E,0x47,0x54,0xB7,0x9C,0x22,0x67,0x73,0xD3,0x58,0x7A,0xF3,0x53,0x94,0xEC,0x6C,0x5E,0x8B,0x6F,0x75,0xAB,0x5B,0xDF,0xE6,0x74,0x2D,0x3A,0x49,0xE4,0xE2,0xDD,0x8D,0xBE,0xE7,0x20,0xF2,0x7A,0xD5,0xFA,0x5A,0x84,0x34,0x66,0x52,0xEA,0x4B,0x64,0x8C,0x9C,0xC2,0xAE,0xF7,0x5C,0x75,0xC6,0x83,0xA8,0x5E,0x73,0xB7,0x6B,0x15,0xAB,0x7A,0xA3,0x38,0xCE,0xDC,0xAA,0xE8,0x8C,0x34,0x6A,0x33,0xA7,0x0F};
//const uint8_t spWEIGHT[] PROGMEM ={0xA6,0x61,0xB6,0x5E,0x14,0xDD,0xB8,0x9A,0xF9,0x7E,0x16,0xF2,0xE3,0x2A,0x56,0x7B,0x45,0x68,0x6B,0x2B,0x94,0x8F,0x0D,0xE3,0x2D,0x27,0x8F,0xD1,0xDC,0x43,0xB6,0x9C,0x22,0x66,0x35,0xF3,0x9C,0x73,0xAA,0x1C,0x94,0xB5,0x72,0xF6,0xAC,0x7B,0xEB,0x7A,0x6B,0x38,0xB2,0x3A,0x8C,0xEE,0x01,0x00,0x1C,0x50,0x99,0x87,0x02,0x9A,0x2A,0x79,0x00,0x00};
//const uint8_t spWELL[] PROGMEM ={0x80,0x12,0xD4,0x26,0x55,0x4D,0x89,0xAE,0x42,0x45,0x5B,0x0F,0xB2,0x67,0x6E,0xB9,0x48,0xF5,0x2A,0xDA,0xE7,0x64,0xC6,0x7B,0xB7,0x46,0xEB,0x9B,0xDD,0xF4,0x66,0xB7,0x58,0x95,0x4E,0xB9,0x2E,0x13,0xA7,0x35,0x72,0x4E,0xBA,0x46,0x95,0xDE,0xF6,0x2E,0x75,0xFC,0x4E,0xB2,0x69,0xAA,0xD8,0x9B,0x9E,0xDD,0x0E,0xF4,0x74,0x65,0x7A,0x76,0x5B,0x54,0xCA,0xF1,0x03};
//const uint8_t spWERE[] PROGMEM ={0xA2,0xC6,0x61,0x3A,0xD4,0x18,0xBB,0x9A,0xF9,0x7E,0x65,0x74,0x9A,0x6A,0x61,0xEB,0x43,0x21,0xFD,0xAA,0xAD,0xCA,0x8E,0x00,0xE7,0xAB,0xB6,0xCE,0xA3,0x86,0x9D,0xAF,0x5A,0xE5,0x88,0x48,0xCA,0xBE,0x2A,0x93,0x93,0xA3,0xC4,0xFF,0xAC,0x46,0xE5,0x72,0x93,0xAC,0x6B,0x9F,0x55,0xAF,0x7A,0xD5,0x2A,0xD7,0x9A,0x64,0x5C,0xFB,0xA8,0xFD,0x68,0x96,0x12,0xED,0xA5,0xF1,0x23,0x48,0x9B,0x3D,0xBB,0xD6,0xBB,0x20,0x0A,0x53,0xA3,0xBA,0x10,0x92,0x89,0x53,0x95,0x68,0xA3,0x0E,0x53,0x0B,0xC7,0x0F,0x00,0x00};
//const uint8_t spWHAT[] PROGMEM ={0x26,0xA4,0xE3,0x93,0x54,0x93,0xA4,0x44,0xD9,0x3F,0x11,0x4D,0xDB,0x12,0xED,0x7E,0x4C,0xB4,0xEE,0x48,0x4D,0xDC,0x32,0xC9,0x24,0x3B,0x1B,0x85,0x2F,0xE3,0x2E,0xD1,0xE4,0x56,0xB5,0xD5,0x3D,0x28,0xC0,0xB3,0x0A,0x0B,0x50,0xE0,0x01};
//const uint8_t spWHAT_WAS_THAT[] PROGMEM ={0x00,0xA9,0x62,0xAD,0x1F,0x38,0x3A,0x9F,0x4A,0x87,0x7C,0x12,0x6D,0x73,0x2A,0xE7,0xE3,0x4D,0x3D,0xF5,0x29,0x6C,0xCF,0x64,0xAF,0xC4,0x37,0x6F,0x55,0xD0,0x69,0x92,0xEA,0x24,0x00,0x59,0x85,0x1B,0x20,0x84,0x34,0x06,0xF8,0xEC,0x82,0x00,0xED,0xCC,0x52,0xC1,0x6A,0x46,0x6A,0x26,0x3E,0x75,0x54,0x99,0x62,0xD2,0x7D,0x34,0x45,0x44,0xB1,0x72,0x7E,0x07,0x68,0x5C,0xE3,0x00,0x0F,0x6C,0x0D,0x50,0x00,0x19,0x01,0x34,0x71,0x76,0x45,0x8B,0x13,0x66,0x22,0x77,0x54,0xDE,0xBB,0xAB,0xF2,0xEA,0x53,0xF9,0x10,0x61,0x6A,0x6F,0x4E,0xE5,0x9A,0x87,0xC6,0x4C,0x39,0x45,0x8C,0x65,0x66,0xFE,0x78,0x65,0x3E,0xA7,0x7A,0x44,0xE9,0x95,0x85,0x5C,0xEA,0x1E,0x95,0x47,0x11,0x4B,0x99,0x69,0x4C,0x01,0x07,0x0C,0x13,0xA1,0x81,0x07,0x00,0x00};
//const uint8_t spWHEN[] PROGMEM ={0x25,0x95,0xE1,0x9A,0xCC,0x56,0x8D,0xC4,0xA5,0x0E,0x15,0xBD,0xB3,0x92,0xD8,0xDC,0x55,0xBB,0xEA,0x4E,0x76,0x7A,0xF3,0x5B,0xDD,0x66,0x75,0xA9,0x65,0x09,0x7B,0xEB,0xD0,0x9B,0xA8,0xC6,0xD4,0xA9,0xE2,0x10,0x07,0x3F,0x98,0xC1,0x59,0x6C,0xB1,0x76,0x6D,0x47,0x3B,0x3E,0x00,0x00};
//const uint8_t spWHERE[] PROGMEM ={0x00,0x29,0x63,0xB5,0x57,0x58,0xD3,0x8E,0x4C,0xC7,0x6C,0x55,0xEB,0xBB,0xB2,0x98,0x5D,0xD5,0x75,0xCF,0xCD,0x77,0xB1,0xAB,0x5B,0x9F,0x26,0x96,0x64,0x2D,0xCB,0xB7,0xBB,0xD1,0x87,0xE1,0xE2,0x25,0x7D,0x67,0xDF,0x06,0xDF,0x55,0xA2,0xB5,0x4B,0x1A,0xFC,0xA4,0xA8,0xD0,0x45,0x6E,0x08,0x17,0x33,0x24,0x67,0xBA,0x21,0x6C,0x15,0xD5,0x70,0xAC,0x86,0xB8,0xC4,0x04,0xC5,0xE9,0x03};
//const uint8_t spWHICH[] PROGMEM ={0x0C,0x50,0xC9,0x53,0x01,0x26,0xBB,0x6B,0x20,0x45,0x3C,0x74,0x89,0x71,0x9A,0x1A,0xAD,0x38,0x78,0x57,0xEB,0x58,0xBA,0x93,0x9B,0x8F,0x2A,0x26,0x27,0xCF,0x98,0x2D,0x2B,0x00,0x30,0xC0,0xDD,0xED,0x1A,0xD0,0x80,0x06,0x24,0x20,0x81,0x07,0x00,0x00};
//const uint8_t spWHITE[] PROGMEM ={0x08,0x30,0xD5,0x0D,0x4A,0x2A,0xD2,0xBC,0x12,0xA7,0x1A,0xA9,0xF6,0xF9,0xCE,0xDC,0x66,0xA5,0x36,0xD5,0x0B,0x47,0xDB,0x93,0xBA,0x5A,0x6B,0xE2,0x4D,0x4F,0x1A,0x7A,0xB6,0x4B,0x34,0x39,0x59,0x1A,0x99,0x26,0xDA,0xF4,0x14,0x75,0x84,0xA9,0x79,0xDA,0x5B,0xA7,0x36,0x05,0x96,0x88,0x2A,0x0B,0x00,0x40,0x00,0x56,0x5B,0x1C,0xD0,0x74,0x19,0x03,0xB8,0x4F,0x7B};
//const uint8_t spWHO[] PROGMEM ={0x00,0x08,0x50,0x31,0x15,0x01,0x5A,0x35,0x1B,0x40,0xD9,0x96,0x92,0xF0,0x18,0x19,0xE2,0x89,0x56,0xE4,0x64,0xA4,0xBB,0xE6,0x19,0x91,0x11,0x59,0x11,0x9A,0xBB,0xC5,0x46,0x64,0x6B,0xF0,0x96,0x9E,0x94,0xCC,0x13,0x1F,0x2B,0xCA,0x5E,0xAB,0xDA,0xD4,0x36,0x74,0x86,0x57,0x89,0x63,0x7F,0xD7,0x0B,0x3D,0x29,0xCE,0x6B,0xD4,0x40,0xCA,0xB8,0x9A,0x37,0x56,0xA3,0xD4,0xE5,0xA6,0x6A,0xE7,0x01};
//const uint8_t spWHY[] PROGMEM ={0x0C,0x10,0x21,0x82,0x01,0xD2,0x77,0x26,0x3C,0x6B,0xAA,0x13,0xB1,0x72,0x72,0xE3,0xF2,0x1D,0xA5,0xCD,0xC9,0x9C,0xCD,0x77,0x92,0x35,0x27,0x77,0xBE,0x4F,0x29,0x9A,0xEC,0xE2,0x56,0xB7,0x3A,0xB5,0x8F,0x5D,0x66,0x96,0xF4,0x76,0xA7,0x8B,0xD9,0xCB,0xCD,0x9A,0xDC,0x7E,0xF5,0xA9,0xBA,0x99,0xE7,0x94,0xD9,0x8F,0x21,0x15,0x53,0xAD,0xAC,0xD2,0x86,0x14,0xD9,0xDD,0x27,0x48,0x1A,0xB2,0x67,0x8D,0xCA,0x40,0x6E,0x28,0x8D,0xC8,0xAC,0xCA,0x02,0x00,0x90,0x2E,0x98,0x74,0xB7,0x74,0xF3};
//const uint8_t spWILL[] PROGMEM ={0x2C,0xC5,0xA1,0x2B,0x3D,0x64,0x89,0x06,0x95,0xE9,0x10,0xA3,0x65,0x2A,0xE6,0xE6,0x99,0x31,0x69,0xA9,0x85,0xA9,0x37,0xC1,0xAE,0xAB,0x32,0x36,0x9B,0x4D,0xF7,0x9D,0xCA,0x59,0xF7,0x94,0x9A,0x7D,0x8B,0x5B,0xAC,0xCA,0x9A,0x4E,0x97,0xB8,0xBD,0xAB,0x5D,0x8F,0xC6,0xD8,0x5A,0x87,0x6C,0x3A,0xDB,0xDE,0x96,0x56,0xC4,0x59,0xA3,0x70,0xE2,0x5A,0x76,0xBB,0x18,0xCB,0x9E,0xEB,0xD8,0xE9,0x44,0x0D,0xC7,0xA6,0x63,0xB3,0x8B,0x38,0x1D,0xAB,0x8E,0xDB,0x29,0x17,0xA7,0xFD};
//const uint8_t spWITH[] PROGMEM ={0xA6,0x65,0xAE,0xCF,0x14,0x6C,0xDB,0x36,0x36,0xA5,0x32,0x3C,0xDE,0x0D,0x94,0xAF,0xCA,0x8A,0x1C,0x11,0x4B,0xBF,0x72,0x63,0x3C,0xA3,0xAC,0xCB,0xCA,0x9D,0xB1,0x88,0x8B,0x99,0xB3,0x98,0xD5,0x6C,0x72,0x8B,0x00,0xAE,0x5D,0x08,0xE0,0x8D,0x0B,0x01,0x82,0x72,0x25,0x40,0x54,0x6E,0x04,0x88,0xDA,0x8D,0x01,0xD6,0xBA,0x3D,0x00,0x00};
//const uint8_t spWON[] PROGMEM ={0xA6,0xA5,0x36,0xDF,0x89,0xEC,0xA5,0x86,0xDB,0xF9,0x42,0x56,0x9A,0x2A,0xE1,0xFB,0x0B,0x38,0x7D,0x6F,0x46,0x63,0x7C,0x9D,0x62,0x25,0x9E,0xCD,0x28,0x5C,0xAC,0x32,0xEA,0x38,0xBB,0x1A,0x4D,0x88,0x56,0x2A,0x53,0x67,0x76,0x79,0x70,0x83,0xF3,0x94,0x6C,0xE9,0xD6,0x0C,0xCE,0x61,0x8A,0xB4,0x3B,0x36,0xCA,0x20,0x1A,0xDC,0xAD,0xCD,0x28,0x8D,0x78,0x7B,0x5B,0x26,0x93,0x10,0x6A,0x95,0x9E,0xDA,0x4C,0x25,0x85,0x9A,0x5A,0x9A,0x07};
//const uint8_t spWORD[] PROGMEM ={0xA1,0x61,0x76,0xDF,0x80,0xE3,0xA7,0x8A,0xDE,0x74,0xB2,0xC8,0x5D,0x2A,0x7E,0xC5,0xDC,0xB2,0x67,0x29,0xF8,0x72,0xC9,0x90,0x4E,0xA5,0x90,0x35,0x25,0x87,0xB3,0xD4,0xA2,0x56,0xAD,0xB2,0x25,0x30,0x96,0xF3,0xF4,0x66,0x34,0x21,0x37,0x71,0x9B,0xFE,0xD9,0xAE,0x36,0xC6,0x66,0x4A,0xD7,0xBF,0xDA,0x14,0x5A,0xD0,0xCB,0x7D,0x69,0xE3,0x0C,0xC6,0xB0,0xE4,0xAA,0xA5,0x51,0xB5,0x63,0x64,0xEB,0x4E,0x74,0x24,0xB8,0x46,0xB7,0x2D,0xDD,0xEB,0x9E,0xF7,0x00,0x00,0xA4,0x49,0x26,0x2D,0x4C,0xEC,0x3C};
const uint8_t spWORDS[] PROGMEM ={0xAA,0xC0,0x71,0xAA,0xD4,0xE4,0xB8,0x9A,0xFB,0x7D,0x45,0x4A,0x5E,0x2A,0x96,0xBB,0xCD,0xD8,0xFD,0xA8,0x64,0xF7,0x30,0x27,0xFF,0xA3,0x90,0x39,0x2C,0x5B,0xF4,0xB7,0x42,0x95,0x62,0x6F,0xD1,0x5F,0x2A,0xD9,0x9C,0x2E,0xA8,0x55,0xAE,0x52,0x2D,0x4B,0xD0,0x36,0xA5,0x2E,0x8D,0xED,0x8E,0xBE,0xE2,0xB7,0x36,0xAD,0xF5,0x3D,0x51,0xC6,0xF4,0xB7,0x36,0xF4,0x60,0xAA,0xD0,0x6E,0x3A,0x94,0xDC,0x32,0xCB,0x96,0x6C,0x65,0x2B,0x5A,0x1C,0x43,0xA3,0xDA,0xB6,0xEA,0xB9,0x48,0x0F,0x2F,0x27,0x02,0x78,0x41,0x4D,0x03,0x16,0xD0,0x80,0x05,0x14,0x70,0xA5,0xE8,0x03};
//const uint8_t spWORK[] PROGMEM ={0xAA,0xC1,0x65,0xC7,0x59,0x6D,0x85,0x56,0xE8,0x7A,0x53,0x50,0x53,0x5A,0x65,0xEA,0x5D,0x41,0xF9,0xAA,0x8D,0xC9,0x89,0x64,0xE9,0xA7,0x72,0xAA,0xD2,0x5B,0xA5,0x9F,0xCA,0xB8,0x4A,0x29,0xE3,0x3E,0x2A,0xD3,0x92,0xA2,0x45,0xFF,0xAC,0x5A,0x65,0x4B,0xA3,0x8E,0xF3,0x2F,0x95,0x1B,0x89,0x3A,0xAA,0xB7,0x54,0xC9,0xA6,0x3B,0x9B,0x12,0x80,0x00,0xD8,0x68,0xEC,0x81,0x07};
//const uint8_t spWORKING[] PROGMEM ={0xAA,0x25,0xA9,0xDB,0x54,0x14,0xA7,0x4E,0xBA,0xDA,0x30,0x70,0x3E,0x6A,0x99,0xAA,0xCD,0xC8,0xFD,0xA9,0x74,0x28,0xF7,0x62,0xE5,0xA7,0xB2,0x76,0x42,0x5A,0x95,0x9F,0xCA,0xA4,0x11,0x6D,0xE3,0xBE,0x0A,0x97,0x8B,0x74,0x54,0x7F,0x2D,0x04,0x60,0x85,0xB8,0x04,0x24,0x10,0x00,0xCB,0xCC,0x57,0x35,0x63,0x18,0x9A,0xAD,0xBE,0xCD,0x6E,0x5B,0xD7,0x9C,0x31,0x67,0x44,0x2A,0x7D,0xB0,0x2C,0x95,0x6E,0xC5,0xF4,0xDC,0x86,0x8F,0xBA,0x29,0xD3,0x73,0x6B,0x31,0x1C,0xB6,0x54,0xCF,0x8D,0xD5,0x72,0xDA,0x16,0xBD,0x34,0x9A,0xC7,0x61,0x4B,0xF4,0xD6,0x40,0xB6,0xA4,0x63,0xD6,0x79,0x43,0x1A,0x6C,0xB6,0x45,0x9F,0xB3,0xAA,0xA3,0xD8,0x81,0x07,0x00,0x00};
//const uint8_t spWRITE[] PROGMEM ={0xA2,0x65,0x21,0xDD,0x39,0x1C,0x8B,0x9A,0x8E,0x90,0xB0,0x74,0xAC,0x6A,0x3A,0x5C,0xA2,0x43,0x89,0x69,0xF8,0x52,0x8E,0x31,0x27,0xA9,0xD1,0x07,0xB3,0x54,0xDC,0xAF,0xDA,0xC4,0x1A,0x67,0x9D,0x77,0xEB,0x53,0x85,0x9C,0xE9,0xDC,0x71,0x6E,0x75,0xAA,0x58,0x33,0x4D,0x3A,0xEE,0xA9,0xD3,0xF0,0x64,0xCF,0xBA,0xA7,0xC9,0x45,0xC4,0xA2,0x2A,0xCD,0x2E,0xF5,0x29,0xB3,0x44,0x57,0x61,0x33,0x18,0x69,0x92,0xE9,0x16,0x00,0x40,0x01,0x5D,0x79,0x3C};
//const uint8_t spX[] PROGMEM ={0xA5,0x28,0xB1,0x4C,0x2C,0xDE,0xDC,0xEA,0xD4,0xA9,0x84,0x99,0xF6,0x9C,0x5B,0xDF,0x7A,0x36,0xB1,0x05,0x00,0x00,0x30,0xC0,0x4B,0x6E,0x0A,0xF8,0x55,0x5D,0x02,0x1C,0xE0,0x00,0x06,0x30,0xF0};
//const uint8_t spY[] PROGMEM ={0xA2,0xC3,0xBE,0x5F,0xC1,0xEC,0xBA,0x86,0xBB,0x7C,0x13,0x72,0x53,0x1A,0x11,0xFB,0x59,0x38,0xCF,0xAA,0x75,0xDD,0x52,0x89,0xA6,0xBB,0xDE,0xF5,0xA9,0x83,0x99,0x35,0xF5,0x2A,0xB7,0x5E,0xB5,0x0F,0x53,0x66,0x51,0x65,0xD5,0x31,0x6C,0x68,0x6A,0xAD,0x5D,0x8D,0x2A,0x54,0x35,0xAD,0xB6,0xDD,0xAB,0x5C,0xA5,0x2A,0x45,0x51,0xF6,0x8A,0x64,0x2B,0x5D,0x3D,0x00,0x00};
//const uint8_t spYELLOW[] PROGMEM ={0xAE,0xDB,0x09,0x44,0xBC,0x2F,0xC5,0x2E,0x75,0xD3,0x83,0x8A,0xCF,0xA5,0xD2,0x0C,0x2D,0x4A,0xBE,0x8F,0x4F,0x55,0xAD,0x2B,0x47,0xAF,0x39,0x45,0xF4,0x16,0x1E,0xB9,0xF8,0x14,0xC1,0x7B,0xBB,0x79,0xEB,0x51,0x78,0xE7,0x93,0x1C,0x4D,0x4A,0x15,0xAC,0x6F,0x09,0xB7,0xEB,0xCD,0x6E,0x5A,0xA7,0x72,0xBE,0xAA,0xB4,0xA9,0x7D,0xE8,0x65,0x9E,0x63,0x93,0x36,0x66,0xE0,0xA3,0x4B,0x8C,0x5B,0xA9,0x81,0x97,0x2D,0x31,0xD5,0xA4,0x06,0x1B,0x24,0xC7,0x9C,0xB6,0xE8,0x7D,0x14,0x76,0xF6,0x34,0x0F,0x00,0x00};
//const uint8_t spYES[] PROGMEM ={0xAA,0x9A,0x0E,0x54,0x6A,0x26,0xC7,0xA6,0xB6,0xAB,0x9D,0xD5,0x0D,0xD8,0xDE,0x9E,0xA6,0x44,0x57,0x8D,0x78,0x73,0xDB,0xD3,0x96,0xEC,0xAE,0xE6,0x4B,0x57,0x1B,0x9B,0x27,0xEB,0xDA,0x9D,0x75,0xAB,0xC2,0x88,0x44,0x6B,0x3B,0xA1,0xB2,0xD1,0x55,0xAC,0x23,0xC4,0xDC,0x00,0xDF,0x88,0x69,0x40,0x03,0x12,0xE0,0x00,0x05,0x28,0x80,0x81,0x07};
//const uint8_t spYET[] PROGMEM ={0xAE,0x9F,0x16,0x8C,0x73,0x47,0xC5,0xA1,0xF4,0x3D,0x98,0x40,0xF4,0x9D,0xD5,0xD7,0x64,0x82,0x51,0x8F,0x4F,0xDF,0x6A,0x1A,0x29,0x7F,0x3F,0x6D,0xA9,0x16,0x66,0xFE,0xF4,0x76,0xB7,0x5D,0x4D,0xCC,0x5A,0xE2,0x35,0xA7,0xD4,0x31,0xCA,0xA8,0x6D,0x42,0x96,0x4B,0xE5,0xD6,0xE6,0x8E,0x00,0x14,0x90,0xB5,0x9B,0x00,0x52,0x4C,0x86,0x07,0x00,0x00};
//const uint8_t spYOU[] PROGMEM ={0xA5,0xDA,0x0D,0x98,0x23,0x6F,0xF4,0x6A,0x55,0x33,0xA9,0x82,0xC6,0xEB,0x91,0xF5,0x68,0x02,0x11,0x5B,0x67,0x36,0x32,0x2B,0xA2,0x24,0x75,0x75,0xCF,0x7B,0xD5,0x9B,0xD6,0x5A,0x61,0xE5,0x49,0xDD,0x6A,0x97,0xFB,0xD8,0xFB,0x5E,0x77,0xA2,0xB3,0x2C,0x45,0x25,0x8D,0x3C,0x00,0x00};
//const uint8_t spYOU_WIN[] PROGMEM ={0x26,0x2B,0x82,0x54,0x76,0x4B,0xA7,0x76,0x04,0x14,0xB6,0xBA,0x5D,0xBA,0x9E,0x48,0x30,0xEA,0xD6,0x69,0x6A,0x73,0x01,0xF7,0xB7,0xA7,0x6A,0xAD,0x0C,0x0C,0xFB,0x8F,0x2C,0x5A,0x55,0x2D,0xFD,0x52,0x62,0x6E,0xBA,0x06,0xA5,0x59,0x8E,0x72,0x1C,0x13,0x97,0x31,0xF7,0x61,0x2C,0x4D,0x5B,0x6E,0x64,0x8E,0x19,0x66,0x3D,0x55,0x16,0x9E,0x56,0xD8,0xF5,0xD4,0x35,0xA6,0x6A,0xC8,0x9A,0xDB,0xDC,0xF6,0xB6,0xB7,0x4D,0x9D,0xB4,0x66,0xEE,0xDE,0xD8,0xB7,0xAA,0xA5,0xC1,0xC2,0xB2,0x22,0xAB,0x86,0x7A,0x2F,0x8D,0x91,0x2D,0x6A,0x94,0x23,0x3D,0xDB,0x8E,0xA8,0xB0,0xCB,0x4E,0x2B,0x39,0x0F,0x00,0x00};
//const uint8_t spYOUR[] PROGMEM ={0xA6,0x1A,0x1A,0x4C,0xB2,0x2F,0xF9,0x2A,0x56,0xB9,0x1A,0x55,0xF4,0xEA,0x12,0xB6,0xA5,0x57,0xAD,0xB2,0xD1,0xA2,0x9C,0x95,0xF7,0xBA,0x37,0xA9,0x53,0x53,0x72,0x45,0xB3,0xE6,0x21,0x0D,0x66,0x89,0xAF,0x49,0x9E,0x34,0xE8,0x21,0xF6,0x9C,0x9A,0xCA,0x60,0xBB,0xC8,0x9A,0xAB,0x76,0x43,0x58,0xC4,0xA1,0xA1,0xD9,0x0C,0x2A,0x99,0x86,0xBB,0x2D,0x31,0x98,0xA8,0x1C,0xE6,0x6E,0xE0,0x01,0x00,0x00};
//const uint8_t spZ[] PROGMEM ={0xA5,0x4A,0x24,0xCC,0x38,0x73,0x8F,0x7A,0x73,0x37,0x65,0xF6,0xBB,0x9B,0xD6,0x7C,0x6F,0x6A,0xA8,0xEE,0x56,0xD1,0x4D,0xA9,0xB0,0xF4,0x39,0x79,0xC9,0x29,0xC2,0xB6,0xF9,0x64,0x35,0x39,0x72,0xE4,0x93,0x9B,0xAD,0xBC,0x46,0x41,0xC9,0x9E,0xB3,0xAB,0x59,0xCD,0xA6,0x77,0xA1,0xCB,0x8E,0x38,0x7A,0x46,0x3F};
//const uint8_t spZERO[] PROGMEM ={0xAD,0x59,0x3A,0xC8,0x18,0xFD,0x9E,0xA2,0x99,0x34,0x23,0xE9,0x77,0xB2,0xE0,0xDD,0xC4,0xAA,0xCD,0x49,0x5C,0x36,0xB3,0xAC,0x36,0x2B,0xB1,0x45,0xD2,0x33,0x72,0xEF,0x6C,0x54,0xA6,0x73,0x79,0x49,0xDE,0xD5,0xD8,0x2A,0xE9,0xA9,0xDE,0x67,0xEF,0x06,0x99,0xBB,0xA4,0x2D,0x75,0x19,0x54,0xB4,0x2F,0xD1,0xB4,0x79,0xF0,0x83,0x1F,0xFC,0xEC,0x17,0xBB,0x3C,0x00,0x00};
void setup() {
CircuitPlayground.begin();
CircuitPlayground.speaker.say(spHELLO);
CircuitPlayground.speaker.say(spTHESE);
CircuitPlayground.speaker.say(spARE);
CircuitPlayground.speaker.say(spTHE);
CircuitPlayground.speaker.say(spTEXAS_INSTRUMENTS);
CircuitPlayground.speaker.say(spWORDS);
// Calling speaker.end() after playing a sound is optional -- this
// will turn off the pin 13 LED (it's connected to a microcontroller
// pin that's also related to the speaker), but there's a small
// audible click when it turns off. Tradeoffs!
CircuitPlayground.speaker.end();
}
void loop() {
}

48
arduino-cli/libraries/Adafruit_Circuit_Playground/examples/accelTap/accelTap.ino Normal file
View File

@@ -0,0 +1,48 @@
#include <Adafruit_CircuitPlayground.h>
#include <Wire.h>
#include <SPI.h>
// Adjust this number for the sensitivity of the 'click' force
// this strongly depend on the range! for 16G, try 5-10
// for 8G, try 10-20. for 4G try 20-40. for 2G try 40-80
#define CLICKTHRESHHOLD 120
void setup(void) {
while (!Serial);
Serial.begin(9600);
CircuitPlayground.begin();
CircuitPlayground.setAccelRange(LIS3DH_RANGE_2_G); // 2, 4, 8 or 16 G!
// 0 = turn off click detection & interrupt
// 1 = single click only interrupt output
// 2 = double click only interrupt output, detect single click
// Adjust threshhold, higher numbers are less sensitive
CircuitPlayground.setAccelTap(1, CLICKTHRESHHOLD);
// have a procedure called when a tap is detected
attachInterrupt(digitalPinToInterrupt(CPLAY_LIS3DH_INTERRUPT), tapTime, FALLING);
}
void tapTime(void) {
// do something :)
Serial.print("Tap! ");
Serial.println(millis()); // the time
}
void loop() {
/*
// *or* uncomment this for manual polling of tap data
uint8_t click = CircuitPlayground.getAccelTap();
if (click == 0) return;
if (! (click & 0x30)) return;
Serial.print("Click detected (0x"); Serial.print(click, HEX); Serial.print("): ");
if (click & 0x10) Serial.print(" single click");
if (click & 0x20) Serial.print(" double click");
Serial.println();
delay(100);
return;
*/
}

137
arduino-cli/libraries/Adafruit_Circuit_Playground/examples/accel_mouse/accel_mouse.ino Normal file
View File

@@ -0,0 +1,137 @@
// Circuit Playground Accelerometer Mouse Example
// Tilt Circuit Playground left/right and up/down to move your mouse, and
// press the left and right push buttons to click the mouse buttons! Make sure
// the slide switch is in the on (+) position to enable the mouse, or slide into
// the off (-) position to disable it. By default the sketch assumes you hold
// Circuit Playground with the USB cable coming out the top.
// Author: Tony DiCola
// License: MIT License (https://opensource.org/licenses/MIT)
#include <Adafruit_CircuitPlayground.h>
#include <Mouse.h>
#include <Wire.h>
#include <SPI.h>
// Configuration values to adjust the sensitivity and speed of the mouse.
// X axis (left/right) configuration:
#define XACCEL_MIN 0.1 // Minimum range of X axis acceleration, values below
// this won't move the mouse at all.
#define XACCEL_MAX 8.0 // Maximum range of X axis acceleration, values above
// this will move the mouse as fast as possible.
#define XMOUSE_RANGE 25.0 // Range of velocity for mouse movements. The higher
// this value the faster the mouse will move.
#define XMOUSE_SCALE 1 // Scaling value to apply to mouse movement, this is
// useful to set to -1 to flip the X axis movement.
// Y axis (up/down) configuration:
// Note that the meaning of these values is exactly the same as the X axis above,
// just applied to the Y axis and up/down mouse movement. You probably want to
// keep these values the same as for the X axis (which is the default, they just
// read the X axis values but you can override with custom values).
#define YACCEL_MIN XACCEL_MIN
#define YACCEL_MAX XACCEL_MAX
#define YMOUSE_RANGE XMOUSE_RANGE
#define YMOUSE_SCALE 1
// Set this true to flip the mouse X/Y axis with the board X/Y axis (what you want
// if holding with USB cable facing up).
#define FLIP_AXES true
// Floating point linear interpolation function that takes a value inside one
// range and maps it to a new value inside another range. This is used to transform
// each axis of acceleration to mouse velocity/speed. See this page for details
// on the equation: https://en.wikipedia.org/wiki/Linear_interpolation
float lerp(float x, float x0, float x1, float y0, float y1) {
// Check if the input value (x) is outside its desired range and clamp to
// those min/max y values.
if (x <= x0) {
return y0;
}
else if (x >= x1) {
return y1;
}
// Otherwise compute the value y based on x's position within its range and
// the desired y min & max.
return y0 + (y1-y0)*((x-x0)/(x1-x0));
}
void setup() {
// Initialize Circuit Playground library.
CircuitPlayground.begin();
// Initialize Arduino mouse library.
Mouse.begin();
}
void loop() {
// Check if the slide switch is enabled (on +) and if not then just exit out
// and run the loop again. This lets you turn on/off the mouse movement with
// the slide switch.
if (!CircuitPlayground.slideSwitch()) {
return;
}
// Grab initial left & right button states to later check if they are pressed
// or released. Do this early in the loop so other processing can take some
// time and the button state change can be detected.
boolean left_first = CircuitPlayground.leftButton();
boolean right_first = CircuitPlayground.rightButton();
// Grab x, y acceleration values (in m/s^2).
float x = CircuitPlayground.motionX();
float y = CircuitPlayground.motionY();
// Use the magnitude of acceleration to interpolate the mouse velocity.
float x_mag = abs(x);
float x_mouse = lerp(x_mag, XACCEL_MIN, XACCEL_MAX, 0.0, XMOUSE_RANGE);
float y_mag = abs(y);
float y_mouse = lerp(y_mag, YACCEL_MIN, YACCEL_MAX, 0.0, YMOUSE_RANGE);
// Change the mouse direction based on the direction of the acceleration.
if (x < 0) {
x_mouse *= -1.0;
}
if (y < 0) {
y_mouse *= -1.0;
}
// Apply any global scaling to the axis (to flip it for example) and truncate
// to an integer value.
x_mouse = floor(x_mouse*XMOUSE_SCALE);
y_mouse = floor(y_mouse*YMOUSE_SCALE);
// Move mouse.
if (!FLIP_AXES) {
// Non-flipped axes, just map board X/Y to mouse X/Y.
Mouse.move((int)x_mouse, (int)y_mouse, 0);
}
else {
// Flipped axes, swap them around.
Mouse.move((int)y_mouse, (int)x_mouse, 0);
}
// Small delay to wait for button state changes and slow down processing a bit.
delay(10);
// Grab a second button state reading to check if the buttons were pressed or
// released.
boolean left_second = CircuitPlayground.leftButton();
boolean right_second = CircuitPlayground.rightButton();
// Check for left button pressed / released.
if (!left_first && left_second) {
// Low then high, button was pressed!
Mouse.press(MOUSE_LEFT);
}
else if (left_first && !left_second) {
// High then low, button was released!
Mouse.release(MOUSE_LEFT);
}
// Check for right button pressed / released.
if (!right_first && right_second) {
// Low then high, button was pressed!
Mouse.press(MOUSE_RIGHT);
}
else if (right_first && !right_second) {
// High then low, button was released!
Mouse.release(MOUSE_RIGHT);
}
}

89
arduino-cli/libraries/Adafruit_Circuit_Playground/examples/analog_sensors/analog_sensors.ino Normal file
View File

@@ -0,0 +1,89 @@
// Circuit Playground Analog Sensor Demo
// Shows how to read an analog sensor like temperature, light,
// sound, or even external inputs and convert the analog value
// to color and sound on the board. Will light up NeoPixel 4 and 5
// with a color proportional to the analog value, and if the slide
// switch is turned to the left will play a music tone proportional
// to the value.
#include <Adafruit_CircuitPlayground.h>
#include <Wire.h>
#include <SPI.h>
// Change the analog input value below to try different sensors:
#define ANALOG_INPUT A5 // Specify the analog input to read.
// Circuit Playground has the following
// inputs available:
// - A0 = temperature sensor / thermistor
// - A4 = sound sensor / microphone
// - A5 = light sensor
// - A7 = pin #6 on board
// - A9 = pin #9 on board
// - A10 = pin #10 on board
// - A11 = pin #12 on board
// These defines set the range of expected analog values.
// This is used to scale the NeoPixels, sound, etc.
#define VALUE_MIN 0
#define VALUE_MAX 200
// These defines set the range of pixel color when mapping
// to the sensor value.
#define COLOR_RED_MIN 255
#define COLOR_GREEN_MIN 0
#define COLOR_BLUE_MIN 0
#define COLOR_RED_MAX 0
#define COLOR_GREEN_MAX 0
#define COLOR_BLUE_MAX 255
// These defines set the range of sound frequencies when
// mapping to the sensor value.
#define TONE_FREQ_MIN 523 // C5 note
#define TONE_FREQ_MAX 988 // B5 note
void setup() {
// Setup serial port.
Serial.begin(115200);
Serial.println("Circuit Playground Analog Sensor Demos!");
// Setup Circuit Playground library.
CircuitPlayground.begin();
}
void loop() {
// Get the sensor sensor value and print it out (can use serial plotter
// to view realtime graph!).
uint16_t value = analogRead(ANALOG_INPUT);
Serial.println(value, DEC);
// Map the sensor value to a color.
// Use the range of minimum and maximum sensor values and
// min/max colors to do the mapping.
if(value < VALUE_MIN) value = VALUE_MIN;
else if(value > VALUE_MAX) value = VALUE_MAX;
int red = map(value, VALUE_MIN, VALUE_MAX, COLOR_RED_MIN , COLOR_RED_MAX);
int green = map(value, VALUE_MIN, VALUE_MAX, COLOR_GREEN_MIN, COLOR_GREEN_MAX);
int blue = map(value, VALUE_MIN, VALUE_MAX, COLOR_BLUE_MIN , COLOR_BLUE_MAX);
// Gamma correction gives a more linear appearance to brightness ranges
red = CircuitPlayground.gamma8(red);
green = CircuitPlayground.gamma8(green);
blue = CircuitPlayground.gamma8(blue);
// Light up pixel #4 and 5 with the color.
CircuitPlayground.clearPixels();
CircuitPlayground.setPixelColor(4, red, green, blue);
CircuitPlayground.setPixelColor(5, red, green, blue);
// Map the sensor value to a tone frequency.
int frequency = map(value, VALUE_MIN, VALUE_MAX, TONE_FREQ_MIN, TONE_FREQ_MAX);
// Play the tone if the slide switch is turned on (to the left).
if (CircuitPlayground.slideSwitch()) {
// Play tone of the mapped frequency value for 100 milliseconds.
CircuitPlayground.playTone(frequency, 100);
}
// Delay for a bit and repeat the loop.
delay(100);
}

65
arduino-cli/libraries/Adafruit_Circuit_Playground/examples/color_sense/color_sense.ino Normal file
View File

@@ -0,0 +1,65 @@
// Circuit Playground Color Sensing Example
// Use a NeoPixel RGB LED and light sensor on the Circuit Playground board to
// do basic color detection. By quickly flashing full red, green, and blue color
// light from the NeoPixel the light sensor can read the intensity of the
// reflected light and roughly approximate the color of the object.
//
// After uploading the sketch to Circuit Playground you can press and release the
// left or right button to do a color sense and print the red, green, blue component
// values to the serial monitor (115200 baud). In addition all the NeoPixels on
// the board will be lit up to the detected color. You should hold a brightly
// colored object right above the light sensor and NeoPixel #1 (upper
// left part of board, look for the eye symbol next to the color sensor) when
// performing the color sense.
//
// Author: Limor Fried & Tony DiCola
// License: MIT License (https://opensource.org/licenses/MIT)
#include <Adafruit_CircuitPlayground.h>
#include <Wire.h>
#include <SPI.h>
void setup() {
Serial.begin(115200);
// Initialize Circuit Playground library.
CircuitPlayground.begin();
CircuitPlayground.strip.setBrightness(255);
}
void loop() {
// Detect if the left or right button is pressed by taking two readings with
// a small delay inbetween. If the button changes state (like it was pressed
// or released) then the two readings will be different.
bool left_first = CircuitPlayground.leftButton();
bool right_first = CircuitPlayground.rightButton();
delay(20);
bool left_second = CircuitPlayground.leftButton();
bool right_second = CircuitPlayground.rightButton();
// Now check if either button was released, i.e. changed from a true (pressed)
// state to a false (non-pressed) state.
if ((left_first && !left_second) || (right_first && !right_second)) {
// Button was pressed, perform a color sense.
// First turn off all the pixels to make sure they don't interfere with the
// reading.
CircuitPlayground.clearPixels();
// Now take a color reading (the red, green, blue color components will be
// returned in the parameters passed in).
uint8_t red, green, blue;
CircuitPlayground.senseColor(red, green, blue);
// Print out the color components.
Serial.print("Color: red=");
Serial.print(red, DEC);
Serial.print(" green=");
Serial.print(green, DEC);
Serial.print(" blue=");
Serial.println(blue, DEC);
// Gamma correction makes LED brightness appear more linear
red = CircuitPlayground.gamma8(red);
green = CircuitPlayground.gamma8(green);
blue = CircuitPlayground.gamma8(blue);
// Finally set all the pixels to the detected color.
for (int i=0; i<10; ++i) {
CircuitPlayground.strip.setPixelColor(i, red, green, blue);
}
CircuitPlayground.strip.show();
}
}

1095
arduino-cli/libraries/Adafruit_Circuit_Playground/examples/comm_badge/coin.h Normal file
View File

File diff suppressed because it is too large Load Diff

47
arduino-cli/libraries/Adafruit_Circuit_Playground/examples/comm_badge/comm_badge.ino Normal file
View File

@@ -0,0 +1,47 @@
// Speaker demo for Circuit Playground -- when tapped, plays a very short
// digitized sound sample, very quietly (because teeny tiny speaker).
#include <Adafruit_CircuitPlayground.h>
#include <Wire.h>
#include <SPI.h>
// Enable ONE of these lines to pick a sound to play back when tapped:
#include "coin.h" // Super Mario coin sound
//#include "trek.h" // Star Trek TNG communicator noise
volatile boolean play = false;
// This function will be called automatically when a tap is detected by the
// accelerometer. This just sets the global flag 'play' to true, which is
// then detected in loop() (where the sound is then played)...doing heavy
// processing within an interrupt function is sometimes considered poor form.
void myFunction() {
play = true; // Hey loop(), play the sound!
}
void setup() {
CircuitPlayground.begin();
// Configure accelerometer for +-4G range, use the tap interrupt
// feature to call myFunction() automatically when tapped.
CircuitPlayground.setAccelRange(LIS3DH_RANGE_4_G);
CircuitPlayground.setAccelTap(1, 127);
attachInterrupt(digitalPinToInterrupt(CPLAY_LIS3DH_INTERRUPT), myFunction, RISING);
}
void loop() {
while(!play); // Wait for tap interrupt
// Play sound data in the audio[] array (declared in one of the .h files).
// This function "blocks" -- that is, program flow stops until sound is
// done playing -- it does not play in the background.
CircuitPlayground.speaker.playSound(audio, sizeof(audio), SAMPLE_RATE);
// Calling speaker.end() after playing a sound is optional -- this will
// turn off the pin 13 LED (it's connected to a microcontroller pin that's
// also related to the speaker), but there's a small audible click when it
// turns off. Tradeoffs!
CircuitPlayground.speaker.end();
play = false; // Clear flag, wait for interrupt
}

580
arduino-cli/libraries/Adafruit_Circuit_Playground/examples/comm_badge/trek.h Normal file
View File

@@ -0,0 +1,580 @@
#define SAMPLE_RATE 22050
const uint8_t PROGMEM audio[] = {
0x7F, 0x7F, 0x7F, 0x7F, 0x80, 0x81, 0x7F, 0x7E, 0x81, 0x80, 0x7D, 0x80,
0x82, 0x7B, 0x81, 0x86, 0x7B, 0x7A, 0x85, 0x83, 0x78, 0x7F, 0x8A, 0x79,
0x7B, 0x88, 0x7C, 0x7F, 0x84, 0x78, 0x81, 0x86, 0x7C, 0x7F, 0x83, 0x7B,
0x7D, 0x7F, 0x87, 0x9C, 0x67, 0x41, 0xAE, 0xBE, 0x65, 0x39, 0x89, 0xE1,
0x40, 0x3A, 0xFB, 0x6A, 0x20, 0xCA, 0xAA, 0x02, 0xC6, 0xB9, 0x30, 0x8E,
0x8E, 0x5D, 0xB3, 0x7B, 0x45, 0xCA, 0x4B, 0x7A, 0xDD, 0x00, 0x94, 0xEF,
0x2A, 0x75, 0xA6, 0x40, 0xC8, 0x6D, 0x6C, 0x9B, 0x6D, 0x67, 0x93, 0xA3,
0x8A, 0x16, 0xA8, 0xC8, 0x6E, 0x55, 0x6F, 0x92, 0x92, 0x89, 0x70, 0x95,
0x58, 0x5C, 0xC3, 0xAF, 0x2A, 0x6A, 0xD9, 0x59, 0x44, 0xCA, 0x74, 0x72,
0x96, 0x54, 0x77, 0xC1, 0x7B, 0x41, 0x8A, 0xBC, 0x61, 0x5B, 0xA5, 0x6F,
0x95, 0x7F, 0x5C, 0x9E, 0x8D, 0x42, 0xB1, 0x95, 0x4E, 0x96, 0x7E, 0x64,
0xB8, 0x6F, 0x52, 0xAA, 0x70, 0x78, 0xB0, 0x59, 0x59, 0xB6, 0x8E, 0x4D,
0x8F, 0x9E, 0x5D, 0x72, 0xA9, 0x77, 0x66, 0x9B, 0x76, 0x67, 0xAA, 0x7D,
0x56, 0x8A, 0xA5, 0x6E, 0x63, 0x93, 0x90, 0x70, 0x81, 0x7B, 0x78, 0x97,
0x7B, 0x77, 0x7D, 0x79, 0x80, 0x9F, 0x7F, 0x5A, 0x86, 0x82, 0x88, 0x91,
0x74, 0x6E, 0x7D, 0x95, 0x83, 0x6C, 0x89, 0x81, 0x70, 0x90, 0x87, 0x70,
0x7B, 0x86, 0x8D, 0x75, 0x73, 0x8B, 0x85, 0x7B, 0x7F, 0x7F, 0x7C, 0x84,
0x85, 0x7C, 0x7B, 0x81, 0x7D, 0x80, 0x89, 0x7E, 0x75, 0x7C, 0x8A, 0x81,
0x7F, 0x7B, 0x7F, 0x82, 0x7B, 0x7F, 0x87, 0x7F, 0x7A, 0x82, 0x80, 0x7E,
0x7B, 0x85, 0x88, 0x78, 0x74, 0x8A, 0x83, 0x7B, 0x80, 0x83, 0x80, 0x75,
0x82, 0x88, 0x81, 0x7A, 0x79, 0x85, 0x88, 0x7B, 0x78, 0x80, 0x87, 0x80,
0x7E, 0x7B, 0x7E, 0x89, 0x80, 0x79, 0x7B, 0x86, 0x83, 0x78, 0x83, 0x83,
0x77, 0x82, 0x88, 0x79, 0x7A, 0x85, 0x83, 0x81, 0x7A, 0x78, 0x88, 0x85,
0x79, 0x83, 0x7D, 0x7A, 0x82, 0x85, 0x80, 0x7C, 0x7B, 0x81, 0x85, 0x81,
0x7C, 0x7B, 0x82, 0x84, 0x7C, 0x7F, 0x83, 0x7C, 0x7E, 0x83, 0x80, 0x7B,
0x7E, 0x85, 0x84, 0x7C, 0x79, 0x7C, 0x8A, 0x8A, 0x71, 0x79, 0x8D, 0x7E,
0x78, 0x83, 0x82, 0x7E, 0x7F, 0x7E, 0x80, 0x83, 0x7E, 0x7E, 0x80, 0x7E,
0x80, 0x7E, 0x82, 0x82, 0x7C, 0x7E, 0x82, 0x80, 0x80, 0x7B, 0x81, 0x85,
0x7E, 0x7A, 0x80, 0x81, 0x81, 0x81, 0x7E, 0x7C, 0x7F, 0x84, 0x7E, 0x7C,
0x83, 0x81, 0x7B, 0x81, 0x81, 0x7C, 0x80, 0x84, 0x82, 0x7D, 0x79, 0x82,
0x86, 0x7D, 0x7E, 0x80, 0x7E, 0x82, 0x7F, 0x7C, 0x80, 0x86, 0x80, 0x78,
0x7F, 0x85, 0x80, 0x7A, 0x84, 0x84, 0x7A, 0x79, 0x87, 0x81, 0x7A, 0x84,
0x82, 0x77, 0x80, 0x82, 0x7E, 0x84, 0x82, 0x78, 0x7B, 0x89, 0x7C, 0x7C,
0x82, 0x81, 0x82, 0x7B, 0x7E, 0x82, 0x82, 0x7B, 0x82, 0x85, 0x7A, 0x7D,
0x82, 0x7E, 0x85, 0x7E, 0x77, 0x88, 0x81, 0x79, 0x7C, 0x85, 0x83, 0x7D,
0x7C, 0x80, 0x84, 0x7F, 0x79, 0x7E, 0x8E, 0x7C, 0x73, 0x83, 0x83, 0x80,
0x85, 0x7C, 0x77, 0x83, 0x81, 0x81, 0x82, 0x7C, 0x7C, 0x81, 0x87, 0x7D,
0x75, 0x84, 0x87, 0x7B, 0x7E, 0x81, 0x7C, 0x84, 0x82, 0x75, 0x83, 0x86,
0x7A, 0x7D, 0x84, 0x80, 0x7B, 0x83, 0x84, 0x7B, 0x7E, 0x81, 0x7F, 0x7F,
0x82, 0x7E, 0x7E, 0x81, 0x7F, 0x81, 0x7E, 0x7A, 0x86, 0x85, 0x75, 0x7E,
0x85, 0x82, 0x7E, 0x7C, 0x81, 0x80, 0x80, 0x7E, 0x7E, 0x7E, 0x84, 0x80,
0x7C, 0x83, 0x7E, 0x7B, 0x84, 0x82, 0x7B, 0x80, 0x81, 0x81, 0x7F, 0x7C,
0x81, 0x84, 0x7E, 0x7C, 0x7E, 0x81, 0x85, 0x7C, 0x7A, 0x83, 0x85, 0x7C,
0x7C, 0x84, 0x81, 0x7A, 0x7E, 0x85, 0x83, 0x78, 0x7C, 0x88, 0x82, 0x7B,
0x7B, 0x81, 0x88, 0x7D, 0x79, 0x84, 0x81, 0x7D, 0x81, 0x7E, 0x80, 0x80,
0x7C, 0x82, 0x83, 0x7C, 0x7D, 0x84, 0x82, 0x7A, 0x7E, 0x84, 0x80, 0x7D,
0x82, 0x7C, 0x7E, 0x85, 0x81, 0x7C, 0x7E, 0x7E, 0x7F, 0x84, 0x7F, 0x7D,
0x7D, 0x83, 0x84, 0x7B, 0x7C, 0x85, 0x80, 0x7E, 0x7F, 0x7E, 0x80, 0x83,
0x7F, 0x7E, 0x80, 0x7D, 0x80, 0x81, 0x81, 0x7E, 0x7D, 0x81, 0x82, 0x7B,
0x80, 0x84, 0x7B, 0x80, 0x80, 0x7C, 0x85, 0x82, 0x79, 0x7E, 0x88, 0x7E,
0x77, 0x80, 0x87, 0x80, 0x7C, 0x7E, 0x80, 0x80, 0x81, 0x7C, 0x81, 0x83,
0x7C, 0x7E, 0x81, 0x7D, 0x7F, 0x84, 0x80, 0x7D, 0x7C, 0x7E, 0x84, 0x82,
0x7B, 0x7B, 0x86, 0x86, 0x79, 0x79, 0x85, 0x82, 0x7E, 0x80, 0x80, 0x7A,
0x7E, 0x87, 0x82, 0x7B, 0x7E, 0x7E, 0x82, 0x83, 0x7C, 0x7C, 0x81, 0x87,
0x7C, 0x79, 0x83, 0x85, 0x7A, 0x80, 0x81, 0x7F, 0x80, 0x7E, 0x7E, 0x7F,
0x83, 0x82, 0x7D, 0x7B, 0x82, 0x84, 0x79, 0x7E, 0x87, 0x80, 0x7C, 0x7C,
0x81, 0x85, 0x7C, 0x7E, 0x83, 0x80, 0x7D, 0x7E, 0x82, 0x84, 0x7D, 0x7B,
0x83, 0x82, 0x7B, 0x80, 0x82, 0x7E, 0x7E, 0x81, 0x82, 0x7A, 0x7C, 0x87,
0x83, 0x7A, 0x7C, 0x80, 0x85, 0x82, 0x77, 0x7E, 0x89, 0x7C, 0x7D, 0x80,
0x7C, 0x84, 0x82, 0x7D, 0x82, 0x7F, 0x7B, 0x80, 0x84, 0x80, 0x7C, 0x80,
0x84, 0x7B, 0x7C, 0x85, 0x83, 0x7C, 0x7E, 0x7D, 0x80, 0x86, 0x7C, 0x7C,
0x84, 0x80, 0x7C, 0x82, 0x80, 0x7B, 0x80, 0x84, 0x81, 0x7B, 0x7B, 0x82,
0x85, 0x80, 0x7B, 0x7D, 0x83, 0x7F, 0x7D, 0x83, 0x82, 0x7A, 0x80, 0x82,
0x7F, 0x7F, 0x7F, 0x81, 0x84, 0x7B, 0x79, 0x86, 0x82, 0x7D, 0x7D, 0x82,
0x82, 0x7C, 0x7C, 0x84, 0x82, 0x7E, 0x7E, 0x7E, 0x80, 0x80, 0x80, 0x82,
0x7E, 0x79, 0x84, 0x87, 0x7B, 0x7A, 0x81, 0x82, 0x80, 0x7E, 0x7E, 0x80,
0x83, 0x7E, 0x7D, 0x83, 0x80, 0x7C, 0x80, 0x80, 0x7C, 0x83, 0x83, 0x7C,
0x7C, 0x80, 0x82, 0x80, 0x80, 0x7C, 0x7C, 0x83, 0x81, 0x80, 0x80, 0x7B,
0x80, 0x85, 0x7E, 0x7C, 0x81, 0x80, 0x82, 0x80, 0x7E, 0x82, 0x7C, 0x7E,
0x82, 0x7F, 0x7F, 0x82, 0x7D, 0x80, 0x83, 0x79, 0x80, 0x85, 0x7C, 0x80,
0x80, 0x7B, 0x84, 0x80, 0x7D, 0x82, 0x7E, 0x7F, 0x82, 0x7D, 0x80, 0x80,
0x7D, 0x81, 0x82, 0x80, 0x80, 0x79, 0x7D, 0x89, 0x7E, 0x7C, 0x80, 0x7C,
0x82, 0x84, 0x7D, 0x7E, 0x80, 0x84, 0x7D, 0x7B, 0x84, 0x7C, 0x80, 0x88,
0x77, 0x7C, 0x8A, 0x7B, 0x7B, 0x84, 0x7D, 0x80, 0x85, 0x7A, 0x7E, 0x85,
0x7B, 0x7D, 0x88, 0x7D, 0x7B, 0x84, 0x80, 0x7D, 0x7E, 0x83, 0x80, 0x7E,
0x7E, 0x80, 0x80, 0x82, 0x7E, 0x7D, 0x81, 0x80, 0x80, 0x80, 0x7E, 0x80,
0x7E, 0x7F, 0x83, 0x7F, 0x7E, 0x7F, 0x7F, 0x82, 0x80, 0x7C, 0x82, 0x80,
0x7E, 0x84, 0x7E, 0x7A, 0x83, 0x80, 0x7E, 0x83, 0x7F, 0x7C, 0x82, 0x80,
0x7E, 0x81, 0x80, 0x7E, 0x7F, 0x81, 0x81, 0x7F, 0x7D, 0x7F, 0x83, 0x81,
0x7C, 0x80, 0x83, 0x7C, 0x7B, 0x83, 0x84, 0x7F, 0x7C, 0x80, 0x80, 0x82,
0x7F, 0x7C, 0x80, 0x84, 0x7C, 0x7E, 0x83, 0x7E, 0x7E, 0x82, 0x7D, 0x80,
0x82, 0x7D, 0x7E, 0x82, 0x80, 0x7D, 0x7F, 0x82, 0x80, 0x80, 0x7F, 0x7E,
0x7F, 0x81, 0x81, 0x7E, 0x7F, 0x81, 0x7F, 0x80, 0x82, 0x7C, 0x80, 0x82,
0x7E, 0x7E, 0x80, 0x7E, 0x7E, 0x84, 0x80, 0x7D, 0x82, 0x7E, 0x7E, 0x82,
0x7F, 0x7F, 0x82, 0x7E, 0x7E, 0x7F, 0x80, 0x82, 0x82, 0x7D, 0x7D, 0x80,
0x7F, 0x7F, 0x81, 0x81, 0x7F, 0x80, 0x80, 0x7E, 0x80, 0x81, 0x7E, 0x7E,
0x80, 0x82, 0x7F, 0x7F, 0x81, 0x80, 0x7E, 0x7E, 0x7F, 0x81, 0x81, 0x7F,
0x80, 0x80, 0x7C, 0x7E, 0x82, 0x84, 0x7D, 0x7B, 0x80, 0x82, 0x82, 0x7E,
0x7C, 0x81, 0x83, 0x7E, 0x7E, 0x83, 0x7F, 0x7D, 0x80, 0x7F, 0x81, 0x80,
0x7E, 0x80, 0x80, 0x7D, 0x81, 0x82, 0x80, 0x7C, 0x7E, 0x81, 0x84, 0x7E,
0x7C, 0x81, 0x81, 0x7E, 0x7E, 0x80, 0x82, 0x7E, 0x7E, 0x80, 0x81, 0x7F,
0x80, 0x7F, 0x7E, 0x80, 0x80, 0x7F, 0x80, 0x81, 0x7F, 0x7D, 0x81, 0x81,
0x7E, 0x7E, 0x80, 0x7E, 0x80, 0x81, 0x82, 0x80, 0x7D, 0x7D, 0x82, 0x82,
0x7D, 0x7D, 0x81, 0x81, 0x7E, 0x7E, 0x80, 0x83, 0x7F, 0x7D, 0x7E, 0x82,
0x81, 0x7E, 0x80, 0x80, 0x7D, 0x81, 0x82, 0x7E, 0x7E, 0x7E, 0x80, 0x82,
0x7F, 0x7C, 0x80, 0x82, 0x7E, 0x80, 0x82, 0x7E, 0x80, 0x80, 0x7E, 0x7F,
0x82, 0x80, 0x7C, 0x82, 0x82, 0x7C, 0x7E, 0x82, 0x80, 0x80, 0x80, 0x80,
0x7D, 0x7E, 0x82, 0x81, 0x80, 0x7E, 0x7E, 0x81, 0x80, 0x7F, 0x7F, 0x7E,
0x80, 0x7E, 0x80, 0x83, 0x80, 0x7C, 0x80, 0x81, 0x7E, 0x7E, 0x80, 0x82,
0x7E, 0x7E, 0x81, 0x81, 0x7E, 0x7E, 0x80, 0x82, 0x7E, 0x7E, 0x7F, 0x82,
0x82, 0x7D, 0x80, 0x81, 0x7E, 0x7F, 0x81, 0x7F, 0x7E, 0x82, 0x82, 0x7D,
0x7E, 0x81, 0x82, 0x80, 0x7E, 0x7C, 0x80, 0x84, 0x7E, 0x7E, 0x82, 0x7F,
0x7E, 0x82, 0x7E, 0x7E, 0x80, 0x80, 0x80, 0x80, 0x7F, 0x7E, 0x82, 0x81,
0x7E, 0x7E, 0x80, 0x81, 0x7F, 0x7C, 0x80, 0x82, 0x81, 0x7D, 0x7E, 0x80,
0x82, 0x7E, 0x80, 0x7E, 0x7E, 0x82, 0x81, 0x7D, 0x7C, 0x80, 0x82, 0x80,
0x80, 0x7E, 0x7E, 0x80, 0x81, 0x7E, 0x7E, 0x80, 0x80, 0x80, 0x82, 0x7E,
0x7C, 0x83, 0x81, 0x7C, 0x7E, 0x82, 0x84, 0x7E, 0x7C, 0x80, 0x80, 0x80,
0x7F, 0x7F, 0x80, 0x82, 0x7E, 0x7E, 0x80, 0x80, 0x7E, 0x81, 0x80, 0x7E,
0x80, 0x82, 0x80, 0x7C, 0x7F, 0x82, 0x80, 0x7F, 0x7E, 0x80, 0x82, 0x7E,
0x7E, 0x81, 0x80, 0x7E, 0x80, 0x81, 0x7F, 0x7E, 0x7E, 0x82, 0x82, 0x7E,
0x7E, 0x80, 0x81, 0x7F, 0x7D, 0x7F, 0x81, 0x80, 0x7E, 0x80, 0x81, 0x7F,
0x80, 0x7E, 0x80, 0x81, 0x7F, 0x7F, 0x81, 0x7F, 0x7E, 0x80, 0x81, 0x80,
0x7F, 0x7D, 0x80, 0x83, 0x7F, 0x7D, 0x7E, 0x80, 0x7F, 0x81, 0x80, 0x81,
0x7F, 0x7E, 0x7E, 0x80, 0x80, 0x80, 0x82, 0x7E, 0x7C, 0x80, 0x82, 0x81,
0x7F, 0x80, 0x7E, 0x7E, 0x82, 0x7E, 0x7F, 0x80, 0x80, 0x7E, 0x81, 0x80,
0x82, 0x83, 0x7E, 0x7C, 0x7D, 0x7D, 0x7E, 0x83, 0x85, 0x7F, 0x78, 0x7D,
0x88, 0x95, 0x99, 0x69, 0x2A, 0x4E, 0xC6, 0xFF, 0xAE, 0x2A, 0x00, 0x5F,
0xD4, 0xE6, 0x84, 0x28, 0x38, 0x9A, 0xD4, 0xB5, 0x65, 0x32, 0x47, 0x8C,
0xC0, 0xB9, 0x83, 0x4B, 0x46, 0x78, 0xAF, 0xB7, 0x84, 0x4F, 0x4E, 0x7C,
0xAA, 0xAC, 0x84, 0x5F, 0x57, 0x73, 0x9C, 0xAA, 0x8C, 0x62, 0x57, 0x73,
0x9A, 0xA7, 0x8C, 0x67, 0x5E, 0x72, 0x93, 0xA1, 0x8D, 0x6D, 0x61, 0x73,
0x90, 0x9B, 0x8C, 0x71, 0x66, 0x74, 0x8C, 0x98, 0x8A, 0x71, 0x6A, 0x79,
0x8B, 0x8F, 0x87, 0x7B, 0x70, 0x74, 0x85, 0x91, 0x8B, 0x77, 0x6D, 0x77,
0x86, 0x8E, 0x8A, 0x7D, 0x74, 0x75, 0x82, 0x8B, 0x84, 0x7E, 0x7A, 0x7B,
0x82, 0x84, 0x84, 0x80, 0x78, 0x78, 0x80, 0x85, 0x8B, 0x80, 0x75, 0x77,
0x7E, 0x84, 0x87, 0x89, 0x7E, 0x76, 0x76, 0x81, 0x88, 0x82, 0x7D, 0x7E,
0x81, 0x84, 0x81, 0x7D, 0x7B, 0x7A, 0x7C, 0x85, 0x8C, 0x85, 0x7B, 0x75,
0x79, 0x7F, 0x84, 0x82, 0x84, 0x86, 0x7F, 0x79, 0x7A, 0x7F, 0x82, 0x7E,
0x7A, 0x83, 0x8C, 0x89, 0x7B, 0x70, 0x76, 0x82, 0x83, 0x83, 0x84, 0x88,
0x83, 0x79, 0x72, 0x7A, 0x86, 0x83, 0x7B, 0x82, 0x8B, 0x85, 0x7C, 0x75,
0x77, 0x7F, 0x82, 0x7F, 0x84, 0x8F, 0x8A, 0x77, 0x69, 0x77, 0x8A, 0x86,
0x7B, 0x7C, 0x8E, 0x94, 0x7D, 0x66, 0x6F, 0x86, 0x87, 0x7E, 0x7D, 0x8D,
0x94, 0x81, 0x66, 0x68, 0x83, 0x94, 0x82, 0x6E, 0x78, 0x9A, 0x9E, 0x7B,
0x5D, 0x66, 0x88, 0x95, 0x7F, 0x6E, 0x81, 0x9C, 0x94, 0x73, 0x5E, 0x72,
0x8F, 0x8D, 0x75, 0x6F, 0x88, 0xA4, 0x93, 0x68, 0x59, 0x74, 0x97, 0x95,
0x72, 0x65, 0x88, 0xA8, 0x96, 0x68, 0x55, 0x72, 0x99, 0x97, 0x73, 0x65,
0x82, 0xA7, 0x9D, 0x6F, 0x51, 0x68, 0x97, 0xA1, 0x7C, 0x60, 0x77, 0xA4,
0xA3, 0x76, 0x58, 0x62, 0x88, 0xA1, 0x8B, 0x64, 0x65, 0x90, 0xB2, 0x99,
0x60, 0x4A, 0x68, 0x9E, 0xAD, 0x83, 0x57, 0x5F, 0x9A, 0xBA, 0x97, 0x56,
0x42, 0x6E, 0xA7, 0xB0, 0x7E, 0x53, 0x61, 0x9C, 0xBC, 0x90, 0x52, 0x47,
0x74, 0xA7, 0xAA, 0x78, 0x53, 0x6B, 0xA4, 0xB5, 0x87, 0x4E, 0x4A, 0x7D,
0xAE, 0xAA, 0x72, 0x4B, 0x69, 0xA7, 0xBE, 0x89, 0x48, 0x45, 0x7B, 0xB3,
0xB2, 0x74, 0x44, 0x5E, 0xA5, 0xC7, 0x96, 0x49, 0x36, 0x71, 0xB3, 0xBC,
0x88, 0x49, 0x46, 0x8D, 0xC8, 0xB1, 0x60, 0x35, 0x58, 0xA1, 0xC1, 0x9D,
0x5B, 0x3F, 0x6D, 0xB1, 0xC3, 0x8A, 0x48, 0x3D, 0x74, 0xB5, 0xBC, 0x88,
0x48, 0x45, 0x87, 0xC0, 0xB5, 0x6E, 0x3B, 0x4F, 0x90, 0xC0, 0xB0, 0x72,
0x40, 0x48, 0x90, 0xCA, 0xB9, 0x6B, 0x2D, 0x46, 0x98, 0xCD, 0xB7, 0x67,
0x31, 0x4A, 0x99, 0xD1, 0xBB, 0x66, 0x28, 0x42, 0x97, 0xD0, 0xBD, 0x70,
0x33, 0x3E, 0x8C, 0xCD, 0xC8, 0x75, 0x2D, 0x36, 0x87, 0xCB, 0xC4, 0x79,
0x3D, 0x45, 0x87, 0xC1, 0xB0, 0x76, 0x44, 0x47, 0x8E, 0xB6, 0xAE, 0x88,
0x47, 0x4C, 0x83, 0xA8, 0xB2, 0x7C, 0x59, 0x51, 0x84, 0xAE, 0x9D, 0x74,
0x5D, 0x73, 0x5D, 0xCC, 0xBE, 0x25, 0x46, 0xD1, 0x43, 0xB9, 0xAD, 0x1A,
0xC8, 0x3F, 0x8B, 0xC5, 0x48, 0x91, 0x5E, 0xA4, 0x60, 0x9E, 0x7A, 0x84,
0x84, 0x32, 0xF3, 0x38, 0xA3, 0x57, 0xAA, 0x63, 0x88, 0x89, 0x6F, 0x9B,
0x89, 0x25, 0x9E, 0xD2, 0x6E, 0x5A, 0x76, 0x79, 0x82, 0xA1, 0x6F, 0x7D,
0xB1, 0x2C, 0x83, 0xCF, 0x3E, 0xAE, 0x5E, 0x76, 0x76, 0x88, 0xCC, 0x4E,
0x59, 0xA9, 0x57, 0x94, 0x93, 0x8D, 0x5E, 0x70, 0x98, 0x5C, 0xC7, 0x5F,
0x7A, 0x6F, 0x83, 0x9F, 0x5B, 0xA5, 0x5E, 0x94, 0x5F, 0x79, 0xCC, 0x63,
0x75, 0x77, 0x51, 0xB0, 0x93, 0x7A, 0x7F, 0x51, 0xA4, 0x7C, 0x7C, 0xA6,
0x5C, 0x62, 0x98, 0x81, 0x8D, 0x7D, 0x84, 0x71, 0x72, 0x83, 0x8D, 0xA0,
0x69, 0x5C, 0x87, 0x92, 0x97, 0x6C, 0x6B, 0x88, 0x7A, 0x8C, 0x98, 0x6F,
0x7D, 0x68, 0x7A, 0x9B, 0x90, 0x6A, 0x7C, 0x7D, 0x7E, 0x88, 0x86, 0x83,
0x74, 0x6E, 0x82, 0x8A, 0x94, 0x80, 0x68, 0x75, 0x8A, 0x8B, 0x83, 0x80,
0x72, 0x76, 0x8A, 0x86, 0x85, 0x7F, 0x75, 0x77, 0x8A, 0x84, 0x7B, 0x8A,
0x78, 0x7B, 0x82, 0x7E, 0x7B, 0x88, 0x83, 0x7A, 0x84, 0x86, 0x72, 0x77,
0x8B, 0x86, 0x7C, 0x77, 0x87, 0x83, 0x7B, 0x83, 0x81, 0x73, 0x83, 0x7D,
0x85, 0x88, 0x77, 0x80, 0x80, 0x7E, 0x7B, 0x86, 0x83, 0x78, 0x82, 0x7B,
0x85, 0x84, 0x7C, 0x7C, 0x81, 0x82, 0x7E, 0x7E, 0x84, 0x7B, 0x78, 0x85,
0x84, 0x87, 0x7F, 0x72, 0x77, 0x88, 0x88, 0x7E, 0x7C, 0x86, 0x72, 0x7F,
0x94, 0x7B, 0x7A, 0x75, 0x78, 0x85, 0x96, 0x90, 0x71, 0x62, 0x6B, 0x91,
0xA6, 0x94, 0x65, 0x52, 0x73, 0xA4, 0xAD, 0x8C, 0x52, 0x44, 0x82, 0xB9,
0xB5, 0x77, 0x3E, 0x4F, 0x92, 0xBD, 0xB0, 0x69, 0x3A, 0x58, 0x9B, 0xC7,
0xA6, 0x59, 0x34, 0x66, 0xAA, 0xC5, 0x98, 0x51, 0x3C, 0x67, 0xAE, 0xCB,
0x8D, 0x50, 0x42, 0x65, 0xAD, 0xC5, 0x8F, 0x5C, 0x47, 0x5F, 0xA2, 0xB3,
0xA0, 0x6C, 0x4B, 0x65, 0x89, 0xAC, 0x9F, 0x69, 0x5F, 0x72, 0x8D, 0x9B,
0x93, 0x74, 0x5A, 0x6A, 0x7E, 0xA6, 0xAC, 0x85, 0x53, 0x51, 0x83, 0x9E,
0xA2, 0x7E, 0x59, 0x68, 0x97, 0xA7, 0x85, 0x66, 0x6A, 0x6C, 0x93, 0x9D,
0x89, 0x6F, 0x61, 0x80, 0x99, 0x9A, 0x76, 0x5D, 0x74, 0x8A, 0x8B, 0x94,
0x82, 0x6E, 0x76, 0x79, 0x87, 0x82, 0x8C, 0x8B, 0x6E, 0x6F, 0x7A, 0x8B,
0x9C, 0x7C, 0x6A, 0x72, 0x83, 0x93, 0x8B, 0x7B, 0x74, 0x74, 0x77, 0x85,
0x95, 0x86, 0x86, 0x77, 0x67, 0x74, 0x8F, 0x96, 0x86, 0x6D, 0x6D, 0x84,
0x8E, 0x92, 0x7C, 0x70, 0x75, 0x77, 0x85, 0x8C, 0x8D, 0x84, 0x79, 0x6D,
0x72, 0x88, 0x99, 0x85, 0x6C, 0x71, 0x80, 0x8A, 0x94, 0x81, 0x6E, 0x74,
0x80, 0x86, 0x8D, 0x80, 0x73, 0x7A, 0x8B, 0x86, 0x78, 0x7E, 0x7F, 0x7F,
0x7C, 0x84, 0x81, 0x83, 0x85, 0x7B, 0x75, 0x75, 0x7F, 0x97, 0x91, 0x72,
0x6C, 0x73, 0x8D, 0x95, 0x7F, 0x70, 0x73, 0x86, 0x88, 0x83, 0x85, 0x7B,
0x6E, 0x7C, 0x89, 0x8D, 0x88, 0x75, 0x6F, 0x73, 0x88, 0x98, 0x8F, 0x73,
0x65, 0x70, 0x8D, 0x9A, 0x86, 0x76, 0x6A, 0x7A, 0x89, 0x95, 0x83, 0x6E,
0x77, 0x79, 0x80, 0x98, 0x8B, 0x6D, 0x6A, 0x7E, 0x93, 0x91, 0x80, 0x6E,
0x6E, 0x80, 0x8B, 0x90, 0x83, 0x73, 0x70, 0x84, 0x8D, 0x7F, 0x7A, 0x84,
0x75, 0x76, 0x90, 0x8B, 0x7D, 0x6F, 0x71, 0x90, 0x97, 0x7A, 0x6E, 0x75,
0x87, 0x89, 0x83, 0x7F, 0x7A, 0x7C, 0x87, 0x7B, 0x7F, 0x85, 0x80, 0x7B,
0x7B, 0x83, 0x89, 0x7C, 0x76, 0x81, 0x85, 0x86, 0x83, 0x71, 0x74, 0x87,
0x90, 0x80, 0x77, 0x79, 0x80, 0x88, 0x84, 0x77, 0x7B, 0x87, 0x7D, 0x80,
0x82, 0x81, 0x80, 0x7D, 0x75, 0x82, 0x8F, 0x84, 0x78, 0x73, 0x7C, 0x85,
0x95, 0x81, 0x6C, 0x75, 0x86, 0x90, 0x81, 0x7B, 0x75, 0x7D, 0x85, 0x83,
0x84, 0x86, 0x72, 0x73, 0x85, 0x89, 0x8A, 0x7E, 0x7B, 0x70, 0x7A, 0x8E,
0x8C, 0x82, 0x71, 0x71, 0x88, 0x8E, 0x80, 0x7B, 0x7B, 0x79, 0x7D, 0x8D,
0x88, 0x79, 0x7B, 0x7B, 0x80, 0x83, 0x80, 0x83, 0x86, 0x7D, 0x6F, 0x80,
0x8B, 0x82, 0x80, 0x7E, 0x75, 0x7D, 0x8B, 0x87, 0x7C, 0x73, 0x7E, 0x86,
0x88, 0x7C, 0x78, 0x87, 0x7C, 0x7C, 0x82, 0x80, 0x7E, 0x81, 0x87, 0x7C,
0x77, 0x81, 0x80, 0x85, 0x81, 0x7A, 0x7F, 0x7D, 0x83, 0x83, 0x80, 0x7C,
0x78, 0x81, 0x85, 0x83, 0x82, 0x7C, 0x7E, 0x75, 0x7E, 0x8B, 0x8A, 0x7C,
0x73, 0x7A, 0x84, 0x8A, 0x80, 0x7C, 0x78, 0x80, 0x82, 0x7E, 0x89, 0x7E,
0x7D, 0x77, 0x80, 0x81, 0x87, 0x85, 0x7B, 0x78, 0x7D, 0x89, 0x81, 0x7C,
0x7A, 0x84, 0x81, 0x83, 0x7E, 0x7A, 0x83, 0x7F, 0x80, 0x7B, 0x82, 0x87,
0x7E, 0x78, 0x81, 0x80, 0x85, 0x75, 0x82, 0x88, 0x7B, 0x7F, 0x7D, 0x86,
0x7B, 0x7F, 0x7F, 0x78, 0x8A, 0x84, 0x7C, 0x7A, 0x7B, 0x84, 0x87, 0x7D,
0x79, 0x80, 0x85, 0x80, 0x7C, 0x80, 0x81, 0x7D, 0x7B, 0x83, 0x83, 0x83,
0x7C, 0x78, 0x7E, 0x85, 0x87, 0x7E, 0x79, 0x78, 0x86, 0x83, 0x87, 0x7E,
0x76, 0x7E, 0x7E, 0x85, 0x82, 0x81, 0x81, 0x7A, 0x7E, 0x81, 0x81, 0x7F,
0x80, 0x7E, 0x7A, 0x83, 0x89, 0x7C, 0x7C, 0x7E, 0x7C, 0x82, 0x84, 0x81,
0x7D, 0x7F, 0x80, 0x79, 0x82, 0x84, 0x82, 0x7F, 0x76, 0x7F, 0x83, 0x84,
0x84, 0x7C, 0x76, 0x7F, 0x85, 0x83, 0x7F, 0x7E, 0x7C, 0x7D, 0x85, 0x82,
0x7E, 0x80, 0x7C, 0x80, 0x80, 0x82, 0x7E, 0x7C, 0x88, 0x7F, 0x78, 0x7C,
0x82, 0x87, 0x80, 0x7A, 0x7C, 0x84, 0x84, 0x7E, 0x80, 0x7B, 0x7E, 0x82,
0x82, 0x82, 0x7B, 0x7E, 0x82, 0x80, 0x7E, 0x7E, 0x84, 0x80, 0x7C, 0x7A,
0x83, 0x87, 0x80, 0x7B, 0x7D, 0x7E, 0x80, 0x84, 0x7F, 0x7E, 0x81, 0x7D,
0x7D, 0x84, 0x82, 0x7B, 0x7D, 0x84, 0x7D, 0x7F, 0x84, 0x7F, 0x7E, 0x7D,
0x80, 0x80, 0x82, 0x81, 0x7B, 0x7F, 0x7F, 0x7F, 0x84, 0x83, 0x7C, 0x7A,
0x80, 0x80, 0x82, 0x82, 0x7E, 0x7C, 0x7E, 0x7E, 0x87, 0x82, 0x7A, 0x7B,
0x7E, 0x85, 0x81, 0x7E, 0x7E, 0x84, 0x7C, 0x7C, 0x80, 0x83, 0x81, 0x7E,
0x7B, 0x80, 0x85, 0x80, 0x7D, 0x7E, 0x80, 0x7E, 0x80, 0x83, 0x7E, 0x7A,
0x83, 0x81, 0x7F, 0x80, 0x7A, 0x82, 0x82, 0x80, 0x7D, 0x7E, 0x84, 0x7C,
0x82, 0x7E, 0x7E, 0x81, 0x80, 0x82, 0x7C, 0x7E, 0x83, 0x7F, 0x7E, 0x7F,
0x7E, 0x82, 0x7E, 0x82, 0x80, 0x7E, 0x7D, 0x81, 0x82, 0x7E, 0x7D, 0x80,
0x83, 0x7E, 0x80, 0x7E, 0x80, 0x81, 0x81, 0x7C, 0x7E, 0x82, 0x7E, 0x82,
0x7F, 0x7D, 0x7F, 0x82, 0x80, 0x7E, 0x80, 0x7E, 0x82, 0x7F, 0x82, 0x7A,
0x80, 0x82, 0x80, 0x80, 0x7C, 0x82, 0x81, 0x7E, 0x7E, 0x80, 0x82, 0x7E,
0x7E, 0x82, 0x7E, 0x80, 0x7F, 0x7E, 0x82, 0x7D, 0x80, 0x82, 0x80, 0x7D,
0x7D, 0x85, 0x80, 0x7B, 0x80, 0x81, 0x81, 0x7F, 0x7F, 0x7D, 0x80, 0x82,
0x80, 0x7F, 0x7E, 0x7C, 0x83, 0x84, 0x7A, 0x7F, 0x81, 0x7F, 0x80, 0x80,
0x7F, 0x80, 0x80, 0x7E, 0x81, 0x80, 0x7C, 0x7E, 0x85, 0x80, 0x7A, 0x81,
0x83, 0x7D, 0x7D, 0x80, 0x7F, 0x81, 0x7F, 0x7F, 0x81, 0x7D, 0x81, 0x7E,
0x81, 0x7F, 0x7D, 0x85, 0x7E, 0x7C, 0x83, 0x80, 0x7C, 0x7E, 0x82, 0x81,
0x80, 0x7E, 0x7E, 0x7F, 0x83, 0x7A, 0x80, 0x86, 0x7E, 0x7C, 0x80, 0x82,
0x7D, 0x81, 0x82, 0x7E, 0x7D, 0x81, 0x80, 0x81, 0x7E, 0x7E, 0x82, 0x80,
0x7E, 0x7E, 0x80, 0x80, 0x80, 0x7E, 0x7E, 0x81, 0x81, 0x7E, 0x7E, 0x82,
0x7D, 0x7F, 0x82, 0x82, 0x7C, 0x7C, 0x81, 0x83, 0x7E, 0x7C, 0x83, 0x7E,
0x7E, 0x84, 0x7C, 0x7E, 0x81, 0x82, 0x7D, 0x7E, 0x80, 0x84, 0x7E, 0x7E,
0x80, 0x80, 0x82, 0x7E, 0x7C, 0x81, 0x80, 0x7E, 0x83, 0x80, 0x7B, 0x7E,
0x82, 0x84, 0x7E, 0x7E, 0x7E, 0x82, 0x81, 0x7C, 0x7E, 0x82, 0x82, 0x7D,
0x7F, 0x81, 0x7C, 0x81, 0x85, 0x79, 0x7E, 0x85, 0x7E, 0x80, 0x7C, 0x80,
0x82, 0x81, 0x80, 0x79, 0x81, 0x84, 0x80, 0x7C, 0x7E, 0x82, 0x82, 0x7E,
0x7E, 0x7E, 0x82, 0x81, 0x7C, 0x82, 0x82, 0x7C, 0x80, 0x84, 0x7C, 0x7C,
0x82, 0x82, 0x80, 0x7C, 0x80, 0x81, 0x81, 0x80, 0x7B, 0x80, 0x83, 0x7E,
0x80, 0x82, 0x7C, 0x80, 0x80, 0x80, 0x80, 0x80, 0x7C, 0x82, 0x84, 0x7A,
0x7C, 0x85, 0x82, 0x7A, 0x81, 0x84, 0x7C, 0x7E, 0x83, 0x7C, 0x80, 0x84,
0x7F, 0x7B, 0x82, 0x82, 0x7D, 0x81, 0x81, 0x7E, 0x7E, 0x82, 0x80, 0x7E,
0x80, 0x82, 0x7C, 0x81, 0x7F, 0x7F, 0x80, 0x80, 0x7F, 0x81, 0x7E, 0x80,
0x7F, 0x80, 0x80, 0x7D, 0x82, 0x82, 0x7A, 0x81, 0x82, 0x7F, 0x7D, 0x82,
0x7F, 0x7F, 0x81, 0x7B, 0x81, 0x81, 0x7E, 0x83, 0x7B, 0x7D, 0x86, 0x7A,
0x82, 0x7F, 0x80, 0x7E, 0x81, 0x82, 0x79, 0x82, 0x85, 0x78, 0x7F, 0x85,
0x7F, 0x7F, 0x7C, 0x81, 0x83, 0x7E, 0x7F, 0x7B, 0x89, 0x7E, 0x7A, 0x83,
0x80, 0x7C, 0x82, 0x84, 0x7C, 0x7B, 0x84, 0x80, 0x7B, 0x85, 0x7E, 0x7E,
0x7E, 0x83, 0x7E, 0x7E, 0x82, 0x7E, 0x7E, 0x83, 0x7E, 0x7E, 0x82, 0x80,
0x78, 0x85, 0x82, 0x7E, 0x7F, 0x7B, 0x84, 0x81, 0x7F, 0x80, 0x7B, 0x84,
0x80, 0x7C, 0x84, 0x7E, 0x7C, 0x84, 0x80, 0x7C, 0x80, 0x81, 0x7F, 0x7E,
0x7E, 0x84, 0x7D, 0x7E, 0x82, 0x7E, 0x7E, 0x82, 0x7F, 0x7E, 0x82, 0x7F,
0x80, 0x80, 0x7C, 0x81, 0x83, 0x7F, 0x7E, 0x7C, 0x82, 0x84, 0x7C, 0x7F,
0x80, 0x80, 0x7F, 0x80, 0x80, 0x7F, 0x7F, 0x7F, 0x7F, 0x81, 0x80, 0x7D,
0x7F, 0x80, 0x82, 0x7D, 0x86, 0x7A, 0x76, 0x8F, 0x7E, 0x77, 0x80, 0x85,
0x7F, 0x7C, 0x81, 0x81, 0x7D, 0x82, 0x80, 0x7E, 0x81, 0x7C, 0x80, 0x84,
0x80, 0x79, 0x7D, 0x84, 0x8D, 0x89, 0x6A, 0x50, 0x94, 0xCF, 0x80, 0x37,
0x5A, 0xB6, 0xB0, 0x64, 0x4B, 0x88, 0xB7, 0x85, 0x58, 0x62, 0x8C, 0xAC,
0x8E, 0x56, 0x61, 0x98, 0xA6, 0x7A, 0x59, 0x77, 0x9A, 0x91, 0x79, 0x69,
0x76, 0x8F, 0x98, 0x74, 0x67, 0x82, 0x91, 0x88, 0x7A, 0x6A, 0x80, 0x95,
0x87, 0x6D, 0x75, 0x87, 0x8F, 0x83, 0x6A, 0x7B, 0x8F, 0x8A, 0x72, 0x76,
0x85, 0x88, 0x86, 0x76, 0x77, 0x84, 0x86, 0x82, 0x79, 0x7A, 0x87, 0x7D,
0x87, 0x80, 0x6E, 0x7D, 0x97, 0x7B, 0x77, 0x7E, 0x7B, 0x96, 0x74, 0x6E,
0x89, 0x91, 0x7F, 0x74, 0x6C, 0x9A, 0x7B, 0x7E, 0x7F, 0x7C, 0x89, 0x76,
0x84, 0x79, 0x8B, 0x79, 0x73, 0x9B, 0x72, 0x6A, 0xA1, 0x75, 0x7F, 0x7F,
0x6D, 0x9C, 0x6D, 0x86, 0x8F, 0x60, 0x9E, 0x77, 0x60, 0xA8, 0x6B, 0x8F,
0x74, 0x7E, 0x93, 0x62, 0x92, 0x69, 0xA8, 0x6A, 0x7B, 0x87, 0x69, 0x99,
0x77, 0x89, 0x69, 0xA4, 0x6F, 0x58, 0xB1, 0x7B, 0x5E, 0x9F, 0x77, 0x97,
0x54, 0x93, 0x90, 0x3D, 0xCD, 0x8C, 0x41, 0x8B, 0x7E, 0x9D, 0x7D, 0x69,
0x72, 0xA8, 0x8E, 0x30, 0xB3, 0x8E, 0x60, 0x83, 0x99, 0x67, 0x94, 0x66,
0x97, 0x4E, 0xBA, 0x7B, 0x59, 0xBB, 0x38, 0xB5, 0x54, 0xA8, 0x69, 0x95,
0x6D, 0x78, 0xA5, 0x3B, 0xD4, 0x3A, 0x87, 0xC9, 0x2B, 0xB5, 0x64, 0x5E,
0xB9, 0x8A, 0x43, 0xA2, 0x95, 0x63, 0x74, 0x8E, 0x8A, 0x71, 0x80, 0x8C,
0x87, 0x71, 0x71, 0x8F, 0x83, 0x7D, 0x70, 0x8E, 0x96, 0x6D, 0x69, 0x85,
0x93, 0x83, 0x69, 0x7A, 0x9B, 0x88, 0x68, 0x6C, 0x90, 0x96, 0x75, 0x69,
0x89, 0x9A, 0x7B, 0x65, 0x79, 0x95, 0x8A, 0x6F, 0x72, 0x92, 0x92, 0x70,
0x68, 0x85, 0x97, 0x80, 0x69, 0x7C, 0x99, 0x89, 0x67, 0x6E, 0x90, 0x98,
0x76, 0x65, 0x83, 0x9E, 0x84, 0x61, 0x6E, 0x97, 0x98, 0x74, 0x61, 0x83,
0xA1, 0x86, 0x5F, 0x6E, 0x96, 0x98, 0x75, 0x64, 0x81, 0x9E, 0x8A, 0x65,
0x68, 0x8D, 0x9C, 0x7F, 0x62, 0x74, 0x9F, 0xA6, 0x6B, 0x2F, 0x6C, 0xE8,
0xC7, 0x2F, 0x12, 0xA1, 0xF3, 0x88, 0x19, 0x59, 0xCD, 0xC4, 0x56, 0x2A,
0x76, 0xCC, 0xBA, 0x54, 0x2F, 0x7D, 0xCD, 0xA7, 0x49, 0x3E, 0x93, 0xC9,
0x95, 0x44, 0x4A, 0x9C, 0xBF, 0x86, 0x4A, 0x5D, 0xA1, 0xB1, 0x78, 0x4D,
0x6D, 0xA6, 0xA5, 0x6E, 0x54, 0x79, 0xA7, 0x98, 0x67, 0x5C, 0x87, 0xA4,
0x85, 0x64, 0x6E, 0x91, 0x95, 0x79, 0x6C, 0x7A, 0x8E, 0x8B, 0x7C, 0x73,
0x79, 0x89, 0x8A, 0x7D, 0x74, 0x7C, 0x8A, 0x86, 0x7A, 0x76, 0x80, 0x89,
0x84, 0x78, 0x78, 0x82, 0x89, 0x81, 0x76, 0x78, 0x87, 0x8B, 0x7B, 0x72,
0x80, 0x8B, 0x84, 0x78, 0x78, 0x82, 0x86, 0x81, 0x7B, 0x7C, 0x81, 0x85,
0x81, 0x7B, 0x7C, 0x81, 0x85, 0x80, 0x7C, 0x7C, 0x81, 0x85, 0x7F, 0x7C,
0x7D, 0x82, 0x84, 0x7E, 0x7A, 0x7F, 0x87, 0x83, 0x79, 0x79, 0x83, 0x86,
0x80, 0x7A, 0x80, 0x84, 0x7E, 0x7C, 0x7F, 0x81, 0x82, 0x7F, 0x7F, 0x7E,
0x7F, 0x80, 0x7E, 0x7F, 0x81, 0x84, 0x80, 0x79, 0x7B, 0x83, 0x87, 0x80,
0x79, 0x7B, 0x85, 0x86, 0x7D, 0x79, 0x7E, 0x87, 0x83, 0x7D, 0x79, 0x7F,
0x86, 0x83, 0x7C, 0x78, 0x81, 0x86, 0x82, 0x7C, 0x79, 0x80, 0x85, 0x80,
0x7D, 0x7F, 0x80, 0x80, 0x80, 0x7F, 0x7E, 0x80, 0x80, 0x82, 0x80, 0x7E,
0x7D, 0x7F, 0x82, 0x82, 0x7F, 0x7F, 0x7F, 0x7C, 0x80, 0x82, 0x80, 0x7E,
0x7F, 0x81, 0x81, 0x7E, 0x7C, 0x7E, 0x82, 0x84, 0x81, 0x7C, 0x7C, 0x80,
0x85, 0x80, 0x7A, 0x7E, 0x83, 0x82, 0x7F, 0x7F, 0x7E, 0x7D, 0x7F, 0x83,
0x82, 0x7E, 0x7A, 0x80, 0x85, 0x81, 0x7B, 0x7B, 0x82, 0x88, 0x83, 0x75,
0x75, 0x86, 0x90, 0x80, 0x70, 0x77, 0x8D, 0x8D, 0x76, 0x70, 0x84, 0x92,
0x82, 0x6D, 0x75, 0x8D, 0x8F, 0x79, 0x6F, 0x80, 0x8E, 0x84, 0x72, 0x76,
0x88, 0x8F, 0x7D, 0x70, 0x7B, 0x8B, 0x8B, 0x77, 0x71, 0x7F, 0x8F, 0x86,
0x76, 0x75, 0x80, 0x89, 0x87, 0x7B, 0x75, 0x7D, 0x89, 0x84, 0x7C, 0x7C,
0x7F, 0x82, 0x80, 0x7E, 0x7A, 0x80, 0x89, 0x84, 0x79, 0x77, 0x80, 0x87,
0x82, 0x7C, 0x7C, 0x82, 0x80, 0x7F, 0x7E, 0x80, 0x81, 0x81, 0x7F, 0x7E,
0x7E, 0x81, 0x80, 0x81, 0x7F, 0x7D, 0x7E, 0x83, 0x82, 0x7D, 0x7C, 0x82,
0x83, 0x7C, 0x79, 0x82, 0x87, 0x80, 0x78, 0x7D, 0x86, 0x84, 0x7C, 0x7C,
0x7D, 0x82, 0x85, 0x7F, 0x7A, 0x7C, 0x83, 0x83, 0x7E, 0x83, 0x8A, 0x7D,
0x65, 0x6E, 0x95, 0xA7, 0x8B, 0x61, 0x5A, 0x7C, 0xA0, 0xA0, 0x75, 0x5B,
0x70, 0x95, 0xA0, 0x83, 0x66, 0x64, 0x7F, 0x96, 0x94, 0x82, 0x70, 0x6E,
0x7C, 0x8B, 0x90, 0x84, 0x72, 0x6E, 0x7D, 0x90, 0x8E, 0x7E, 0x73, 0x74,
0x7E, 0x89, 0x8D, 0x83, 0x72, 0x71, 0x80, 0x90, 0x89, 0x77, 0x74, 0x83,
0x84, 0x77, 0x7C, 0x8F, 0x8B, 0x6E, 0x67, 0x8D, 0xA3, 0x7E, 0x56, 0x6C,
0xA3, 0xA6, 0x6F, 0x53, 0x7D, 0xA7, 0x8C, 0x60, 0x6B, 0x99, 0x99, 0x6E,
0x61, 0x89, 0xA1, 0x7F, 0x5F, 0x72, 0x9A, 0x93, 0x71, 0x6C, 0x86, 0x8D,
0x7B, 0x77, 0x89, 0x87, 0x71, 0x75, 0x91, 0x90, 0x6E, 0x69, 0x8C, 0x9C,
0x79, 0x64, 0x80, 0x9E, 0x81, 0x5D, 0x74, 0xA3, 0x99, 0x62, 0x5C, 0x91,
0xA8, 0x79, 0x56, 0x7A, 0xA8, 0x94, 0x5C, 0x5E, 0x97, 0xAA, 0x75, 0x50,
0x79, 0xAE, 0x9D, 0x5D, 0x50, 0x87, 0xB2, 0x95, 0x5C, 0x5A, 0x89, 0xA5,
0x8D, 0x66, 0x63, 0x88, 0x9F, 0x81, 0x68, 0x79, 0x92, 0x8C, 0x74, 0x69,
0x76, 0x95, 0xA1, 0x7E, 0x5B, 0x6C, 0x9C, 0x95, 0x67, 0x68, 0x98, 0xA0,
0x70, 0x5E, 0x7F, 0x9B, 0x83, 0x69, 0x79, 0x99, 0x90, 0x6A, 0x68, 0x85,
0x98, 0x85, 0x69, 0x6E, 0x92, 0xA0, 0x7A, 0x5B, 0x71, 0x9C, 0x97, 0x6E,
0x68, 0x89, 0x98, 0x7D, 0x6D, 0x7B, 0x89, 0x83, 0x7D, 0x7A, 0x7C, 0x89,
0x8E, 0x7E, 0x6E, 0x76, 0x87, 0x84, 0x7D, 0x86, 0x89, 0x79, 0x72, 0x80,
0x89, 0x7E, 0x79, 0x7F, 0x86, 0x84, 0x81, 0x7C, 0x75, 0x7C, 0x8F, 0x8A,
0x6F, 0x6B, 0x89, 0x98, 0x83, 0x70, 0x74, 0x87, 0x8C, 0x7E, 0x6F, 0x73,
0x8E, 0x9E, 0x83, 0x61, 0x6D, 0x90, 0x93, 0x79, 0x6C, 0x80, 0x93, 0x8C,
0x75, 0x6B, 0x7C, 0x93, 0x91, 0x71, 0x65, 0x7F, 0x98, 0x8B, 0x75, 0x77,
0x83, 0x83, 0x79, 0x7B, 0x82, 0x80, 0x80, 0x86, 0x84, 0x7C, 0x7D, 0x7D,
0x7A, 0x79, 0x87, 0x91, 0x7E, 0x6B, 0x77, 0x92, 0x92, 0x75, 0x68, 0x7D,
0x92, 0x8B, 0x74, 0x71, 0x7D, 0x90, 0x90, 0x7D, 0x6A, 0x6E, 0x87, 0x98,
0x8A, 0x6D, 0x64, 0x84, 0xA5, 0x93, 0x63, 0x58, 0x82, 0xA3, 0x94, 0x6E,
0x63, 0x7C, 0x96, 0x94, 0x7D, 0x69, 0x6B, 0x85, 0x9B, 0x92, 0x70, 0x62,
0x79, 0x98, 0x96, 0x7C, 0x6B, 0x71, 0x82, 0x8D, 0x91, 0x80, 0x68, 0x6D,
0x8F, 0xA0, 0x85, 0x64, 0x66, 0x83, 0x95, 0x93, 0x7F, 0x6C, 0x6B, 0x81,
0x98, 0x91, 0x77, 0x65, 0x6F, 0x8C, 0xA0, 0x91, 0x6A, 0x59, 0x77, 0xA0,
0xA0, 0x7D, 0x60, 0x68, 0x85, 0x9B, 0x93, 0x7B, 0x68, 0x6B, 0x80, 0x97,
0x9C, 0x83, 0x5F, 0x5B, 0x86, 0xAA, 0x9B, 0x6E, 0x58, 0x6F, 0x92, 0xA2,
0x8D, 0x6B, 0x60, 0x76, 0x91, 0x98, 0x8A, 0x75, 0x65, 0x70, 0x8F, 0x9F,
0x89, 0x68, 0x64, 0x80, 0x96, 0x96, 0x7F, 0x6A, 0x6C, 0x80, 0x91, 0x91,
0x81, 0x70, 0x6D, 0x80, 0x96, 0x8E, 0x72, 0x69, 0x7F, 0x94, 0x8C, 0x78,
0x70, 0x7A, 0x88, 0x8B, 0x7F, 0x76, 0x7B, 0x86, 0x86, 0x7A, 0x79, 0x84,
0x85, 0x7B, 0x7A, 0x82, 0x8A, 0x82, 0x75, 0x75, 0x83, 0x8D, 0x86, 0x79,
0x73, 0x7A, 0x8B, 0x8F, 0x7E, 0x6F, 0x74, 0x87, 0x8E, 0x83, 0x79, 0x78,
0x7D, 0x81, 0x82, 0x83, 0x83, 0x7E, 0x78, 0x7C, 0x86, 0x88, 0x7E, 0x75,
0x7A, 0x86, 0x88, 0x82, 0x7C, 0x79, 0x7B, 0x84, 0x88, 0x82, 0x7B, 0x78,
0x7D, 0x84, 0x86, 0x81, 0x7B, 0x7A, 0x7F, 0x81, 0x84, 0x84, 0x7E, 0x77,
0x78, 0x86, 0x8D, 0x81, 0x75, 0x75, 0x80, 0x89, 0x85, 0x7E, 0x78, 0x7C,
0x84, 0x85, 0x80, 0x7D, 0x7C, 0x7B, 0x7E, 0x87, 0x8B, 0x7E, 0x72, 0x77,
0x88, 0x8B, 0x80, 0x78, 0x7A, 0x83, 0x85, 0x80, 0x7C, 0x7A, 0x7E, 0x83,
0x85, 0x83, 0x7C, 0x78, 0x7D, 0x85, 0x85, 0x80, 0x7A, 0x7C, 0x80, 0x83,
0x83, 0x82, 0x7C, 0x7A, 0x7D, 0x83, 0x85, 0x81, 0x7C, 0x7A, 0x7E, 0x83,
0x85, 0x80, 0x78, 0x7A, 0x83, 0x89, 0x81, 0x78, 0x7A, 0x82, 0x84, 0x80,
0x7D, 0x80, 0x82, 0x7F, 0x7D, 0x7D, 0x80, 0x83, 0x82, 0x7F, 0x7D, 0x7F,
0x7F, 0x7F, 0x82, 0x81, 0x7E, 0x7D, 0x80, 0x82, 0x80, 0x7E, 0x7E, 0x80,
0x80, 0x80, 0x7F, 0x7F, 0x80, 0x7F, 0x80, 0x80, 0x7F, 0x7D, 0x7F, 0x82,
0x81, 0x7D, 0x7E, 0x81, 0x82, 0x7E, 0x7D, 0x7F, 0x82, 0x80, 0x7C, 0x7D,
0x82, 0x85, 0x80, 0x7B, 0x7A, 0x82, 0x84, 0x81, 0x7E, 0x7D, 0x7F, 0x81,
0x83, 0x82, 0x7C, 0x78, 0x7C, 0x88, 0x8A, 0x80, 0x74, 0x74, 0x82, 0x91,
0x89, 0x75, 0x6E, 0x7B, 0x8D, 0x90, 0x80, 0x70, 0x70, 0x80, 0x92, 0x91,
0x7D, 0x68, 0x6E, 0x88, 0x9A, 0x8E, 0x70, 0x64, 0x78, 0x94, 0x98, 0x82,
0x68, 0x68, 0x83, 0x99, 0x94, 0x77, 0x65, 0x6F, 0x8C, 0x9B, 0x8C, 0x71,
0x65, 0x75, 0x90, 0x98, 0x87, 0x72, 0x69, 0x76, 0x8D, 0x97, 0x89, 0x72,
0x6A, 0x78, 0x8C, 0x91, 0x82, 0x75, 0x73, 0x80, 0x8B, 0x89, 0x7F, 0x75,
0x73, 0x7C, 0x8B, 0x90, 0x86, 0x72, 0x6D, 0x7E, 0x90, 0x8D, 0x7A, 0x70,
0x79, 0x89, 0x8F, 0x82, 0x73, 0x73, 0x80, 0x8B, 0x89, 0x7D, 0x76, 0x79,
0x85, 0x89, 0x83, 0x78, 0x76, 0x7E, 0x87, 0x87, 0x80, 0x7B, 0x7B, 0x7E,
0x81, 0x82, 0x82, 0x82, 0x7D, 0x79, 0x7D, 0x86, 0x87, 0x7F, 0x78, 0x7A,
0x82, 0x87, 0x84, 0x7D, 0x7A, 0x7B, 0x7F, 0x84, 0x86, 0x83, 0x7C, 0x77,
0x7B, 0x84, 0x87, 0x82, 0x7B, 0x7A, 0x80, 0x83, 0x83, 0x81, 0x7C, 0x7B,
0x7C, 0x81, 0x85, 0x85, 0x80, 0x79, 0x79, 0x80, 0x85, 0x85, 0x7E, 0x79,
0x7C, 0x83, 0x85, 0x82, 0x7D, 0x7B, 0x7B, 0x81, 0x85, 0x83, 0x7D, 0x7B,
0x7F, 0x83, 0x82, 0x7D, 0x7C, 0x80, 0x81, 0x82, 0x7E, 0x80, 0x82, 0x7F,
0x7B, 0x7A, 0x83, 0x89, 0x83, 0x79, 0x77, 0x7F, 0x87, 0x85, 0x7D, 0x7A,
0x7C, 0x81, 0x83, 0x82, 0x7E, 0x7B, 0x7C, 0x82, 0x87, 0x82, 0x7A, 0x78,
0x7D, 0x84, 0x88, 0x84, 0x7B, 0x75, 0x7C, 0x86, 0x89, 0x80, 0x78, 0x79,
0x80, 0x87, 0x85, 0x7E, 0x79, 0x7B, 0x82, 0x87, 0x84, 0x7B, 0x77, 0x7C,
0x85, 0x8A, 0x81, 0x75, 0x77, 0x82, 0x87, 0x85, 0x7E, 0x79, 0x7C, 0x82,
0x84, 0x82, 0x7E, 0x7C, 0x7E, 0x80, 0x82, 0x82, 0x7C, 0x7C, 0x80, 0x85,
0x83, 0x7C, 0x7A, 0x7E, 0x84, 0x83, 0x7F, 0x7C, 0x7D, 0x81, 0x82, 0x80,
0x7E, 0x7F, 0x80, 0x7F, 0x80, 0x7F, 0x7E, 0x80, 0x82, 0x82, 0x7E, 0x7B,
0x7E, 0x82, 0x81, 0x80, 0x7E, 0x80, 0x80, 0x7E, 0x7F, 0x80, 0x82, 0x7E,
0x7E, 0x80, 0x82, 0x82, 0x7D, 0x7C, 0x7E, 0x83, 0x84, 0x80, 0x7D, 0x7B,
0x7F, 0x83, 0x83, 0x7F, 0x7B, 0x7C, 0x80, 0x84, 0x82, 0x7D, 0x7B, 0x7E,
0x84, 0x83, 0x80, 0x7B, 0x7B, 0x80, 0x85, 0x85, 0x7F, 0x7A, 0x7B, 0x81,
0x83, 0x82, 0x7F, 0x7D, 0x7C, 0x80, 0x83, 0x83, 0x7E, 0x7B, 0x7E, 0x82,
0x83, 0x81, 0x7E, 0x7C, 0x7E, 0x81, 0x82, 0x81, 0x80, 0x7E, 0x7D, 0x7E,
0x81, 0x82, 0x80, 0x7D, 0x7E, 0x80, 0x81, 0x82, 0x7E, 0x7D, 0x7E, 0x80,
0x82, 0x80, 0x80, 0x7E, 0x7E, 0x80, 0x80, 0x7F, 0x80, 0x81, 0x80, 0x7E,
0x7C, 0x80, 0x83, 0x81, 0x7F, 0x7C, 0x7E, 0x82, 0x82, 0x80, 0x7C, 0x7E,
0x81, 0x82, 0x80, 0x7F, 0x7F, 0x7E, 0x7E, 0x7F, 0x83, 0x83, 0x7E, 0x7B,
0x7D, 0x82, 0x84, 0x82, 0x7C, 0x7C, 0x7F, 0x82, 0x83, 0x7F, 0x7C, 0x7E,
0x80, 0x81, 0x81, 0x7F, 0x7F, 0x7E, 0x7F, 0x80, 0x81, 0x80, 0x7E, 0x7F,
0x80, 0x81, 0x7F, 0x7F, 0x7E, 0x7F, 0x80, 0x80, 0x81, 0x80, 0x7F, 0x7F,
0x7F, 0x7F, 0x7F, 0x80, 0x81, 0x7E, 0x7F, 0x80, 0x80, 0x80, 0x7E, 0x7E,
0x80, 0x82, 0x82, 0x7F, 0x7D, 0x7F, 0x81, 0x81, 0x7F, 0x7E, 0x7F, 0x80,
0x81, 0x81, 0x7F, 0x7D, 0x7E, 0x80, 0x82, 0x80, 0x7E, 0x7E, 0x80, 0x80,
0x80, 0x80, 0x7E, 0x7E, 0x7F, 0x81, 0x81, 0x81, 0x7E, 0x7C, 0x7E, 0x82,
0x83, 0x80, 0x7C, 0x7D, 0x80, 0x82, 0x80, 0x7E, 0x7E, 0x80, 0x80, 0x80,
0x80, 0x80, 0x7F, 0x7D, 0x7E, 0x82, 0x83, 0x81, 0x7D, 0x7C, 0x7F, 0x82,
0x81, 0x7F, 0x7E, 0x7F, 0x80, 0x80, 0x80, 0x80, 0x7E, 0x7E, 0x7F, 0x81,
0x82, 0x7F, 0x7D, 0x7E, 0x80, 0x82, 0x80, 0x7E, 0x7E, 0x80, 0x80, 0x7F,
0x80, 0x81, 0x81, 0x7F, 0x7D, 0x7F, 0x81, 0x82, 0x80, 0x7E, 0x7E, 0x80,
0x81, 0x80, 0x7F, 0x7E, 0x7F, 0x80, 0x80, 0x80, 0x7F, 0x80, 0x80, 0x7E,
0x7F, 0x80, 0x81, 0x80, 0x7D, 0x7E, 0x81, 0x82, 0x80, 0x7D, 0x7E, 0x81,
0x82, 0x80, 0x7E, 0x7E, 0x80, 0x81, 0x80, 0x80, 0x7F, 0x7E, 0x7F, 0x80,
0x80, 0x80, 0x80, 0x7E, 0x7F, 0x80, 0x81, 0x80, 0x7F, 0x7E, 0x7F, 0x80,
0x81, 0x81, 0x80, 0x7E, 0x7D, 0x80, 0x81, 0x81, 0x7E, 0x7E, 0x7F, 0x81,
0x81, 0x80, 0x7E, 0x7E, 0x7F, 0x80, 0x81, 0x81, 0x7F, 0x7D, 0x7E, 0x81,
0x82, 0x7F, 0x7D, 0x7E, 0x81, 0x82, 0x7F, 0x7E, 0x7E, 0x80, 0x81, 0x80,
0x7F, 0x7F, 0x7F, 0x7F, 0x7F, 0x80, 0x80, 0x80, 0x80, 0x7F, 0x7F, 0x7F,
0x80, 0x80, 0x80, 0x7F, 0x7F, 0x7F, 0x80, 0x80, 0x80, 0x7F, 0x7E, 0x7F,
0x80, 0x81, 0x80, 0x7E, 0x7E, 0x80, 0x81, 0x81, 0x7F, 0x7D, 0x7E, 0x81,
0x82, 0x7F, 0x7E, 0x7F, 0x80, 0x81, 0x7F, 0x7E, 0x7F, 0x80, 0x80, 0x80,
0x7F, 0x7E, 0x7F, 0x80, 0x80, 0x80, 0x7F, 0x7F, 0x80, 0x80, 0x80, 0x7F,
0x7F, 0x7F, 0x80, 0x80, 0x7F, 0x80, 0x80, 0x7F, 0x7F, 0x80, 0x81, 0x80,
0x7E, 0x7E, 0x80, 0x81, 0x80, 0x7F, 0x7E, 0x80, 0x81, 0x80, 0x7F, 0x7E,
0x80, 0x80, 0x80, 0x7F, 0x7F, 0x80, 0x80, 0x7F, 0x7E, 0x80, 0x82, 0x82,
0x7F, 0x7C, 0x7E, 0x81, 0x82, 0x80, 0x7D, 0x7E, 0x81, 0x82, 0x80, 0x7E,
0x7E, 0x7F, 0x81, 0x81, 0x80, 0x7F, 0x7E, 0x7F, 0x80, 0x80, 0x80, 0x7F,
0x7E, 0x7F, 0x80, 0x80, 0x80, 0x7F, 0x7F, 0x7E, 0x7F, 0x81, 0x81, 0x7F,
0x7E, 0x7E, 0x80, 0x80, 0x80, 0x80, 0x7F, 0x7E, 0x80, 0x81, 0x81, 0x80,
0x7E, 0x7E, 0x7F, 0x81, 0x81, 0x7F, 0x7E, 0x7F, 0x80, 0x81, 0x80, 0x7F,
0x7E, 0x7F, 0x80, 0x81, 0x80, 0x7F, 0x7D, 0x7E, 0x81, 0x82, 0x80, 0x7E,
0x7E, 0x7F, 0x80, 0x80, 0x80, 0x7F, 0x7E, 0x80, 0x80, 0x80, 0x7F, 0x7F,
0x7F, 0x7F, 0x80, 0x80, 0x80, 0x7F, 0x7F, 0x80, 0x80, 0x80, 0x7F, 0x7E,
0x7F, 0x80, 0x81, 0x80, 0x7F, 0x7F, 0x7F, 0x80, 0x80, 0x7F, 0x7F, 0x7F,
0x80, 0x7F, 0x7F, 0x80, 0x80, 0x80, 0x7E, 0x7F, 0x80, 0x80, 0x80, 0x7F,
0x7E, 0x7F, 0x80, 0x81, 0x7F, 0x7F, 0x7F, 0x80, 0x80, 0x80, 0x7F, 0x80,
0x7F, 0x7F, 0x80, 0x80, 0x80, 0x7F, 0x7F, 0x80, 0x80, 0x80, 0x80, 0x7F,
0x7F, 0x80, 0x80, 0x80, 0x7F, 0x7F, 0x7F, 0x80, 0x80, 0x80, 0x80, 0x7F,
0x7F, 0x80, 0x80, 0x80, 0x80, 0x7F, 0x7F, 0x80, 0x81, 0x80, 0x7F, 0x7E,
0x7F, 0x80, 0x80, 0x80, 0x7F, 0x7E, 0x80, 0x81, 0x80, 0x7F, 0x7E, 0x80,
0x80, 0x80, 0x7F, 0x7E, 0x7F, 0x80, 0x81, 0x80, 0x7F, 0x7E, 0x7F, 0x80,
0x80, 0x80, 0x7E, 0x7F, 0x80, 0x81, 0x80, 0x7E, 0x7E, 0x80, 0x81, 0x80,
0x7F, 0x7E, 0x7F, 0x80, 0x80, 0x80, 0x7E, 0x7F, 0x80, 0x81, 0x80, 0x7F,
0x7E, 0x7F, 0x81, 0x81, 0x7F, 0x7F, 0x7F, 0x80, 0x80, 0x80, 0x7F, 0x7F,
0x80, 0x80, 0x80, 0x7F, 0x80, 0x80, 0x80, 0x7F, 0x7F, 0x7F, 0x80, 0x80,
0x80, 0x7F, 0x7F, 0x80, 0x80, 0x80, 0x7E, 0x7F, 0x80, 0x80, 0x80, 0x80,
0x7E, 0x7F, 0x80, 0x80, 0x80, 0x7F, 0x7E, 0x7F, 0x80, 0x80, 0x80, 0x7F,
0x7F, 0x80, 0x80, 0x80, 0x7F, 0x7F, 0x7F, 0x80, 0x80, 0x80, 0x80, 0x7E,
0x7F, 0x80, 0x80, 0x80, 0x80, 0x7F, 0x7F, 0x80, 0x80, 0x7F, 0x7F, 0x7F,
0x7F, 0x80, 0x80, 0x80, 0x7F, 0x7F, 0x7F, 0x80, 0x80, 0x80, 0x7F, 0x7E,
0x7F, 0x80, 0x80, 0x80, 0x7F, 0x7F, 0x80, 0x80, 0x80, 0x7F, 0x7E, 0x7F,
0x80, 0x80, 0x80, 0x7F, 0x7F, 0x7F, 0x80, 0x81, 0x80, 0x7E, 0x7E, 0x80,
0x81, 0x80, 0x7F, 0x7E, 0x7F, 0x80, 0x81, 0x80, 0x7F, 0x7E, 0x80, 0x80,
0x80, 0x7F, 0x7F, 0x7F, 0x80, 0x81, 0x80, 0x7F, 0x7F, 0x80, 0x80, 0x7F,
0x7F, 0x80, 0x80, 0x80, 0x7F, 0x7F, 0x7F, 0x7F, 0x7F, 0x80, 0x80, 0x80,
0x80, 0x80, 0x80, 0x7F, 0x7F, 0x7F, 0x80, 0x81, 0x80, 0x7F, 0x7F, 0x7F,
0x80, 0x80, 0x80, 0x7F, 0x7F, 0x80, 0x80, 0x80, 0x80, 0x7F, 0x7E, 0x7F,
0x80, 0x81, 0x80, 0x7F, 0x7F, 0x7F, 0x80, 0x80, 0x80, 0x7F, 0x7F, 0x80,
0x81, 0x80, 0x7F, 0x7F, 0x7F, 0x80, 0x80, 0x80, 0x7F, 0x7F, 0x7F, 0x80,
0x80, 0x80, 0x7F, 0x7F, 0x80, 0x80, 0x80, 0x7F, 0x7E, 0x7F, 0x80, 0x80,
0x80, 0x7F, 0x7E, 0x7F, 0x80, 0x81, 0x80, 0x7F, 0x7E, 0x7F, 0x80, 0x81,
0x80, 0x7F, 0x7E, 0x80, 0x80, 0x7F, 0x7F, 0x7F, 0x80, 0x80, 0x80, 0x80,
0x7F, 0x7F, 0x7F, 0x80, 0x80, 0x80, 0x80, 0x7F, 0x7F, 0x80, 0x80, 0x80,
0x7F, 0x7F, 0x7F, 0x80, 0x80, 0x7F, 0x7E, 0x7F, 0x80, 0x80, 0x80, 0x7F,
0x7F, 0x7F, 0x7F, 0x80, 0x81, 0x80, 0x7F, 0x7F, 0x7F, 0x80, 0x80, 0x80,
0x7F, 0x7E, 0x7F, 0x81, 0x80, 0x80, 0x7E, 0x7F, 0x80, 0x81, 0x80, 0x7F,
0x7E, 0x7F, 0x80, 0x81, 0x80, 0x7F, 0x7E, 0x80, 0x80, 0x80, 0x7F, 0x7E,
0x7F, 0x80, 0x80, 0x80, 0x7F, 0x7F, 0x7F, 0x7F, 0x80, 0x80, 0x80, 0x7F,
0x7F, 0x80, 0x80, 0x80, 0x7F, 0x7F, 0x7F, 0x80, 0x80, 0x7F, 0x7F, 0x80,
0x80, 0x7F, 0x7F, 0x7F, 0x7F, 0x7F, 0x7F, 0x80, 0x80, 0x80, 0x7F, 0x7E,
0x7F, 0x80, 0x81, 0x81, 0x7F, 0x7E, 0x7F, 0x80, 0x80, 0x80, 0x7F, 0x7F,
0x7F, 0x80, 0x80, 0x80, 0x7F, 0x7E, 0x80, 0x80, 0x80, 0x7F, 0x7F, 0x7F,
0x80, 0x80, 0x80, 0x80, 0x7F, 0x7F, 0x80, 0x80, 0x80, 0x80, 0x7E, 0x7E,
0x80, 0x81, 0x80, 0x7F, 0x7E, 0x7F, 0x80, 0x80, 0x7F, 0x7F, 0x7F, 0x80,
0x80, 0x80, 0x7F, 0x7F, 0x80, 0x80, 0x80, 0x7F, 0x7E, 0x7E, 0x80, 0x81,
0x80, 0x80, 0x7F, 0x7E, 0x7F, 0x80, 0x80, 0x80, 0x7F, 0x7F, 0x80, 0x80,
0x80, 0x7F, 0x7F, 0x7E, 0x80, 0x80, 0x81, 0x7F, 0x7F, 0x7F, 0x80, 0x80,
0x80, 0x7F, 0x7F, 0x7F, 0x80, 0x80, 0x80, 0x7F, 0x7F, 0x80, 0x80, 0x80,
0x7F, 0x7F, 0x7F, 0x80, 0x80, 0x80, 0x7F, 0x7F, 0x7F, 0x80, 0x80, 0x80,
0x80, 0x80, 0x7F, 0x7F, 0x7F, 0x7F, 0x80, 0x80, 0x80, 0x7F, 0x7F, 0x80,
0x80, 0x80, 0x7E, 0x7E, 0x80, 0x81, 0x80, 0x7F, 0x7F, 0x7F, 0x80, 0x80,
0x80, 0x7F, 0x7F, 0x80, 0x81, 0x80, 0x7F, 0x7E, 0x7F, 0x80, 0x81, 0x7F,
0x7E, 0x7E, 0x80, 0x81, 0x81, 0x80, 0x7E, 0x7D, 0x7E, 0x81, 0x82, 0x81,
0x7F, 0x7D, 0x7D, 0x80, 0x82, 0x82, 0x7F, 0x7A, 0x79, 0x82, 0x8D, 0x8B,
0x77, 0x64, 0x72, 0x96, 0xA3, 0x85, 0x5F, 0x5E, 0x85, 0xA4, 0x96, 0x70,
0x5F, 0x74, 0x94, 0x9B, 0x85, 0x6C, 0x69, 0x7A, 0x90, 0x96, 0x86, 0x70,
0x69, 0x79, 0x8F, 0x94, 0x83, 0x6F, 0x6E, 0x7E, 0x8F, 0x8E, 0x80, 0x73,
0x72, 0x7E, 0x8A, 0x8C, 0x81, 0x75, 0x73, 0x7E, 0x8A, 0x8B, 0x80, 0x74,
0x74, 0x80, 0x8B, 0x89, 0x7E, 0x75, 0x77, 0x82, 0x89, 0x86, 0x7D, 0x77,
0x7A, 0x83, 0x88, 0x84, 0x7C, 0x77, 0x7C, 0x84, 0x87, 0x83, 0x7C, 0x79,
0x7D, 0x83, 0x85, 0x82, 0x7D, 0x7B, 0x7E, 0x81, 0x83, 0x82, 0x7D, 0x7C,
0x7E, 0x82, 0x84, 0x81, 0x7D, 0x7C, 0x7F, 0x82, 0x82, 0x80, 0x7D, 0x7D,
0x7F, 0x81, 0x83, 0x80, 0x7E, 0x7C, 0x7F, 0x81, 0x82, 0x80, 0x7E, 0x7D,
0x7F, 0x82, 0x82, 0x7F, 0x7D, 0x7D, 0x7F, 0x82, 0x83, 0x80, 0x7D, 0x7C,
0x7F, 0x81, 0x82, 0x80, 0x7E, 0x7D, 0x80, 0x82, 0x82, 0x7F, 0x7D, 0x7E,
0x80, 0x81, 0x81, 0x7F, 0x7E, 0x7E, 0x7F, 0x81, 0x81, 0x7F, 0x7D, 0x7F,
0x81, 0x82, 0x80, 0x7F, 0x7E, 0x7E, 0x7F, 0x80, 0x81, 0x80, 0x7F, 0x7E,
0x7F, 0x81, 0x82, 0x80, 0x7E, 0x7E, 0x7F, 0x81, 0x81, 0x7F, 0x7E, 0x7F,
0x7F, 0x80, 0x80, 0x80, 0x80, 0x7F, 0x7F, 0x7F, 0x80, 0x80, 0x80, 0x7F,
0x7F, 0x7F, 0x80, 0x80, 0x80, 0x7E, 0x7E, 0x7F, 0x80, 0x81, 0x81, 0x80,
0x7E, 0x7E, 0x80, 0x81, 0x81, 0x7F, 0x7E, 0x7F, 0x80, 0x81, 0x80, 0x7F,
0x7E, 0x7F, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x7F, 0x7E, 0x7F, 0x81,
0x80, 0x7F, 0x7F, 0x80, 0x80, 0x80, 0x7F, 0x7E, 0x7F, 0x81, 0x80, 0x7F,
0x7F, 0x7F, 0x80, 0x80, 0x7F, 0x7E, 0x7F, 0x80, 0x80, 0x7F, 0x7E, 0x7F,
0x80, 0x80, 0x80, 0x7F, 0x7E, 0x7F, 0x80, 0x81, 0x81, 0x7F, 0x7E, 0x7E,
0x80, 0x81, 0x80, 0x7F, 0x7F, 0x80, 0x81, 0x80, 0x7F, 0x7E, 0x7E, 0x7F,
0x80, 0x81, 0x81, 0x80, 0x7F, 0x7E, 0x7F, 0x80, 0x81, 0x80, 0x7F, 0x7E,
0x80, 0x81, 0x80, 0x7E, 0x7D, 0x7E, 0x80, 0x82, 0x81, 0x7F, 0x7D, 0x7E,
0x80, 0x81, 0x81, 0x7F, 0x7E, 0x7F, 0x80, 0x81, 0x80, 0x7F, 0x7F, 0x7F,
0x80, 0x80, 0x80, 0x80, 0x80, 0x7F, 0x7F, 0x7F, 0x80, 0x80, 0x80, 0x7F,
0x7F, 0x80, 0x80, 0x80, 0x7F, 0x7F, 0x7F, 0x7F, 0x80, 0x80, 0x81, 0x80,
0x7E, 0x7E, 0x80, 0x81, 0x80, 0x7E, 0x7E, 0x80, 0x81, 0x81, 0x80, 0x7E,
0x7E, 0x7F, 0x81, 0x82, 0x81, 0x7F, 0x7D, 0x7E, 0x81, 0x82, 0x80, 0x7E,
0x7E, 0x80, 0x82, 0x81, 0x7E, 0x7D, 0x7E, 0x81, 0x83, 0x81, 0x7E, 0x7C,
0x7E, 0x80, 0x82, 0x81, 0x7E, 0x7D, 0x7F, 0x82, 0x82, 0x7F, 0x7D, 0x7E,
0x80, 0x82, 0x81, 0x7F, 0x7D, 0x7E, 0x80, 0x82, 0x81, 0x7E, 0x7D, 0x7E,
0x81, 0x82, 0x80, 0x7E, 0x7E, 0x80, 0x82, 0x80, 0x7E, 0x7D, 0x7F, 0x81,
0x82, 0x80, 0x7F, 0x7E, 0x7E, 0x80, 0x80, 0x80, 0x7F, 0x7F, 0x7F, 0x80,
0x80, 0x80, 0x7F, 0x7E, 0x7F, 0x80, 0x81, 0x80, 0x7F, 0x7E, 0x7E, 0x80,
0x81, 0x80, 0x7E, 0x7E, 0x7F, 0x81, 0x81, 0x7F, 0x7E, 0x7F, 0x80, 0x81,
0x80, 0x7E, 0x7E, 0x80, 0x81, 0x81, 0x7F, 0x7E, 0x7E, 0x80, 0x81, 0x80,
0x80, 0x7E, 0x7F, 0x80, 0x80, 0x80, 0x7F, 0x7F, 0x7F, 0x80, 0x80, 0x7F,
0x7F, 0x7F, 0x80, 0x80, 0x80, 0x80, 0x80, 0x7F, 0x7F, 0x7F, 0x80, 0x80,
0x7E, 0x7D, 0x7F, 0x84, 0x84, 0x7E, 0x78, 0x7A, 0x83, 0x8A, 0x84, 0x78,
0x74, 0x7E, 0x8B, 0x8B, 0x7D, 0x70, 0x76, 0x87, 0x90, 0x87, 0x74, 0x6F,
0x7C, 0x8D, 0x8E, 0x7E, 0x6F, 0x74, 0x86, 0x90, 0x86, 0x76, 0x71, 0x7D,
0x8B, 0x8B, 0x7E, 0x74, 0x78, 0x85, 0x89, 0x82, 0x79, 0x7A, 0x81, 0x85,
0x81, 0x7B, 0x7C, 0x83, 0x84, 0x7E, 0x7A, 0x7E, 0x85, 0x85, 0x7D, 0x77,
0x7C, 0x87, 0x89, 0x7F, 0x75, 0x78, 0x85, 0x8C, 0x83, 0x75, 0x74, 0x81,
0x8D, 0x88, 0x78, 0x71, 0x7C, 0x8C, 0x8E, 0x7E, 0x70, 0x74, 0x86, 0x90,
0x87, 0x75, 0x6F, 0x7C, 0x8D, 0x8F, 0x7F, 0x6F, 0x71, 0x84, 0x92, 0x8B,
0x78, 0x6D, 0x76, 0x88, 0x90, 0x87, 0x77, 0x70, 0x78, 0x87, 0x8E, 0x86,
0x79, 0x73, 0x7A, 0x87, 0x8B, 0x82, 0x77, 0x77, 0x80, 0x88, 0x87, 0x80,
0x79, 0x77, 0x7C, 0x86, 0x8A, 0x84, 0x78, 0x74, 0x7D, 0x89, 0x89, 0x7D,
0x74, 0x7A, 0x87, 0x8B, 0x80, 0x75, 0x77, 0x83, 0x8A, 0x84, 0x79, 0x77,
0x7F, 0x88, 0x86, 0x7C, 0x77, 0x7B, 0x84, 0x88, 0x83, 0x7B, 0x77, 0x7C,
0x85, 0x88, 0x82, 0x79, 0x76, 0x7E, 0x88, 0x88, 0x7F, 0x77, 0x7A, 0x82,
0x86, 0x81, 0x7C, 0x7D, 0x81, 0x81, 0x7F, 0x7F, 0x80, 0x80, 0x7E, 0x7E,
0x81, 0x83, 0x81, 0x7E, 0x7D, 0x7E, 0x7F, 0x7F, 0x81, 0x83, 0x81, 0x7C,
0x7A, 0x7F, 0x85, 0x85, 0x7E, 0x7A, 0x7C, 0x82, 0x85, 0x82, 0x7D, 0x7B,
0x7C, 0x7F, 0x83, 0x86, 0x82, 0x7B, 0x78, 0x7D, 0x86, 0x87, 0x80, 0x79,
0x7A, 0x81, 0x86, 0x85, 0x7E, 0x7A, 0x79, 0x7F, 0x85, 0x88, 0x82, 0x79,
0x76, 0x7D, 0x88, 0x89, 0x80, 0x76, 0x77, 0x81, 0x89, 0x87, 0x7F, 0x77,
0x77, 0x7F, 0x88, 0x89, 0x81, 0x76, 0x75, 0x7F, 0x89, 0x89, 0x7E, 0x76,
0x78, 0x82, 0x88, 0x85, 0x7D, 0x79, 0x7B, 0x7F, 0x84, 0x85, 0x82, 0x7C,
0x79, 0x7D, 0x83, 0x87, 0x82, 0x7A, 0x79, 0x7F, 0x86, 0x86, 0x7F, 0x79,
0x7B, 0x81, 0x84, 0x82, 0x7E, 0x7D, 0x7F, 0x80, 0x80, 0x80, 0x80, 0x80,
0x7F, 0x7E, 0x80, 0x82, 0x82, 0x7F, 0x7C, 0x7D, 0x81, 0x83, 0x82, 0x7E,
0x7B, 0x7E, 0x83, 0x85, 0x80, 0x7A, 0x7B, 0x81, 0x85, 0x83, 0x7D, 0x7B,
0x7E, 0x82, 0x83, 0x80, 0x7D, 0x7E, 0x80, 0x80, 0x80, 0x80, 0x81, 0x7F,
0x7D, 0x7D, 0x80, 0x83, 0x81, 0x7E, 0x7C, 0x7E, 0x82, 0x83, 0x7F, 0x7D,
0x7E, 0x81, 0x82, 0x80, 0x7E, 0x7F, 0x81, 0x81, 0x7F, 0x7E, 0x7F, 0x81,
0x81, 0x7F, 0x7E, 0x7F, 0x80, 0x80, 0x7F, 0x7F, 0x7F, 0x80, 0x80, 0x80,
0x7F, 0x7E, 0x7E, 0x80, 0x82, 0x81, 0x7E, 0x7D, 0x7F, 0x82, 0x82, 0x7F,
0x7D, 0x7E, 0x81, 0x82, 0x80, 0x7E, 0x7E, 0x7F, 0x81, 0x82, 0x80, 0x7D,
0x7D, 0x80, 0x83, 0x82, 0x7E, 0x7B, 0x7D, 0x82, 0x83, 0x80, 0x7D, 0x7D,
0x80, 0x82, 0x81, 0x7E, 0x7D, 0x7F, 0x81, 0x82, 0x80, 0x7E, 0x7D, 0x7F,
0x82, 0x82, 0x7F, 0x7D, 0x7E, 0x81, 0x82, 0x80, 0x7E, 0x7E, 0x7F, 0x80,
0x81, 0x80, 0x7F, 0x7F, 0x7F, 0x80, 0x7F, 0x7F, 0x80, 0x80, 0x80, 0x7F,
0x7E, 0x7F, 0x80, 0x82, 0x80, 0x7E, 0x7E, 0x7F, 0x81, 0x80, 0x7F, 0x7F,
0x7F, 0x80, 0x81, 0x81, 0x7F, 0x7D, 0x7E, 0x80, 0x82, 0x82, 0x7F, 0x7D,
0x7E, 0x80, 0x82, 0x81, 0x7F, 0x7D, 0x7E, 0x81, 0x81, 0x80, 0x7E, 0x7E,
0x7F, 0x81, 0x81, 0x80, 0x7F, 0x7D, 0x7E, 0x80, 0x82, 0x82, 0x7F, 0x7D,
0x7E, 0x80, 0x82, 0x81, 0x7E, 0x7D, 0x7F, 0x81, 0x81, 0x80, 0x7E, 0x7E,
0x7F, 0x81, 0x81, 0x80, 0x7E, 0x7E, 0x80, 0x81, 0x81, 0x7F, 0x7E, 0x7F,
0x80, 0x80, 0x80, 0x7F, 0x7F, 0x80, 0x80, 0x80, 0x7F, 0x7F, 0x80, 0x7F,
0x80, 0x80, 0x80, 0x80, 0x7F, 0x7F, 0x7F, 0x7F, 0x80, 0x80, 0x80, 0x7F,
0x80, 0x80, 0x80, 0x7F, 0x7F, 0x80, 0x80, 0x80, 0x7F, 0x7F, 0x7F, 0x80,
0x80, 0x7F, 0x7F, 0x7F, 0x7F, 0x80, 0x80, 0x7F, 0x7F, 0x7F, 0x80, 0x80,
0x7F, 0x7F, 0x7F, 0x80, 0x81, 0x80, 0x7F, 0x7E, 0x7F, 0x81, 0x80, 0x80,
0x7F, 0x7F, 0x80, 0x80, 0x80, 0x7F, 0x7F, 0x7F, 0x80, 0x80, 0x80, 0x7F,
0x7F, 0x80, 0x80, 0x80, 0x7F, 0x7F, 0x80, 0x80, 0x80, 0x7F, 0x7F, 0x7F,
0x80, 0x80, 0x80, 0x7F, 0x7F, 0x7F, 0x80, 0x80, 0x7F, 0x7F, 0x80, 0x80,
0x80, 0x7F, 0x7F, 0x80, 0x80, 0x7F, 0x7F, 0x7F, 0x80, 0x80, 0x80, 0x7F,
0x7F, 0x7F, 0x80, 0x80, 0x80, 0x7F, 0x7F, 0x7F, 0x7F, 0x80, 0x7F, 0x80,
0x80, 0x80, 0x80, 0x7F, 0x7F, 0x7F };

85
arduino-cli/libraries/Adafruit_Circuit_Playground/examples/demo/demo.ino Normal file
View File

@@ -0,0 +1,85 @@
// Demo program for testing library and board - flip the switch to turn on/off buzzer
#include <Adafruit_CircuitPlayground.h>
// we light one pixel at a time, this is our counter
uint8_t pixeln = 0;
void setup() {
Serial.begin(9600);
Serial.println("Circuit Playground test!");
CircuitPlayground.begin();
}
void loop() {
// turn off speaker when not in use
CircuitPlayground.speaker.enable(false);
// test Red #13 LED
CircuitPlayground.redLED(HIGH);
delay(100);
CircuitPlayground.redLED(LOW);
/************* TEST CAPTOUCH */
Serial.print("Capsense #3: "); Serial.println(CircuitPlayground.readCap(3));
Serial.print("Capsense #2: "); Serial.println(CircuitPlayground.readCap(2));
Serial.print("Capsense #0: "); Serial.println(CircuitPlayground.readCap(0));
Serial.print("Capsense #1: "); Serial.println(CircuitPlayground.readCap(1));
Serial.print("Capsense #12: "); Serial.println(CircuitPlayground.readCap(12));
Serial.print("Capsense #6: "); Serial.println(CircuitPlayground.readCap(6));
Serial.print("Capsense #9: "); Serial.println(CircuitPlayground.readCap(9));
Serial.print("Capsense #10: "); Serial.println(CircuitPlayground.readCap(10));
delay(10);
/************* TEST SLIDE SWITCH */
if (CircuitPlayground.slideSwitch()) {
Serial.println("Slide to the left");
} else {
Serial.println("Slide to the right");
CircuitPlayground.speaker.enable(true);
CircuitPlayground.playTone(500 + pixeln * 500, 100);
}
delay(10);
/************* TEST 10 NEOPIXELS */
CircuitPlayground.setPixelColor(pixeln++, CircuitPlayground.colorWheel(25 * pixeln));
if (pixeln == 11) {
pixeln = 0;
CircuitPlayground.clearPixels();
}
delay(10);
/************* TEST BOTH BUTTONS */
if (CircuitPlayground.leftButton()) {
Serial.println("Left button pressed!");
}
if (CircuitPlayground.rightButton()) {
Serial.println("Right button pressed!");
}
delay(10);
/************* TEST LIGHT SENSOR */
Serial.print("Light sensor: ");
Serial.println(CircuitPlayground.lightSensor());
delay(10);
/************* TEST SOUND SENSOR */
Serial.print("Sound sensor: ");
Serial.println(CircuitPlayground.mic.soundPressureLevel(10));
delay(10);
/************* TEST ACCEL */
// Display the results (acceleration is measured in m/s*s)
Serial.print("X: "); Serial.print(CircuitPlayground.motionX());
Serial.print(" \tY: "); Serial.print(CircuitPlayground.motionY());
Serial.print(" \tZ: "); Serial.print(CircuitPlayground.motionZ());
Serial.println(" m/s^2");
delay(10);
/************* TEST THERMISTOR */
Serial.print("Temperature ");
Serial.print(CircuitPlayground.temperature());
Serial.println(" *C");
}

52
arduino-cli/libraries/Adafruit_Circuit_Playground/examples/external_neopixels/external_neopixels.ino Normal file
View File

@@ -0,0 +1,52 @@
#include <Adafruit_CircuitPlayground.h>
// do NOT include the standard NeoPixel library
#define NEOPIX_PIN A2
#define NUM_PIXELS 5
// use Adafruit_CPlay_NeoPixel to create a separate external NeoPixel strip
Adafruit_CPlay_NeoPixel strip = Adafruit_CPlay_NeoPixel(NUM_PIXELS, NEOPIX_PIN, NEO_GRB + NEO_KHZ800);
void setup() {
// initialize the Circuit Playground as usual
// this will initialize the onboard NeoPixels as well
CircuitPlayground.begin();
// initialize external NeoPixel strip separately
strip.begin();
}
void loop() {
// for the on board NeoPixels, use the CircuitPlayground functions
CircuitPlayground.clearPixels();
// for the external NeoPixels, must use the Adafruit_CPlay_NeoPixel functions directly
strip.clear();
strip.show();
delay(500);
CircuitPlayground.setPixelColor(0, 255, 0, 0);
CircuitPlayground.setPixelColor(1, 128, 128, 0);
CircuitPlayground.setPixelColor(2, 0, 255, 0);
CircuitPlayground.setPixelColor(3, 0, 128, 128);
CircuitPlayground.setPixelColor(4, 0, 0, 255);
CircuitPlayground.setPixelColor(5, 0xFF0000);
CircuitPlayground.setPixelColor(6, 0x808000);
CircuitPlayground.setPixelColor(7, 0x00FF00);
CircuitPlayground.setPixelColor(8, 0x008080);
CircuitPlayground.setPixelColor(9, 0x0000FF);
// some functions are the same
strip.setPixelColor(0, 255, 0, 0);
strip.setPixelColor(1, 128, 128, 0);
strip.setPixelColor(2, 0, 255, 0);
strip.setPixelColor(3, 0, 128, 128);
strip.setPixelColor(4, 0, 0, 255);
// but for the external strip, must call show()
strip.show();
delay(5000);
}

95
arduino-cli/libraries/Adafruit_Circuit_Playground/examples/mega_demo/CapTouchDemo.h Normal file
View File

@@ -0,0 +1,95 @@
#ifndef CAPTOUCHDEMO_H
#define CAPTOUCHDEMO_H
#include "Demo.h"
#define CAP_SAMPLES 20 // Number of samples to take for a capacitive touch read.
#define TONE_DURATION_MS 100 // Duration in milliseconds to play a tone when touched.
class CapTouchDemo: public Demo {
public:
uint16_t CAP_THRESHOLD = 200; // Threshold for a capacitive touch (higher = less sensitive).
CapTouchDemo() {
playSound = false;
if (CircuitPlayground.isExpress()) {
CAP_THRESHOLD = 800;
} else {
CAP_THRESHOLD = 200;
}
}
~CapTouchDemo() {}
virtual void loop() {
// Clear all the neopixels.
for (int i=0; i<10; ++i) {
CircuitPlayground.strip.setPixelColor(i, 0);
}
// Check if any of the cap touch inputs are pressed and turn on those pixels.
// Also play a tone if in tone playback mode.
if (CircuitPlayground.readCap(0, CAP_SAMPLES) >= CAP_THRESHOLD) {
CircuitPlayground.strip.setPixelColor(3, CircuitPlayground.colorWheel(256/10*3));
if (playSound) {
CircuitPlayground.playTone(330, TONE_DURATION_MS); // 330hz = E4
}
}
if (CircuitPlayground.readCap(1, CAP_SAMPLES) >= CAP_THRESHOLD) {
CircuitPlayground.strip.setPixelColor(4, CircuitPlayground.colorWheel(256/10*4));
if (playSound) {
CircuitPlayground.playTone(349, TONE_DURATION_MS); // 349hz = F4
}
}
if (CircuitPlayground.readCap(2, CAP_SAMPLES) >= CAP_THRESHOLD) {
CircuitPlayground.strip.setPixelColor(1, CircuitPlayground.colorWheel(256/10));
if (playSound) {
CircuitPlayground.playTone(294, TONE_DURATION_MS); // 294hz = D4
}
}
if (CircuitPlayground.readCap(3, CAP_SAMPLES) >= CAP_THRESHOLD) {
CircuitPlayground.strip.setPixelColor(0, CircuitPlayground.colorWheel(0));
if (playSound) {
CircuitPlayground.playTone(262, TONE_DURATION_MS); // 262hz = C4
}
}
if (CircuitPlayground.readCap(6, CAP_SAMPLES) >= CAP_THRESHOLD) {
CircuitPlayground.strip.setPixelColor(6, CircuitPlayground.colorWheel(256/10*6));
if (playSound) {
CircuitPlayground.playTone(440, TONE_DURATION_MS); // 440hz = A4
}
}
if (CircuitPlayground.readCap(9, CAP_SAMPLES) >= CAP_THRESHOLD) {
CircuitPlayground.strip.setPixelColor(8, CircuitPlayground.colorWheel(256/10*8));
if (playSound) {
CircuitPlayground.playTone(494, TONE_DURATION_MS); // 494hz = B4
}
}
if (CircuitPlayground.readCap(10, CAP_SAMPLES) >= CAP_THRESHOLD) {
CircuitPlayground.strip.setPixelColor(9, CircuitPlayground.colorWheel(256/10*9));
if (playSound) {
CircuitPlayground.playTone(523, TONE_DURATION_MS); // 523hz = C5
}
}
if (CircuitPlayground.readCap(12, CAP_SAMPLES) >= CAP_THRESHOLD) {
CircuitPlayground.strip.setPixelColor(5, CircuitPlayground.colorWheel(256/10*5));
if (playSound) {
CircuitPlayground.playTone(392, TONE_DURATION_MS); // 392hz = G4
}
}
// Light up the pixels.
CircuitPlayground.strip.show();
}
virtual void modePress() {
// Turn sound on/off.
playSound = !playSound;
}
private:
bool playSound;
};
#endif

27
arduino-cli/libraries/Adafruit_Circuit_Playground/examples/mega_demo/Demo.h Normal file
View File

@@ -0,0 +1,27 @@
#ifndef DEMO_H
#define DEMO_H
// Define each mode with the following interface for a loop and modePress
// function that will be called during the main loop and if the mode button
// was pressed respectively. It's up to each mode implementation to fill
// these in and add their logic.
class Demo {
public:
virtual ~Demo() {}
virtual void loop() = 0;
virtual void modePress() = 0;
};
// Linear interpolation function is handy for all the modes to use.
float lerp(float x, float xmin, float xmax, float ymin, float ymax) {
if (x >= xmax) {
return ymax;
}
if (x <= xmin) {
return ymin;
}
return ymin + (ymax-ymin)*((x-xmin)/(xmax-xmin));
}
#endif

40
arduino-cli/libraries/Adafruit_Circuit_Playground/examples/mega_demo/RainbowCycleDemo.h Normal file
View File

@@ -0,0 +1,40 @@
#ifndef RAINBOWCYCLEDEMO_H
#define RAINBOWCYCLEDEMO_H
#include "Demo.h"
// Animation speeds to loop through with mode presses. The current milliseconds
// are divided by this value so the smaller the value the faster the animation.
static int speeds[] = { 5, 10, 50, 100 };
class RainbowCycleDemo: public Demo {
public:
RainbowCycleDemo() { currentSpeed = 0; }
~RainbowCycleDemo() {}
virtual void loop() {
// Make an offset based on the current millisecond count scaled by the current speed.
uint32_t offset = millis() / speeds[currentSpeed];
// Loop through each pixel and set it to an incremental color wheel value.
for(int i=0; i<10; ++i) {
CircuitPlayground.strip.setPixelColor(i, CircuitPlayground.colorWheel(((i * 256 / 10) + offset) & 255));
}
// Show all the pixels.
CircuitPlayground.strip.show();
}
virtual void modePress() {
// Increment through the available speeds.
currentSpeed += 1;
if (currentSpeed >= sizeof(speeds)/sizeof(int)) {
currentSpeed = 0;
}
}
private:
int currentSpeed;
};
#endif

65
arduino-cli/libraries/Adafruit_Circuit_Playground/examples/mega_demo/SensorDemo.h Normal file
View File

@@ -0,0 +1,65 @@
#ifndef SENSORDEMO_H
#define SENSORDEMO_H
#include "Demo.h"
// Define small, medium, large range of light sensor values.
static int minLight[] = { 0, 0, 0};
static int maxLight[] = { 50, 255, 1023};
// Define small, medium, large range of temp sensor values (in Fahrenheit).
static float minTempF[] = { 80.0, 70.0, -32.0};
static float maxTempF[] = { 85.0, 90.0, 212.0};
// Define color for light sensor pixels.
#define LIGHT_RED 0xFF
#define LIGHT_GREEN 0x00
#define LIGHT_BLUE 0x00
// Define color for temp sensor pixels.
#define TEMP_RED 0x00
#define TEMP_GREEN 0x00
#define TEMP_BLUE 0xFF
class SensorDemo: public Demo {
public:
SensorDemo() { mode = 0; }
~SensorDemo() {}
virtual void loop() {
// Reset all lights to off.
for (int i=0; i<10; ++i) {
CircuitPlayground.strip.setPixelColor(i, 0);
}
// Measure the light level and use it to light up its LEDs (right half).
uint16_t light = CircuitPlayground.lightSensor();
int level = (int)lerp(light, minLight[mode], maxLight[mode], 0.0, 5.0);
for (int i=9; i>9-level; --i) {
CircuitPlayground.strip.setPixelColor(i, LIGHT_RED, LIGHT_GREEN, LIGHT_BLUE);
}
// Measure the temperatue and use it to light up its LEDs (left half).
float tempF = CircuitPlayground.temperatureF();
level = (int)lerp(tempF, minTempF[mode], maxTempF[mode], 0.0, 5.0);
for (int i=0; i<level; ++i) {
CircuitPlayground.strip.setPixelColor(i, TEMP_RED, TEMP_GREEN, TEMP_BLUE);
}
// Light up the pixels!
CircuitPlayground.strip.show();
}
virtual void modePress() {
// Switch to one of three modes for small, medium, big ranges of measurements.
mode += 1;
if (mode > 2) {
mode = 0;
}
}
private:
int mode;
};
#endif

71
arduino-cli/libraries/Adafruit_Circuit_Playground/examples/mega_demo/TiltDemo.h Normal file
View File

@@ -0,0 +1,71 @@
#ifndef TILTDEMO_H
#define TILTDEMO_H
#include "Demo.h"
// Define range of possible acceleration values.
#define MIN_ACCEL -10.0
#define MAX_ACCEL 10.0
// Define range of colors (min color and max color) using their red, green, blue components.
// First the min color:
#define MIN_COLOR_RED 0xFF
#define MIN_COLOR_GREEN 0x00
#define MIN_COLOR_BLUE 0x00
// Then the max color:
#define MAX_COLOR_RED 0x00
#define MAX_COLOR_GREEN 0x00
#define MAX_COLOR_BLUE 0xFF
class TiltDemo: public Demo {
public:
TiltDemo() { mode = 0; }
~TiltDemo() {}
virtual void loop() {
// Grab the acceleration for the current mode's axis.
float accel = 0;
switch (mode) {
case 0:
accel = CircuitPlayground.motionX();
break;
case 1:
accel = CircuitPlayground.motionY();
break;
case 2:
accel = CircuitPlayground.motionZ();
break;
}
// Now interpolate the acceleration into a color for the pixels.
uint8_t red = (uint8_t)lerp(accel, MIN_ACCEL, MAX_ACCEL, MIN_COLOR_RED, MAX_COLOR_RED);
uint8_t green = (uint8_t)lerp(accel, MIN_ACCEL, MAX_ACCEL, MIN_COLOR_GREEN, MAX_COLOR_GREEN);
uint8_t blue = (uint8_t)lerp(accel, MIN_ACCEL, MAX_ACCEL, MIN_COLOR_BLUE, MAX_COLOR_BLUE);
// Gamma correction makes LED brightness appear more linear
red = CircuitPlayground.gamma8(red);
green = CircuitPlayground.gamma8(green);
blue = CircuitPlayground.gamma8(blue);
// Light up all the pixels the interpolated color.
for (int i=0; i<10; ++i) {
CircuitPlayground.strip.setPixelColor(i, red, green, blue);
}
CircuitPlayground.strip.show();
}
virtual void modePress() {
// Change the mode (axis being displayed) to a value inside 0-2 for X, Y, Z.
mode += 1;
if (mode > 2) {
mode = 0;
}
}
private:
int mode;
};
#endif

100
arduino-cli/libraries/Adafruit_Circuit_Playground/examples/mega_demo/VUMeterDemo.h Normal file
View File

@@ -0,0 +1,100 @@
// This demo is based on the vumeter demo in the Adafruit Circuit Playground library.
#ifndef VUMETERDEMO_H
#define VUMETERDEMO_H
#include <math.h>
#include "Demo.h"
#define SAMPLE_WINDOW 10 // Sample window for average level
#define PEAK_HANG 24 // Time of pause before peak dot falls
#define PEAK_FALL 4 // Rate of falling peak dot
#define INPUT_FLOOR 56 // Lower range of mic sensitivity in dB SPL
#define INPUT_CEILING 110 // Upper range of mic sensitivity in db SPL
static byte peak = 16; // Peak level of column; used for falling dots
static unsigned int sample;
static byte dotCount = 0; //Frame counter for peak dot
static byte dotHangCount = 0; //Frame counter for holding peak dot
static float mapf(float x, float in_min, float in_max, float out_min, float out_max);
static void drawLine(uint8_t from, uint8_t to, uint32_t c);
class VUMeterDemo: public Demo {
public:
VUMeterDemo() { currentCeiling = 0; }
~VUMeterDemo() {}
virtual void loop() {
int numPixels = CircuitPlayground.strip.numPixels();
float peakToPeak = 0; // peak-to-peak level
unsigned int c, y;
//get peak sound pressure level over the sample window
peakToPeak = CircuitPlayground.mic.soundPressureLevel(SAMPLE_WINDOW);
//limit to the floor value
peakToPeak = max(INPUT_FLOOR, peakToPeak);
// Serial.println(peakToPeak);
//Fill the strip with rainbow gradient
for (int i=0;i<=numPixels-1;i++){
CircuitPlayground.strip.setPixelColor(i, CircuitPlayground.colorWheel(map(i,0,numPixels-1,30,150)));
}
c = mapf(peakToPeak, INPUT_FLOOR, INPUT_CEILING, numPixels, 0);
// Turn off pixels that are below volume threshold.
if(c < peak) {
peak = c; // Keep dot on top
dotHangCount = 0; // make the dot hang before falling
}
if (c <= numPixels) { // Fill partial column with off pixels
drawLine(numPixels, numPixels-c, CircuitPlayground.strip.Color(0, 0, 0));
}
// Set the peak dot to match the rainbow gradient
y = numPixels - peak;
CircuitPlayground.strip.setPixelColor(y-1,CircuitPlayground.colorWheel(map(y,0,numPixels-1,30,150)));
CircuitPlayground.strip.show();
// Frame based peak dot animation
if(dotHangCount > PEAK_HANG) { //Peak pause length
if(++dotCount >= PEAK_FALL) { //Fall rate
peak++;
dotCount = 0;
}
}
else {
dotHangCount++;
}
}
virtual void modePress() {
}
private:
int currentCeiling;
};
static float mapf(float x, float in_min, float in_max, float out_min, float out_max)
{
return (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min;
}
//Used to draw a line between two points of a given color
static void drawLine(uint8_t from, uint8_t to, uint32_t c) {
uint8_t fromTemp;
if (from > to) {
fromTemp = from;
from = to;
to = fromTemp;
}
for(int i=from; i<=to; i++){
CircuitPlayground.strip.setPixelColor(i, c);
}
}
#endif

121
arduino-cli/libraries/Adafruit_Circuit_Playground/examples/mega_demo/mega_demo.ino Normal file
View File

@@ -0,0 +1,121 @@
// Circuit Playground MEGA Demo
//
// Showcases interesting demos of all the components on Circuit Playground.
// This is a somewhat advanced sketch that's broken across multiple files (see
// the tabs above for all the files). When run on Circuit Playground you can
// press the left button to cycle through each demo, and the right button to
// cycle through each mode inside a demo. When the slide switch is in the -/right
// position the board will 'turn off' and go into deep sleep (pullin around 5mA
// of current), and when moved into the +/left position it will turn on and run
// the demos. Make sure the switch is on the +/left side after you upload or else
// the board won't do anything!
//
// NOTE: This example requires the Adafruit SleepyDog sleep & watchdog library
// be installed. Use the library manager to install, or grab it from its home:
// - https://github.com/adafruit/Adafruit_SleepyDog
// - https://github.com/adafruit/Adafruit_ASFcore (for Express)
//
// The following demos are available (in order):
// - NeoPixel color rainbow cycle
// This animates all 10 neopixels with a rainbow cycle. Changing the mode
// changes the speed of animation.
// - Volume level meter
// This uses the microphone to display a volume level meter. The louder the
// volume the more lights light up (and a peak level dot animates back down).
// Changing mode changes the sensitivity from medium to very high to very low
// and back to medium again (3 levels).
// - Capacitive touch instrument
// This uses the capacitive touch pads (0, 1, 2, 3, 6, 9, 10, 12) and lights up
// a nearby pixel when a pad is touched. Pressing the mode toggles between
// playing a different tone for each pad too (8 notes total covering the basic
// C4 scale).
// - Accelerometer tilt demo
// This lights up all the pixels to a color between blue and red depending on
// the value of the accelerometer. Try tilting the board around axes to see
// how it behaves. Pressing mode toggles between the X, Y, Z axis as the one
// under measurements (starts with X axis).
// - Temperature & light sensor demo
// The left half of the pixels light up blue proportional to the temperature
// of the thermistor, and the right half of the pixels light up red proportional
// to the light sensor. Pressing mode toggles between small, medium, and big
// ranges of measurements for each sensor.
//
// Author: Tony DiCola
// License: MIT License (https://opensource.org/licenses/MIT)
#include <Adafruit_CircuitPlayground.h>
#include <Wire.h>
#include <SPI.h>
#include "Adafruit_SleepyDog.h"
// Include all the demos, note that each demo is defined in a separate class to keep the sketch
// code below clean and simple.
#include "Demo.h"
#include "RainbowCycleDemo.h"
#include "VUMeterDemo.h"
#include "CapTouchDemo.h"
#include "TiltDemo.h"
#include "SensorDemo.h"
// Create an instance of each demo class.
RainbowCycleDemo rainbowCycleDemo;
VUMeterDemo vuMeterDemo;
CapTouchDemo capTouchDemo;
TiltDemo tiltDemo;
SensorDemo sensorDemo;
// Make a list of all demo class instances and keep track of the currently selected one.
int currentDemo = 0;
Demo* demos[] = {
&rainbowCycleDemo,
&vuMeterDemo,
&capTouchDemo,
&tiltDemo,
&sensorDemo
};
void setup() {
// Initialize serial port and circuit playground library.
Serial.begin(115200);
Serial.println("Circuit Playground MEGA Demo!");
CircuitPlayground.begin();
}
void loop() {
// Check if slide switch is on the left (false) and go to sleep.
while (!CircuitPlayground.slideSwitch()) {
// Turn off the pixels, then go into deep sleep for a second.
CircuitPlayground.clearPixels();
Watchdog.sleep(1000);
}
// Check for any button presses by checking their state twice with
// a delay inbetween. If the first press state is different from the
// second press state then something was pressed/released!
bool leftFirst = CircuitPlayground.leftButton();
bool rightFirst = CircuitPlayground.rightButton();
delay(10);
// Run current demo's main loop.
demos[currentDemo]->loop();
// Now check for buttons that were released.
bool leftSecond = CircuitPlayground.leftButton();
bool rightSecond = CircuitPlayground.rightButton();
// Left button will change the current demo.
if (leftFirst && !leftSecond) {
// Turn off all the pixels when entering new mode.
CircuitPlayground.clearPixels();
// Increment the current demo (looping back to zero if at end).
currentDemo += 1;
if (currentDemo >= (sizeof(demos)/sizeof(Demo*))) {
currentDemo = 0;
}
Serial.print("Changed to demo: "); Serial.println(currentDemo, DEC);
}
// Right button will change the mode of the current demo.
if (rightFirst && !rightSecond) {
demos[currentDemo]->modePress();
}
}

171
arduino-cli/libraries/Adafruit_Circuit_Playground/examples/tachometer/tachometer.ino Normal file
View File

@@ -0,0 +1,171 @@
// Adafruit Circuit Playground Fidget Spinner Tachometer
//
// This sketch uses the light sensor built in to Circuit Playground
// to detect the speed (in revolutions per second) of a fidget spinner.
// Load the sketch on a Circuit Playground (either classic or express)
// and notice the first three NeoPixels will turn on bright white.
// Hold a spinning fidget spinner very close to (but not touching) the
// light sensor (look for the eye graphic on the board, it's right
// below the three lit NeoPixels) and look at the serial monitor
// to see it print out the speed of the spinner. This works best
// holding the spinner perpendicular to the sensor, like:
// ||
// || <- Spinner
// ||
// ________ <- Circuit Playground
//
// Author: Tony DiCola
// License: MIT License (https://en.wikipedia.org/wiki/MIT_License)
#include <Adafruit_CircuitPlayground.h>
// Configuration values. You don't have to change these but they're
// interesting to adjust the logic. If your spinner has more or less
// than three arms be sure to change the SPINNER_ARMS value below:
#define SPINNER_ARMS 3 // Number of arms on the fidget spinner.
// This is used to calculate the true
// revolutions per second of the spinner
// as one full revolution of the spinner
// will actually see this number of cycles
// pass by the light sensor. Set this to
// the value 1 to ignore this calculation
// and just see the raw cycles / second.
#define SAMPLE_DEPTH 512 // How many samples to take when measuring
// the spinner speed. The larger this value
// the more memory that will be consumed but
// the slower a spinner speed that can be
// detected (larger sample depths mean longer
// period waves can be detected). You're
// limited by the amount of memory on the
// board for this value. On a classic
// Circuit Playground with 2kb of memory
// you can only go up to about 512 or so (each
// sample is 2 bytes, so 1kb of space total).
// On an express board you can go much higher,
// like up to 10240 for 20kb of sample data.
#define SAMPLE_PERIOD_US 1500 // Amount of time in microseconds to delay
// between each light sensor sample. This is
// a balance between how fast and slow of
// a spinner reading that can be measured.
// The higher this value the slower a spinner
// you can measure, but at the tradeoff of
// not accurately measuring fast spinners.
// Low values (even 0) mean very fast speeds
// can be detected but slow speeds (below 10hz)
// are harder to detect. You can increase the
// sample depth to help improve the range
// of detection speeds, but there's a limit
// based on the memory available.
#define THRESHOLD 400 // How big the amplitude of a cyclic
// signal has to be before the measurement
// logic kicks in. This is a value from
// 0 to 1023 and might need to be adjusted
// up or down if the detection is too
// sensitive or not sensitive enough.
// Raising this value will make the detection
// less sensitive and require a very large
// difference in amplitude (i.e. a very close
// or highly reflective spinner), and lowering
// the value will make the detection more
// sensitive and potentially pick up random
// noise from light in the room.
#define MEASURE_PERIOD_MS 1000 // Number of milliseconds to wait
// between measurements. Default is
// one second (1000 milliseconds).
void setup() {
// Initialize serial monitor at 115200 baud.
Serial.begin(115200);
// Initialize CircuitPlayground library and turn on the first 3 pixels (near the light sensor)
// to pure white at maximum brightness.
CircuitPlayground.begin(255); // 255 means set pixel colors to max brightness.
CircuitPlayground.clearPixels();
CircuitPlayground.setPixelColor(0, 255, 255, 255); // Set pixel 0, 1, 2 to white.
CircuitPlayground.setPixelColor(1, 255, 255, 255);
CircuitPlayground.setPixelColor(2, 255, 255, 255);
}
void loop() {
// Pause between measurements.
delay(MEASURE_PERIOD_MS);
// Collect samples from the light sensor as quickly as possible.
// Keep track of the amount of time (in microseconds) between samples
// so the sampling frequency can later be determined.
uint16_t samples[SAMPLE_DEPTH] = {0};
uint32_t start = micros();
for (int i=0; i<SAMPLE_DEPTH; ++i) {
samples[i] = CircuitPlayground.lightSensor();
delayMicroseconds(SAMPLE_PERIOD_US);
}
uint32_t elapsed_uS = micros() - start;
float elapsed = elapsed_uS / 1000000.0; // Elapsed time in seconds.
// Find the min and max values in the collected samples.
uint16_t minval = samples[0];
uint16_t maxval = samples[0];
for (int i=1; i<SAMPLE_DEPTH; ++i) {
minval = min(minval, samples[i]);
maxval = max(maxval, samples[i]);
}
// Check the amplitude of the signal (difference between min and max)
// is greater than the threshold to continue detecting speed.
uint16_t amplitude = maxval - minval;
if (amplitude < THRESHOLD) {
// Didn't make it past the threshold so start over with another measurement attempt.
return;
}
// Compute midpoint of the signal (halfway between min and max values).
uint16_t midpoint = minval + (amplitude/2);
// Count how many midpoint crossings were found in the signal.
// These are instances where two readings either straddle or land on
// the midpoint. The midpoint crossings will happen twice for every
// complete sine wave cycle (once going up and again coming down).
int crossings = 0;
for (int i=1; i<SAMPLE_DEPTH; ++i) {
uint16_t p0 = samples[i-1];
uint16_t p1 = samples[i];
if ((p1 == midpoint) ||
((p0 < midpoint) && (p1 > midpoint)) ||
((p0 > midpoint) && (p1 < midpoint))) {
crossings += 1;
}
}
// Compute signal frequency, RPM, and period.
// The period is the amount of time it takes for a complete
// sine wave cycle to occur. You can calculate this by dividing the
// amount of time that elapsed during the measurement period by the
// number of midpoint crossings cut in half (because each complete
// sine wave cycle will have 2 midpoint crossings). However since
// fidget spinners have multiple arms you also divide by the number
// of arms to normalize the period into a value that represents the
// time taken for a complete revolution of the entire spinner, not
// just the time between one arm and the next.
float period = elapsed / (crossings / SPINNER_ARMS / 2.0);
// Once the period is calculated it can be converted into a frequency
// value (i.e revolutions per second, how many times the spinner spins
// around per second) and more common RPM value (revolutions per minute,
// just multiply frequency by 60 since there are 60 seconds in a minute).
float frequency = 1.0 / period;
float rpm = frequency * 60.0;
// Print out the measured values!
Serial.print("Frequency: ");
Serial.print(frequency, 3);
Serial.print(" (hz)\t\tRPM: ");
Serial.print(rpm, 3);
Serial.print("\t\tPeriod: ");
Serial.print(period, 3);
Serial.println(" (seconds)");
}

194
arduino-cli/libraries/Adafruit_Circuit_Playground/examples/tachometer_led_display/tachometer_led_display.ino Normal file
View File

@@ -0,0 +1,194 @@
// Adafruit Circuit Playground Fidget Spinner Tachometer with LED Display
//
// This sketch uses the light sensor built in to Circuit Playground
// to detect the speed (in revolutions per second) of a fidget spinner
// and display it on a connected 4-digit 7-segment LED backpack display.
// See the tachometer example (without led_display) for a version that
// will output just to the serial monitor with no extra hardware needed.
//
// Load the sketch on a Circuit Playground (either classic or express)
// and notice the first three NeoPixels will turn on bright white.
// Hold a spinning fidget spinner very close to (but not touching) the
// light sensor (look for the eye graphic on the board, it's right
// below the three lit NeoPixels) and the sketch will display the
// revolutions per second of the spinner on the LED display. Hold
// the spinner perpendicular to the light sensor for the best
// measurement:
// ||
// || <- Spinner
// ||
// ________ <- Circuit Playground
//
// Author: Tony DiCola
// License: MIT License (https://en.wikipedia.org/wiki/MIT_License)
#include <Adafruit_CircuitPlayground.h>
#include <Adafruit_LEDBackpack.h>
#include <Adafruit_GFX.h>
// Configuration values. You don't have to change these but they're
// interesting to adjust the logic. If your spinner has more or less
// than three arms be sure to change the SPINNER_ARMS value below:
#define SPINNER_ARMS 3 // Number of arms on the fidget spinner.
// This is used to calculate the true
// revolutions per second of the spinner
// as one full revolution of the spinner
// will actually see this number of cycles
// pass by the light sensor. Set this to
// the value 1 to ignore this calculation
// and just see the raw cycles / second.
#define SAMPLE_DEPTH 512 // How many samples to take when measuring
// the spinner speed. The larger this value
// the more memory that will be consumed but
// the slower a spinner speed that can be
// detected (larger sample depths mean longer
// period waves can be detected). You're
// limited by the amount of memory on the
// board for this value. On a classic
// Circuit Playground with 2kb of memory
// you can only go up to about 512 or so (each
// sample is 2 bytes, so 1kb of space total).
// On an express board you can go much higher,
// like up to 10240 for 20kb of sample data.
#define SAMPLE_PERIOD_US 1500 // Amount of time in microseconds to delay
// between each light sensor sample. This is
// a balance between how fast and slow of
// a spinner reading that can be measured.
// The higher this value the slower a spinner
// you can measure, but at the tradeoff of
// not accurately measuring fast spinners.
// Low values (even 0) mean very fast speeds
// can be detected but slow speeds (below 10hz)
// are harder to detect. You can increase the
// sample depth to help improve the range
// of detection speeds, but there's a limit
// based on the memory available.
#define THRESHOLD 400 // How big the amplitude of a cyclic
// signal has to be before the measurement
// logic kicks in. This is a value from
// 0 to 1023 and might need to be adjusted
// up or down if the detection is too
// sensitive or not sensitive enough.
// Raising this value will make the detection
// less sensitive and require a very large
// difference in amplitude (i.e. a very close
// or highly reflective spinner), and lowering
// the value will make the detection more
// sensitive and potentially pick up random
// noise from light in the room.
#define MEASURE_PERIOD_MS 1000 // Number of milliseconds to wait
// between measurements. Default is
// one second (1000 milliseconds).
#define DISPLAY_ADDRESS 0x70 // I2C address of the display. Use the default
// 0x70 unless you've manually changed the
// devices address by soldering closed a bridge.
// Global state for the LED display:
Adafruit_7segment disp = Adafruit_7segment();
void setup() {
// Initialize serial monitor at 115200 baud.
Serial.begin(115200);
// Initialize CircuitPlayground library and turn on the first 3 pixels (near the light sensor)
// to pure white at maximum brightness.
CircuitPlayground.begin(255); // 255 means set pixel colors to max brightness.
CircuitPlayground.clearPixels();
CircuitPlayground.setPixelColor(0, 255, 255, 255); // Set pixel 0, 1, 2 to white.
CircuitPlayground.setPixelColor(1, 255, 255, 255);
CircuitPlayground.setPixelColor(2, 255, 255, 255);
// Initialize and clear the display.
disp.begin(DISPLAY_ADDRESS);
disp.clear();
disp.writeDisplay();
}
void loop() {
// Pause between measurements.
delay(MEASURE_PERIOD_MS);
// Collect samples from the light sensor as quickly as possible.
// Keep track of the amount of time (in microseconds) between samples
// so the sampling frequency can later be determined.
uint16_t samples[SAMPLE_DEPTH] = {0};
uint32_t start = micros();
for (int i=0; i<SAMPLE_DEPTH; ++i) {
samples[i] = CircuitPlayground.lightSensor();
delayMicroseconds(SAMPLE_PERIOD_US);
}
uint32_t elapsed_uS = micros() - start;
float elapsed = elapsed_uS / 1000000.0; // Elapsed time in seconds.
// Find the min and max values in the collected samples.
uint16_t minval = samples[0];
uint16_t maxval = samples[0];
for (int i=1; i<SAMPLE_DEPTH; ++i) {
minval = min(minval, samples[i]);
maxval = max(maxval, samples[i]);
}
// Check the amplitude of the signal (difference between min and max)
// is greater than the threshold to continue detecting speed.
uint16_t amplitude = maxval - minval;
if (amplitude < THRESHOLD) {
// Didn't make it past the threshold so start over with another measurement attempt.
return;
}
// Compute midpoint of the signal (halfway between min and max values).
uint16_t midpoint = minval + (amplitude/2);
// Count how many midpoint crossings were found in the signal.
// These are instances where two readings either straddle or land on
// the midpoint. The midpoint crossings will happen twice for every
// complete sine wave cycle (once going up and again coming down).
int crossings = 0;
for (int i=1; i<SAMPLE_DEPTH; ++i) {
uint16_t p0 = samples[i-1];
uint16_t p1 = samples[i];
if ((p1 == midpoint) ||
((p0 < midpoint) && (p1 > midpoint)) ||
((p0 > midpoint) && (p1 < midpoint))) {
crossings += 1;
}
}
// Compute signal frequency, RPM, and period.
// The period is the amount of time it takes for a complete
// sine wave cycle to occur. You can calculate this by dividing the
// amount of time that elapsed during the measurement period by the
// number of midpoint crossings cut in half (because each complete
// sine wave cycle will have 2 midpoint crossings). However since
// fidget spinners have multiple arms you also divide by the number
// of arms to normalize the period into a value that represents the
// time taken for a complete revolution of the entire spinner, not
// just the time between one arm and the next.
float period = elapsed / (crossings / SPINNER_ARMS / 2.0);
// Once the period is calculated it can be converted into a frequency
// value (i.e revolutions per second, how many times the spinner spins
// around per second) and more common RPM value (revolutions per minute,
// just multiply frequency by 60 since there are 60 seconds in a minute).
float frequency = 1.0 / period;
float rpm = frequency * 60.0;
// Print out the measured values!
Serial.print("Frequency: ");
Serial.print(frequency, 3);
Serial.print(" (hz)\t\tRPM: ");
Serial.print(rpm, 3);
Serial.print("\t\tPeriod: ");
Serial.print(period, 3);
Serial.println(" (seconds)");
// Also print the frequency (revolutions per second) to the LED display.
disp.print(frequency);
disp.writeDisplay();
}

10
arduino-cli/libraries/Adafruit_Circuit_Playground/library.properties Normal file
View File

@@ -0,0 +1,10 @@
name=Adafruit Circuit Playground
version=1.11.3
author=Adafruit
maintainer=Adafruit <info@adafruit.com>
sentence=All in one library to control Adafruit's Circuit Playground board.
paragraph=All in one library to control Adafruit's Circuit Playground board.
category=Other
url=https://github.com/adafruit/Adafruit_CircuitPlayground
architectures=*
depends=Adafruit LED Backpack Library, Adafruit GFX Library, Adafruit SleepyDog Library, Adafruit Zero FFT Library, Mouse, Adafruit BusIO

501
arduino-cli/libraries/Adafruit_Circuit_Playground/utility/Adafruit_CPlay_FreeTouch.cpp Normal file
View File

@@ -0,0 +1,501 @@
/*
* FreeTouch, a QTouch-compatible library - tested on ATSAMD21 only!
* The MIT License (MIT)
*
* Copyright (c) 2017 Limor 'ladyada' Fried for Adafruit Industries
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#include "Adafruit_CPlay_FreeTouch.h"
#if defined(__SAMD21G18A__)
Adafruit_CPlay_FreeTouch::Adafruit_CPlay_FreeTouch(int p, oversample_t f, series_resistor_t r, freq_mode_t fh) {
pin = p;
oversample = f;
seriesres = r;
freqhop = fh;
compcap = 0x2000;
intcap = 0x3F;
yline = -1;
}
bool Adafruit_CPlay_FreeTouch::begin(void) {
yline = getYLine(); // determine the Y0-15 #
if (yline == -1) // not all pins have Y line
return false;
setupClock();
ptcInitSettings();
enablePTC(false);
enableWCOint(false);
enableEOCint(false);
// enable the sensor, only done once per line
if (yline < 8) {
sync_config();
QTOUCH_PTC->YENABLEL.reg |= 1 << yline;
sync_config();
} else if (yline < 16) {
QTOUCH_PTC->YENABLEH.reg |= 1 << (yline - 8);
}
enablePTC(true);
return true;
}
void Adafruit_CPlay_FreeTouch::setupClock(void) {
/* Setup and enable generic clock source for PTC module.
struct system_gclk_chan_config gclk_chan_conf;
system_gclk_chan_get_config_defaults(&gclk_chan_conf);
*/
uint8_t channel = PTC_GCLK_ID;
uint8_t source_generator = 1;
// original line: system_gclk_chan_set_config(PTC_GCLK_ID, &gclk_chan_conf);
uint32_t new_clkctrl_config = (channel << GCLK_CLKCTRL_ID_Pos); // from gclk.c
// original line: gclk_chan_conf.source_generator = GCLK_GENERATOR_1;
/* Select the desired generic clock generator */
new_clkctrl_config |= source_generator << GCLK_CLKCTRL_GEN_Pos; // from gclk.c
/* Disable generic clock channel */
// original line: system_gclk_chan_disable(channel);
noInterrupts();
/* Select the requested generator channel */
*((uint8_t*)&GCLK->CLKCTRL.reg) = channel;
/* Sanity check WRTLOCK */
//Assert(!GCLK->CLKCTRL.bit.WRTLOCK);
/* Switch to known-working source so that the channel can be disabled */
uint32_t prev_gen_id = GCLK->CLKCTRL.bit.GEN;
GCLK->CLKCTRL.bit.GEN = 0;
/* Disable the generic clock */
GCLK->CLKCTRL.reg &= ~GCLK_CLKCTRL_CLKEN;
while (GCLK->CLKCTRL.reg & GCLK_CLKCTRL_CLKEN) {
/* Wait for clock to become disabled */
}
/* Restore previous configured clock generator */
GCLK->CLKCTRL.bit.GEN = prev_gen_id;
//system_interrupt_leave_critical_section();
interrupts();
/* Write the new configuration */
GCLK->CLKCTRL.reg = new_clkctrl_config;
// original line: system_gclk_chan_enable(PTC_GCLK_ID);
*((uint8_t*)&GCLK->CLKCTRL.reg) = channel;
GCLK->CLKCTRL.reg |= GCLK_CLKCTRL_CLKEN; /* Enable the generic clock */
// original line: system_apb_clock_set_mask(SYSTEM_CLOCK_APB_APBC, PM_APBCMASK_PTC);
PM->APBCMASK.reg |= PM_APBCMASK_PTC;
}
uint16_t Adafruit_CPlay_FreeTouch::measure(void) {
uint16_t m;
m = measureRaw();
if (m == -1) return -1;
// normalize the signal
switch (oversample) {
case OVERSAMPLE_1: return m;
case OVERSAMPLE_2: return m/2;
case OVERSAMPLE_4: return m/4;
case OVERSAMPLE_8: return m/8;
case OVERSAMPLE_16: return m/16;
case OVERSAMPLE_32: return m/32;
case OVERSAMPLE_64: return m/64;
}
return -1; // shouldn't reach here but fail if we do!
}
uint16_t Adafruit_CPlay_FreeTouch::measureRaw(void) {
if (yline == -1)
return -1;
runInStandby(true);
enablePTC(true);
// check if in progress
// set up NVIC if using INT (we're not)
enableWCOint(false);
clearWCOintFlag();
clearEOCintFlag();
// enable_eoc_int(); // not using irq (for now)
// set up pin!
//Serial.print("Y Line #"); Serial.println(yline);
selectYLine();
// set up sense resistor
setSeriesResistor(seriesres);
// set up prescalar
setOversampling(oversample);
// set up freq hopping
setFreqHopping(freqhop, hops);
// set up compensation cap + int (?) cap
setCompCap(compcap);
setIntCap(intcap);
uint32_t burstmodeRegBackup = QTOUCH_PTC->BURSTMODE.reg;
QTOUCH_PTC->BURSTMODE.reg = 0xA4;
sync_config();
uint16_t ptcResult = startPtcAcquire();
QTOUCH_PTC->BURSTMODE.reg = burstmodeRegBackup;
sync_config();
return ptcResult;
}
uint16_t Adafruit_CPlay_FreeTouch::startPtcAcquire(void) {
ptcConfigIOpin();
ptcAcquire();
while (QTOUCH_PTC->CONVCONTROL.bit.CONVERT) {
yield();
}
sync_config();
uint16_t result = QTOUCH_PTC->RESULT.reg;
return result;
}
/*********************************** low level config **/
void Adafruit_CPlay_FreeTouch::selectYLine(void) {
sync_config();
if (yline < 8) {
QTOUCH_PTC->YSELECTL.reg = 1 << yline;
} else {
QTOUCH_PTC->YSELECTL.reg = 0;
}
if (yline > 7) {
QTOUCH_PTC->YSELECTH.reg = 1 << (yline - 8);
} else {
QTOUCH_PTC->YSELECTH.reg = 0;
}
sync_config();
}
int Adafruit_CPlay_FreeTouch::getYLine(void) {
int p = g_APinDescription[pin].ulPin;
if (g_APinDescription[pin].ulPort == PORTA) {
if ((p >= 2) && (p <= 7)) {
return (p - 2);
}
}
if (g_APinDescription[pin].ulPort == PORTB) {
if ((p >= 0) && (p <= 9)) {
return (p + 6);
}
}
// not valid
return -1;
}
void Adafruit_CPlay_FreeTouch::setCompCap(uint16_t cc) {
compcap = cc & 0x3FFF;
sync_config();
QTOUCH_PTC->COMPCAPL.bit.VALUE = compcap & 0xFF;
QTOUCH_PTC->COMPCAPH.bit.VALUE = (compcap>>8) & 0x3F;
sync_config();
}
void Adafruit_CPlay_FreeTouch::setIntCap(uint8_t ic) {
intcap = ic & 0x3F;
sync_config();
QTOUCH_PTC->INTCAP.bit.VALUE = intcap & 0x3F;
sync_config();
}
void Adafruit_CPlay_FreeTouch::setOversampling(oversample_t lvl) {
oversample = lvl; // back it up for later
sync_config();
QTOUCH_PTC->CONVCONTROL.bit.ADCACCUM = lvl;
sync_config();
}
void Adafruit_CPlay_FreeTouch::setSeriesResistor(series_resistor_t res) {
seriesres = res;
sync_config();
QTOUCH_PTC->SERRES.bit.RESISTOR = res;
sync_config();
}
void Adafruit_CPlay_FreeTouch::setFreqHopping(freq_mode_t fh, freq_hop_t hs) {
freqhop = fh;
hops = hs;
sync_config();
if (fh == FREQ_MODE_NONE) {
QTOUCH_PTC->FREQCONTROL.bit.FREQSPREADEN = 0;
QTOUCH_PTC->FREQCONTROL.bit.SAMPLEDELAY = 0;
} else {
QTOUCH_PTC->FREQCONTROL.bit.FREQSPREADEN = 1;
QTOUCH_PTC->FREQCONTROL.bit.SAMPLEDELAY = hops;
}
sync_config();
}
void Adafruit_CPlay_FreeTouch::ptcInitSettings(void) {
ptcConfigIOpin();
enablePTC(false);
QTOUCH_PTC->UNK4C04.reg &= 0xF7; //MEMORY[0x42004C04] &= 0xF7u;
QTOUCH_PTC->UNK4C04.reg &= 0xFB; //MEMORY[0x42004C04] &= 0xFBu;
QTOUCH_PTC->UNK4C04.reg &= 0xFC; //MEMORY[0x42004C04] &= 0xFCu;
sync_config();
QTOUCH_PTC->FREQCONTROL.reg &= 0x9F; //MEMORY[0x42004C0C] &= 0x9Fu;
sync_config();
QTOUCH_PTC->FREQCONTROL.reg &= 0xEF; //MEMORY[0x42004C0C] &= 0xEFu;
sync_config();
QTOUCH_PTC->FREQCONTROL.bit.SAMPLEDELAY = 0; //MEMORY[0x42004C0C] &= 0xF0u;
QTOUCH_PTC->CONTROLC.bit.INIT = 1; //MEMORY[0x42004C05] |= 1u;
QTOUCH_PTC->CONTROLA.bit.RUNINSTANDBY = 1; //MEMORY[0x42004C00] |= 4u;
sync_config();
enablePTC(true); //MEMORY[0x42004C00] |= 2u;
}
void Adafruit_CPlay_FreeTouch::ptcConfigIOpin(void) {
uint32_t ulpin = g_APinDescription[pin].ulPin;
uint32_t ulport = g_APinDescription[pin].ulPort;
PORT->Group[ulport].PINCFG[ulpin].reg = 0x3; // pmuxen + input
uint8_t curr_pmux = (PORT->Group[ulport].PMUX[ulpin/2].reg);
if (ulpin & 1) {
// pmuxodd
curr_pmux &= PORT_PMUX_PMUXE(0xF); // keep the even mux data
curr_pmux |= PORT_PMUX_PMUXO(0x1); // set to mux B
} else {
// pmuxeven
curr_pmux &= PORT_PMUX_PMUXO(0xF); // keep the odd mux data
curr_pmux |= PORT_PMUX_PMUXE(0x1); // set to mux B
}
PORT->Group[ulport].PMUX[ulpin/2].reg = curr_pmux;
}
void Adafruit_CPlay_FreeTouch::runInStandby(boolean en) {
sync_config();
if (en) {
QTOUCH_PTC->CONTROLA.bit.RUNINSTANDBY = 1;
} else {
QTOUCH_PTC->CONTROLA.bit.RUNINSTANDBY = 0;
}
sync_config();
}
void Adafruit_CPlay_FreeTouch::enablePTC(boolean en) {
sync_config();
if (en) {
QTOUCH_PTC->CONTROLA.bit.ENABLE = 1;
} else {
QTOUCH_PTC->CONTROLA.bit.ENABLE = 0;
}
sync_config();
}
void Adafruit_CPlay_FreeTouch::enableWCOint(boolean en) {
sync_config();
if (en) {
QTOUCH_PTC->INTENABLE.bit.WCO = 1;
} else {
QTOUCH_PTC->INTDISABLE.bit.WCO = 1;
}
sync_config();
}
void Adafruit_CPlay_FreeTouch::enableEOCint(boolean en) {
sync_config();
if (en) {
QTOUCH_PTC->INTENABLE.bit.EOC = 1;
} else {
QTOUCH_PTC->INTDISABLE.bit.EOC = 1;
}
sync_config();
}
void Adafruit_CPlay_FreeTouch::clearWCOintFlag(void) {
sync_config();
QTOUCH_PTC->INTFLAGS.bit.WCO = 1;
sync_config();
}
void Adafruit_CPlay_FreeTouch::clearEOCintFlag(void) {
sync_config();
QTOUCH_PTC->INTFLAGS.bit.EOC = 1;
sync_config();
}
void Adafruit_CPlay_FreeTouch::ptcAcquire(void) {
sync_config();
QTOUCH_PTC->CONVCONTROL.bit.CONVERT = 1;
sync_config();
}
void Adafruit_CPlay_FreeTouch::sync_config(void) {
while (QTOUCH_PTC->CONTROLB.bit.SYNCFLAG) ;
}
/**************************** DEBUGGING ASSIST *************************/
void Adafruit_CPlay_FreeTouch::snapshotRegsAndPrint(uint32_t base, uint8_t numregs) {
volatile uint32_t addr = base;
uint8_t datas[255];
digitalWrite(LED_BUILTIN, HIGH);
for (uint8_t i=0; i<numregs; i++) {
datas[i] = *(uint8_t *)(addr+i);
}
digitalWrite(LED_BUILTIN, LOW);
printPTCregs(base, datas, numregs);
for (uint8_t i=0; i<numregs; i++) {
// Serial.print("$"); Serial.print(addr+i, HEX); Serial.print("\t0x");
// printHex(datas[i]); Serial.println();
}
}
// Print a hex with leading zero
void Adafruit_CPlay_FreeTouch::printHex(uint8_t h, boolean newline) {
if (h < 0x10) Serial.print("0");
Serial.print(h, HEX);
if (newline) Serial.println();
}
void Adafruit_CPlay_FreeTouch::printPTCregs(uint32_t base, uint8_t *regs, uint8_t num) {
Serial.println("--------------------------------------------------------");
for (uint8_t i=0; i<num; i++) {
switch (i + base) {
case 0x41004430: Serial.print("0x"); Serial.print(i+base, HEX);
Serial.print(" PMUX0:\t\t0x"); printHex(regs[i], true); break;
case 0x41004431: Serial.print("0x"); Serial.print(i+base, HEX);
Serial.print(" PMUX1:\t\t0x"); printHex(regs[i], true); break;
case 0x41004432: Serial.print("0x"); Serial.print(i+base, HEX);
Serial.print(" PMUX2:\t\t0x"); printHex(regs[i], true); break;
case 0x41004433: Serial.print("0x"); Serial.print(i+base, HEX);
Serial.print(" PMUX3:\t\t0x"); printHex(regs[i], true); break;
case 0x41004440: Serial.print("0x"); Serial.print(i+base, HEX);
Serial.print(" PCFG0:\t\t0x"); printHex(regs[i], true); break;
case 0x41004441: Serial.print("0x"); Serial.print(i+base, HEX);
Serial.print(" PCFG1:\t\t0x"); printHex(regs[i], true); break;
case 0x41004442: Serial.print("0x"); Serial.print(i+base, HEX);
Serial.print(" PCFG2:\t\t0x"); printHex(regs[i], true); break;
case 0x41004443: Serial.print("0x"); Serial.print(i+base, HEX);
Serial.print(" PCFG3:\t\t0x"); printHex(regs[i], true); break;
case 0x41004444: Serial.print("0x"); Serial.print(i+base, HEX);
Serial.print(" PCFG4:\t\t0x"); printHex(regs[i], true); break;
case 0x42004C00: Serial.print("0x"); Serial.print(i+base, HEX);
Serial.print(" Control A:\t\t0x"); printHex(regs[i], true); break;
case 0x42004C01: Serial.print("0x"); Serial.print(i+base, HEX);
Serial.print(" Sync: \t\t0x"); printHex(regs[i], true); break;
case 0x42004C04: Serial.print("0x"); Serial.print(i+base, HEX);
Serial.print(" Prescaler:\t\t0x"); printHex(regs[i], true); break;
case 0x42004C05: Serial.print("0x"); Serial.print(i+base, HEX);
Serial.print(" Init: \t\t0x"); printHex(regs[i], true); break;
case 0x42004C08: Serial.print("0x"); Serial.print(i+base, HEX);
Serial.print(" Disable Irq:\t\t0x"); printHex(regs[i], true); break;
case 0x42004C09: Serial.print("0x"); Serial.print(i+base, HEX);
Serial.print(" Enable Irq:\t\t0x"); printHex(regs[i], true); break;
case 0x42004C0A: Serial.print("0x"); Serial.print(i+base, HEX);
Serial.print(" Flags: \t\t0x"); printHex(regs[i], true); break;
case 0x42004C0C: Serial.print("0x"); Serial.print(i+base, HEX);
Serial.print(" Freq Cntl:\t\t0x"); printHex(regs[i], true); break;
case 0x42004C0D: Serial.print("0x"); Serial.print(i+base, HEX);
Serial.print(" Conv Cntl:\t\t0x"); printHex(regs[i], true); break;
case 0x42004C10: Serial.print("0x"); Serial.print(i+base, HEX);
Serial.print(" Y Select1:\t\t0x"); printHex(regs[i], true); break;
case 0x42004C11: Serial.print("0x"); Serial.print(i+0x42004C00, HEX);
Serial.print(" Y Select2:\t\t0x"); printHex(regs[i], true); break;
/*
case 0x42004C12: Serial.print("0x"); Serial.print(i+0x42004C00, HEX);
Serial.print(" X Select1:\t\t0x"); printHex(regs[i], true); break;
case 0x42004C13: Serial.print("0x"); Serial.print(i+0x42004C00, HEX);
Serial.print(" X Select2:\t\t0x"); printHex(regs[i], true); break;
*/
case 0x42004C14: Serial.print("0x"); Serial.print(i+base, HEX);
Serial.print(" Y Enable1:\t\t0x"); printHex(regs[i], true); break;
case 0x42004C15: Serial.print("0x"); Serial.print(i+0x42004C00, HEX);
Serial.print(" Y Enable2:\t\t0x"); printHex(regs[i], true); break;
/*
case 0x42004C16: Serial.print("0x"); Serial.print(i+0x42004C00, HEX);
Serial.print(" X Enable1:\t\t0x"); printHex(regs[i], true); break;
case 0x42004C17: Serial.print("0x"); Serial.print(i+0x42004C00, HEX);
Serial.print(" X Enable2:\t\t0x"); printHex(regs[i], true); break;
*/
case 0x42004C18: Serial.print("0x"); Serial.print(i+base, HEX);
Serial.print(" Compcap L:\t\t0x"); printHex(regs[i], true); break;
case 0x42004C19: Serial.print("0x"); Serial.print(i+base, HEX);
Serial.print(" Compcap H:\t\t0x"); printHex(regs[i], true); break;
case 0x42004C1A: Serial.print("0x"); Serial.print(i+base, HEX);
Serial.print(" Intcap: \t\t0x"); printHex(regs[i], true); break;
case 0x42004C1B: Serial.print("0x"); Serial.print(i+base, HEX);
Serial.print(" Sense res:\t\t0x"); printHex(regs[i], true); break;
case 0x42004C1C: Serial.print("0x"); Serial.print(i+base, HEX);
Serial.print(" Result L:\t\t0x"); printHex(regs[i], true); break;
case 0x42004C1D: Serial.print("0x"); Serial.print(i+base, HEX);
Serial.print(" Result H:\t\t0x"); printHex(regs[i], true); break;
}
}
}
#endif

428
arduino-cli/libraries/Adafruit_Circuit_Playground/utility/Adafruit_CPlay_FreeTouch.h Normal file
View File

@@ -0,0 +1,428 @@
#include <Arduino.h>
#if defined(__SAMD21G18A__)
#ifndef ADAFRUIT_FREETOUCH_H
#define ADAFRUIT_FREETOUCH_H
/*************** CONTROL A register ***************/
#define PTC_REG_CONTROLA 0x42004C00
#define PTC_BIT_ENABLE 0x02
#define PTC_BIT_RUNINSTBY 0x04
typedef union {
struct {
uint8_t SWRESET:1;
uint8_t ENABLE:1;
uint8_t RUNINSTANDBY:1;
uint8_t __pad0__:5;
} bit;
uint8_t reg;
} PTC_REG_CONTROLA_Type;
/*************** CONTROL B register ***************/
#define PTC_REG_CONTROLB 0x42004C01
#define PTC_BIT_SYNCFLAG 0x80
typedef union {
struct {
uint8_t __pad0__:7;
uint8_t SYNCFLAG:1;
} bit;
uint8_t reg;
} PTC_REG_CONTROLB_Type;
/*************** UNK4C04 register ***************/
#define PTC_REG_UNK4C04 0x42004C04
typedef union {
uint8_t reg;
} PTC_REG_UNK4C04_Type;
/*************** CONTROL C register ***************/
#define PTC_REG_CONTROLC 0x42004C05
#define PTC_BIT_INIT 0x01
typedef union {
struct {
uint8_t INIT:1;
uint8_t __pad0__:7;
} bit;
uint8_t reg;
} PTC_REG_CONTROLC_Type;
/*************** INT registers ***************/
typedef union {
struct {
uint8_t EOC:1;
uint8_t WCO:1;
uint8_t __pad0__:6;
} bit;
uint8_t reg;
} PTC_REG_INT_Type;
#define PTC_REG_INTDISABLE 0x42004C08
#define PTC_REG_INTENABLE 0x42004C09
#define PTC_BIT_EOCINTEN 0x01
#define PTC_BIT_WCOINTEN 0x02
#define PTC_REG_INTFLAGS 0x42004C0A
#define PTC_BIT_EOCINTFLAG 0x01
#define PTC_BIT_WCOINTFLAG 0x02
/*************** FREQ CONTROL reg ***************/
typedef union {
struct {
uint8_t SAMPLEDELAY:4;
uint8_t FREQSPREADEN:1;
uint8_t __pad0__:3;
} bit;
uint8_t reg;
} PTC_REG_FREQCONTROL_Type;
#define PTC_REG_FREQCONTROL 0x42004C0C
#define PTC_BIT_FREQSPREADEN 0x10
#define PTC_REG_SAMPLEDELAY_MASK 0x0F
/*************** CONVERT CONTROL reg ***************/
typedef union {
struct {
uint8_t ADCACCUM:3;
uint8_t __pad0__:4;
uint8_t CONVERT:1;
} bit;
uint8_t reg;
} __attribute__ ((packed)) PTC_REG_CONVCONTROL_Type;
#define PTC_REG_CONVCONTROL 0x42004C0D
#define PTC_BIT_CONVSTARTED 0x80
#define PTC_REG_ADCACC_MASK 0x07
/*************** Y SELECT L+H reg ***************/
typedef union {
struct {
uint8_t Y0:1;
uint8_t Y1:1;
uint8_t Y2:1;
uint8_t Y3:1;
uint8_t Y4:1;
uint8_t Y5:1;
uint8_t Y6:1;
uint8_t Y7:1;
} bit;
uint8_t reg;
} __attribute__ ((packed)) PTC_REG_YSELECTL_Type;
typedef union {
struct {
uint8_t Y8:1;
uint8_t Y9:1;
uint8_t Y10:1;
uint8_t Y11:1;
uint8_t Y12:1;
uint8_t Y13:1;
uint8_t Y14:1;
uint8_t Y15:1;
} bit;
uint8_t reg;
} __attribute__ ((packed)) PTC_REG_YSELECTH_Type;
#define PTC_REG_YSELECT_L 0x42004C10
#define PTC_REG_YSELECT_H 0x42004C11
#define PTC_REG_YENABLE_L 0x42004C14
#define PTC_REG_YENABLE_H 0x42004C15
/*************** X SELECT L+H reg ***************/
typedef union {
struct {
uint8_t X0:1;
uint8_t X1:1;
uint8_t X2:1;
uint8_t X3:1;
uint8_t X4:1;
uint8_t X5:1;
uint8_t X6:1;
uint8_t X7:1;
} bit;
uint8_t reg;
} __attribute__ ((packed)) PTC_REG_XSELECTL_Type;
typedef union {
struct {
uint8_t X8:1;
uint8_t X9:1;
uint8_t X10:1;
uint8_t X11:1;
uint8_t X12:1;
uint8_t X13:1;
uint8_t X14:1;
uint8_t X15:1;
} bit;
uint8_t reg;
} __attribute__ ((packed)) PTC_REG_XSELECTH_Type;
#define PTC_REG_XSELECT_L 0x42004C12
#define PTC_REG_XSELECT_H 0x42004C13
#define PTC_REG_XENABLE_L 0x42004C16
#define PTC_REG_XENABLE_H 0x42004C17
/*************** Compensation Cap reg ***************/
typedef union {
struct {
uint8_t VALUE:8;
} bit;
uint8_t reg;
} __attribute__ ((packed)) PTC_REG_COMPCAPL_Type;
typedef union {
struct {
uint8_t VALUE:6;
uint8_t __pad0__:2;
} bit;
uint8_t reg;
} __attribute__ ((packed)) PTC_REG_COMPCAPH_Type;
#define PTC_REG_COMPCAPL 0x42004C18
#define PTC_REG_COMPCAPH 0x42004C19
/*************** Int Cap reg ***************/
typedef union {
struct {
uint8_t VALUE:6;
uint8_t __pad0__:2;
} bit;
uint8_t reg;
} __attribute__ ((packed)) PTC_REG_INTCAP_Type;
#define PTC_REG_INTCAP 0x42004C1A
/*************** Series resistor reg ***************/
typedef union {
struct {
uint8_t RESISTOR:2;
uint8_t __pad0__:6;
} bit;
uint8_t reg;
} __attribute__ ((packed)) PTC_REG_SERRES_Type;
#define PTC_REG_SERIESRES 0x42004C1B
/*************** conversion result reg ***************/
typedef union {
struct {
uint8_t LOWBYTE;
uint8_t HIGHBYTE;
} byte;
uint16_t reg;
} __attribute__ ((packed)) PTC_REG_CONVRESULT_Type;
#define PTC_REG_CONVRESULT_L 0x42004C1C
#define PTC_REG_CONVRESULT_H 0x42004C1D
/*************** burst mode reg ***************/
typedef union {
struct {
uint8_t __pad0__:2;
uint8_t CTSLOWPOWER:1;
uint8_t __pad1__:1;
uint8_t BURSTMODE:4;
} bit;
uint8_t reg;
} __attribute__ ((packed)) PTC_REG_BURSTMODE_Type;
#define PTC_REG_BURSTMODE 0x42004C20
#define PTC_REG_BURSTMODE_MASK 0xF0
#define PTC_BIT_CTSLOWPOWER 0x04
/*************** etc unused reg ***************/
#define PTC_REG_XYENABLE 0x42004C16
#define PTC_BIT_XYENABLE 0x02
#define PTC_REG_WCO_MODE 0x42004C21
#define PTC_REG_WCO_MODE_MASK 0x07
#define PTC_SET_WCO_THRESHHOLD_A_L 0x42004C24
#define PTC_SET_WCO_THRESHHOLD_A_H 0x42004C25
#define PTC_SET_WCO_THRESHHOLD_B_L 0x42004C26
#define PTC_SET_WCO_THRESHHOLD_B_H 0x42004C27
typedef struct {
__IO PTC_REG_CONTROLA_Type CONTROLA; // 0x42004C00
__IO PTC_REG_CONTROLB_Type CONTROLB; // 0x42004C01
uint8_t __pad4c02__; // 0x42004C02 unknown
uint8_t __pad4c03__; // 0x42004C03 unknown
__IO PTC_REG_UNK4C04_Type UNK4C04; // 0x42004C04 unknown
__IO PTC_REG_CONTROLC_Type CONTROLC; // 0x42004C05
uint8_t __pad4c06__; // 0x42004C06 unknown
uint8_t __pad4c07__; // 0x42004C07 unknown
__IO PTC_REG_INT_Type INTDISABLE; // 0x42004C08
__IO PTC_REG_INT_Type INTENABLE; // 0x42004C09
__I PTC_REG_INT_Type INTFLAGS; // 0x42004C0A
uint8_t __pad4c0b__; // 0x42004C0B unknown
__IO PTC_REG_FREQCONTROL_Type FREQCONTROL; //0x42004C0C
__IO PTC_REG_CONVCONTROL_Type CONVCONTROL; // 0x42004C0D
uint8_t __pad4c0e__; // 0x42004C0E unknown
uint8_t __pad4c0f__; // 0x42004C0F unknown
__IO PTC_REG_YSELECTL_Type YSELECTL; // 0x42004C10
__IO PTC_REG_YSELECTL_Type YSELECTH; // 0x42004C11
__IO PTC_REG_XSELECTL_Type XSELECTL; // 0x42004C12
__IO PTC_REG_XSELECTL_Type XSELECTH; // 0x42004C13
__IO PTC_REG_YSELECTL_Type YENABLEL; // 0x42004C14
__IO PTC_REG_YSELECTL_Type YENABLEH; // 0x42004C15
__IO PTC_REG_XSELECTL_Type XENABLEL; // 0x42004C16
__IO PTC_REG_XSELECTL_Type XENABLEH; // 0x42004C17
__IO PTC_REG_COMPCAPL_Type COMPCAPL; // 0x42004C18
__IO PTC_REG_COMPCAPH_Type COMPCAPH; // 0x42004C19
__IO PTC_REG_INTCAP_Type INTCAP; // 0x42004C1A
__IO PTC_REG_SERRES_Type SERRES; // 0x42004C1B
__IO PTC_REG_CONVRESULT_Type RESULT; // 0x42004C1C + 0x42004C1D
uint8_t __pad4c1e__; // 0x42004C1E unknown
uint8_t __pad4c1f__; // 0x42004C1F unknown
__IO PTC_REG_BURSTMODE_Type BURSTMODE; // 0x42004C20
} Qtouch_Ptc;
#define QTOUCH_PTC (( Qtouch_Ptc *)0x42004C00U)
#define PTC_REG_INTDISABLE 0x42004C08
#define PTC_REG_INTENABLE 0x42004C09
#define PTC_BIT_EOCINTEN 0x01
#define PTC_BIT_WCOINTEN 0x02
#define PTC_REG_INTFLAGS 0x42004C0A
/* Touch library oversampling (filter) setting */
typedef enum tag_oversample_level_t {
OVERSAMPLE_1,
OVERSAMPLE_2,
OVERSAMPLE_4,
OVERSAMPLE_8,
OVERSAMPLE_16,
OVERSAMPLE_32,
OVERSAMPLE_64
}
oversample_t;
/* Touch library series resistor setting */
typedef enum tag_series_resistor_t {
RESISTOR_0,
RESISTOR_20K,
RESISTOR_50K,
RESISTOR_100K,
}
series_resistor_t;
typedef enum tag_freq_mode_t {
FREQ_MODE_NONE,
FREQ_MODE_HOP,
FREQ_MODE_SPREAD,
FREQ_MODE_SPREAD_MEDIAN
}
freq_mode_t;
typedef enum tag_freq_hop_t {
FREQ_HOP_1,
FREQ_HOP_2,
FREQ_HOP_3,
FREQ_HOP_4,
FREQ_HOP_5,
FREQ_HOP_6,
FREQ_HOP_7,
FREQ_HOP_8,
FREQ_HOP_9,
FREQ_HOP_10,
FREQ_HOP_11,
FREQ_HOP_12,
FREQ_HOP_13,
FREQ_HOP_14,
FREQ_HOP_15,
FREQ_HOP_16
}
freq_hop_t;
class Adafruit_CPlay_FreeTouch {
public:
Adafruit_CPlay_FreeTouch(int p = 0, oversample_t f = OVERSAMPLE_4, series_resistor_t r = RESISTOR_0, freq_mode_t fh = FREQ_MODE_NONE);
bool begin(void);
uint16_t measure(void);
uint16_t measureRaw(void);
private:
void ptcInitSettings(void);
void ptcConfigIOpin(void);
uint16_t startPtcAcquire(void);
void setupClock(void);
int getYLine(void);
void selectYLine(void);
void setOversampling(oversample_t lvl);
void setSeriesResistor(series_resistor_t res);
void setFreqHopping(freq_mode_t fh, freq_hop_t hops = FREQ_HOP_1);
void setCompCap(uint16_t cc);
void setIntCap(uint8_t ic);
void runInStandby(boolean en);
void enablePTC(boolean en);
void enableWCOint(boolean en);
void enableEOCint(boolean en);
void clearWCOintFlag(void);
void clearEOCintFlag(void);
void ptcAcquire(void);
void sync_config(void);
// debugging helper!
void snapshotRegsAndPrint(uint32_t base, uint8_t numregs);
void printPTCregs(uint32_t base, uint8_t *regs, uint8_t num);
void printHex(uint8_t h, boolean newline);
int pin; // arduino pin #
int8_t yline; // the Y select line (see datasheet)
oversample_t oversample;
series_resistor_t seriesres;
freq_mode_t freqhop;
freq_hop_t hops;
uint16_t compcap;
uint8_t intcap;
};
#endif
#endif

486
arduino-cli/libraries/Adafruit_Circuit_Playground/utility/Adafruit_CPlay_LIS3DH.cpp Normal file
View File

@@ -0,0 +1,486 @@
/*!
* @file Adafruit_CPlay_LIS3DH.cpp
*
*
* This is a library for the Adafruit LIS3DH Accel breakout board
*
* Designed specifically to work with the Adafruit LIS3DH Accel breakout board.
*
* Pick one up today in the adafruit shop!
* ------> https://www.adafruit.com/product/2809
*
* This sensor communicates over I2C or SPI (our library code supports both) so
* you can share it with a bunch of other sensors on the same I2C bus.
*
* Adafruit invests time and resources providing this open source code,
* please support Adafruit andopen-source hardware by purchasing products
* from Adafruit!
*
* K. Townsend / Limor Fried (Adafruit Industries)
*
* BSD license, all text above must be included in any redistribution
*/
#include "Arduino.h"
#include <Adafruit_CPlay_LIS3DH.h>
#include <Wire.h>
/*!
* @brief Instantiates a new LIS3DH class in I2C
* @param Wi
* optional wire object
*/
Adafruit_CPlay_LIS3DH::Adafruit_CPlay_LIS3DH(TwoWire *Wi)
: _cs(-1), _mosi(-1), _miso(-1), _sck(-1), _sensorID(-1) {
I2Cinterface = Wi;
}
/*!
* @brief Instantiates a new LIS3DH class using hardware SPI
* @param cspin
* number of CSPIN (Chip Select)
* @param *theSPI
* optional parameter contains spi object
*/
Adafruit_CPlay_LIS3DH::Adafruit_CPlay_LIS3DH(int8_t cspin, SPIClass *theSPI) {
_cs = cspin;
_mosi = -1;
_miso = -1;
_sck = -1;
_sensorID = -1;
SPIinterface = theSPI;
}
/*!
* @brief Instantiates a new LIS3DH class using software SPI
* @param cspin
* number of CSPIN (Chip Select)
* @param mosipin
* number of pin used for MOSI (Master Out Slave In))
* @param misopin
* number of pin used for MISO (Master In Slave Out)
* @param sckpin
* number of pin used for CLK (clock pin)
*/
Adafruit_CPlay_LIS3DH::Adafruit_CPlay_LIS3DH(int8_t cspin, int8_t mosipin, int8_t misopin,
int8_t sckpin) {
_cs = cspin;
_mosi = mosipin;
_miso = misopin;
_sck = sckpin;
_sensorID = -1;
}
/*!
* @brief Setups the HW (reads coefficients values, etc.)
* @param i2caddr
* i2c address (optional, fallback to default)
* @param nWAI
* Who Am I register value - defaults to 0x33 (LIS3DH)
* @return true if successful
*/
bool Adafruit_CPlay_LIS3DH::begin(uint8_t i2caddr, uint8_t nWAI) {
_i2caddr = i2caddr;
_wai = nWAI;
if (_cs == -1) {
// i2c
I2Cinterface->begin();
} else {
digitalWrite(_cs, HIGH);
pinMode(_cs, OUTPUT);
#ifndef __AVR_ATtiny85__
if (_sck == -1) {
// hardware SPI
SPIinterface->begin();
} else {
// software SPI
pinMode(_sck, OUTPUT);
pinMode(_mosi, OUTPUT);
pinMode(_miso, INPUT);
}
#endif
}
/*
Serial.println("Debug");
for (uint8_t i=0; i<0x30; i++) {
Serial.print("$");
Serial.print(i, HEX); Serial.print(" = 0x");
Serial.println(readRegister8(i), HEX);
}
*/
/* Check connection */
uint8_t deviceid = readRegister8(LIS3DH_REG_WHOAMI);
if (deviceid != _wai) {
/* No LIS3DH detected ... return false */
// Serial.println(deviceid, HEX);
return false;
}
// enable all axes, normal mode
writeRegister8(LIS3DH_REG_CTRL1, 0x07);
// 400Hz rate
setDataRate(LIS3DH_DATARATE_400_HZ);
// High res & BDU enabled
writeRegister8(LIS3DH_REG_CTRL4, 0x88);
// DRDY on INT1
writeRegister8(LIS3DH_REG_CTRL3, 0x10);
// Turn on orientation config
// writeRegister8(LIS3DH_REG_PL_CFG, 0x40);
// enable adcs
writeRegister8(LIS3DH_REG_TEMPCFG, 0x80);
/*
for (uint8_t i=0; i<0x30; i++) {
Serial.print("$");
Serial.print(i, HEX); Serial.print(" = 0x");
Serial.println(readRegister8(i), HEX);
}
*/
return true;
}
/*!
* @brief Get Device ID from LIS3DH_REG_WHOAMI
* @return WHO AM I value
*/
uint8_t Adafruit_CPlay_LIS3DH::getDeviceID() {
return readRegister8(LIS3DH_REG_WHOAMI);
}
/*!
* @brief Check to see if new data available
* @return true if there is new data available, false otherwise
*/
bool Adafruit_CPlay_LIS3DH::haveNewData() {
// checking ZYXDA in REG_STATUS2 tells us if data available
return (readRegister8(LIS3DH_REG_STATUS2) & 0x8) >> 3;
}
/*!
* @brief Reads x y z values at once
*/
void Adafruit_CPlay_LIS3DH::read() {
if (_cs == -1) {
// i2c
I2Cinterface->beginTransmission(_i2caddr);
I2Cinterface->write(LIS3DH_REG_OUT_X_L | 0x80); // 0x80 for autoincrement
I2Cinterface->endTransmission();
I2Cinterface->requestFrom(_i2caddr, 6);
x = I2Cinterface->read();
x |= ((uint16_t)I2Cinterface->read()) << 8;
y = I2Cinterface->read();
y |= ((uint16_t)I2Cinterface->read()) << 8;
z = I2Cinterface->read();
z |= ((uint16_t)I2Cinterface->read()) << 8;
}
#ifndef __AVR_ATtiny85__
else {
if (_sck == -1)
SPIinterface->beginTransaction(SPISettings(500000, MSBFIRST, SPI_MODE0));
digitalWrite(_cs, LOW);
spixfer(LIS3DH_REG_OUT_X_L | 0x80 | 0x40); // read multiple, bit 7&6 high
x = spixfer();
x |= ((uint16_t)spixfer()) << 8;
y = spixfer();
y |= ((uint16_t)spixfer()) << 8;
z = spixfer();
z |= ((uint16_t)spixfer()) << 8;
digitalWrite(_cs, HIGH);
if (_sck == -1)
SPIinterface->endTransaction(); // release the SPI bus
}
#endif
uint8_t range = getRange();
uint16_t divider = 1;
if (range == LIS3DH_RANGE_16_G)
divider = 1365; // different sensitivity at 16g
if (range == LIS3DH_RANGE_8_G)
divider = 4096;
if (range == LIS3DH_RANGE_4_G)
divider = 8190;
if (range == LIS3DH_RANGE_2_G)
divider = 16380;
x_g = (float)x / divider;
y_g = (float)y / divider;
z_g = (float)z / divider;
}
/*!
* @brief Read the auxilary ADC
* @param adc
* adc index. possible values (1, 2, 3).
* @return auxilary ADC value
*/
int16_t Adafruit_CPlay_LIS3DH::readADC(uint8_t adc) {
if ((adc < 1) || (adc > 3))
return 0;
uint16_t value;
adc--;
uint8_t reg = LIS3DH_REG_OUTADC1_L + adc * 2;
if (_cs == -1) {
// i2c
I2Cinterface->beginTransmission(_i2caddr);
I2Cinterface->write(reg | 0x80); // 0x80 for autoincrement
I2Cinterface->endTransmission();
I2Cinterface->requestFrom(_i2caddr, 2);
value = I2Cinterface->read();
value |= ((uint16_t)I2Cinterface->read()) << 8;
}
#ifndef __AVR_ATtiny85__
else {
if (_sck == -1)
SPIinterface->beginTransaction(SPISettings(500000, MSBFIRST, SPI_MODE0));
digitalWrite(_cs, LOW);
spixfer(reg | 0x80 | 0x40); // read multiple, bit 7&6 high
value = spixfer();
value |= ((uint16_t)spixfer()) << 8;
digitalWrite(_cs, HIGH);
if (_sck == -1)
SPIinterface->endTransaction(); // release the SPI bus
}
#endif
return value;
}
/*!
* @brief Set INT to output for single or double click
* @param c
* 0 = turn off I1_CLICK
* 1 = turn on all axes & singletap
* 2 = turn on all axes & doubletap
* @param clickthresh
* CLICK threshold value
* @param timelimit
* sets time limit (default 10)
* @param timelatency
* sets time latency (default 20)
* @param timewindow
* sets time window (default 255)
*/
void Adafruit_CPlay_LIS3DH::setClick(uint8_t c, uint8_t clickthresh,
uint8_t timelimit, uint8_t timelatency,
uint8_t timewindow) {
if (!c) {
// disable int
uint8_t r = readRegister8(LIS3DH_REG_CTRL3);
r &= ~(0x80); // turn off I1_CLICK
writeRegister8(LIS3DH_REG_CTRL3, r);
writeRegister8(LIS3DH_REG_CLICKCFG, 0);
return;
}
// else...
writeRegister8(LIS3DH_REG_CTRL3, 0x80); // turn on int1 click
writeRegister8(LIS3DH_REG_CTRL5, 0x08); // latch interrupt on int1
if (c == 1)
writeRegister8(LIS3DH_REG_CLICKCFG, 0x15); // turn on all axes & singletap
if (c == 2)
writeRegister8(LIS3DH_REG_CLICKCFG, 0x2A); // turn on all axes & doubletap
writeRegister8(LIS3DH_REG_CLICKTHS, clickthresh); // arbitrary
writeRegister8(LIS3DH_REG_TIMELIMIT, timelimit); // arbitrary
writeRegister8(LIS3DH_REG_TIMELATENCY, timelatency); // arbitrary
writeRegister8(LIS3DH_REG_TIMEWINDOW, timewindow); // arbitrary
}
/*!
* @brief Get uint8_t for single or double click
* @return register LIS3DH_REG_CLICKSRC
*/
uint8_t Adafruit_CPlay_LIS3DH::getClick() {
return readRegister8(LIS3DH_REG_CLICKSRC);
}
/*!
* @brief Sets the g range for the accelerometer
* @param range
* range value
*/
void Adafruit_CPlay_LIS3DH::setRange(lis3dh_range_t range) {
uint8_t r = readRegister8(LIS3DH_REG_CTRL4);
r &= ~(0x30);
r |= range << 4;
writeRegister8(LIS3DH_REG_CTRL4, r);
}
/*!
* @brief Gets the g range for the accelerometer
* @return Returns g range value
*/
lis3dh_range_t Adafruit_CPlay_LIS3DH::getRange() {
/* Read the data format register to preserve bits */
return (lis3dh_range_t)((readRegister8(LIS3DH_REG_CTRL4) >> 4) & 0x03);
}
/*!
* @brief Sets the data rate for the LIS3DH (controls power consumption)
* @param dataRate
* data rate value
*/
void Adafruit_CPlay_LIS3DH::setDataRate(lis3dh_dataRate_t dataRate) {
uint8_t ctl1 = readRegister8(LIS3DH_REG_CTRL1);
ctl1 &= ~(0xF0); // mask off bits
ctl1 |= (dataRate << 4);
writeRegister8(LIS3DH_REG_CTRL1, ctl1);
}
/*!
* @brief Gets the data rate for the LIS3DH (controls power consumption)
* @return Returns Data Rate value
*/
lis3dh_dataRate_t Adafruit_CPlay_LIS3DH::getDataRate() {
return (lis3dh_dataRate_t)((readRegister8(LIS3DH_REG_CTRL1) >> 4) & 0x0F);
}
/*!
* @brief Gets the most recent sensor event
* @param *event
* sensor event that we want to read
* @return true if successful
*/
bool Adafruit_CPlay_LIS3DH::getEvent(sensors_event_t *event) {
/* Clear the event */
memset(event, 0, sizeof(sensors_event_t));
event->version = sizeof(sensors_event_t);
event->sensor_id = _sensorID;
event->type = SENSOR_TYPE_ACCELEROMETER;
event->timestamp = 0;
read();
event->acceleration.x = x_g * SENSORS_GRAVITY_STANDARD;
event->acceleration.y = y_g * SENSORS_GRAVITY_STANDARD;
event->acceleration.z = z_g * SENSORS_GRAVITY_STANDARD;
return true;
}
/*!
* @brief Gets the sensor_t data
* @param *sensor
* sensor that we want to write data into
*/
void Adafruit_CPlay_LIS3DH::getSensor(sensor_t *sensor) {
/* Clear the sensor_t object */
memset(sensor, 0, sizeof(sensor_t));
/* Insert the sensor name in the fixed length char array */
strncpy(sensor->name, "LIS3DH", sizeof(sensor->name) - 1);
sensor->name[sizeof(sensor->name) - 1] = 0;
sensor->version = 1;
sensor->sensor_id = _sensorID;
sensor->type = SENSOR_TYPE_ACCELEROMETER;
sensor->min_delay = 0;
sensor->max_value = 0;
sensor->min_value = 0;
sensor->resolution = 0;
}
/*!
* @brief Low level SPI
* @param x
* value that will be written throught SPI
* @return reply
*/
uint8_t Adafruit_CPlay_LIS3DH::spixfer(uint8_t x) {
#ifndef __AVR_ATtiny85__
if (_sck == -1)
return SPIinterface->transfer(x);
// software spi
// Serial.println("Software SPI");
uint8_t reply = 0;
for (int i = 7; i >= 0; i--) {
reply <<= 1;
digitalWrite(_sck, LOW);
digitalWrite(_mosi, x & (1 << i));
digitalWrite(_sck, HIGH);
if (digitalRead(_miso))
reply |= 1;
}
return reply;
#endif
}
/*!
* @brief Writes 8-bits to the specified destination register
* @param reg
* register address
* @param value
* value that will be written into selected register
*/
void Adafruit_CPlay_LIS3DH::writeRegister8(uint8_t reg, uint8_t value) {
if (_cs == -1) {
I2Cinterface->beginTransmission((uint8_t)_i2caddr);
I2Cinterface->write((uint8_t)reg);
I2Cinterface->write((uint8_t)value);
I2Cinterface->endTransmission();
}
#ifndef __AVR_ATtiny85__
else {
if (_sck == -1)
SPIinterface->beginTransaction(SPISettings(500000, MSBFIRST, SPI_MODE0));
digitalWrite(_cs, LOW);
spixfer(reg & ~0x80); // write, bit 7 low
spixfer(value);
digitalWrite(_cs, HIGH);
if (_sck == -1)
SPIinterface->endTransaction(); // release the SPI bus
}
#endif
}
/*!
* @brief Reads 8-bits from the specified register
* @param reg
* register address
* @return read value
*/
uint8_t Adafruit_CPlay_LIS3DH::readRegister8(uint8_t reg) {
uint8_t value;
if (_cs == -1) {
I2Cinterface->beginTransmission(_i2caddr);
I2Cinterface->write((uint8_t)reg);
I2Cinterface->endTransmission();
I2Cinterface->requestFrom(_i2caddr, 1);
value = I2Cinterface->read();
}
#ifndef __AVR_ATtiny85__
else {
if (_sck == -1)
SPIinterface->beginTransaction(SPISettings(500000, MSBFIRST, SPI_MODE0));
digitalWrite(_cs, LOW);
spixfer(reg | 0x80); // read, bit 7 high
value = spixfer(0);
digitalWrite(_cs, HIGH);
if (_sck == -1)
SPIinterface->endTransaction(); // release the SPI bus
}
#endif
return value;
}

396
arduino-cli/libraries/Adafruit_Circuit_Playground/utility/Adafruit_CPlay_LIS3DH.h Normal file
View File

@@ -0,0 +1,396 @@
/*!
* @file Adafruit_CPlay_LIS3DH.h
*
* This is a library for the Adafruit LIS3DH Accel breakout board
*
* Designed specifically to work with the Adafruit LIS3DH Triple-Axis
*Accelerometer
* (+-2g/4g/8g/16g)
*
* Pick one up today in the adafruit shop!
* ------> https://www.adafruit.com/product/2809
*
* This sensor communicates over I2C or SPI (our library code supports
*both) so you can share it with a bunch of other sensors on the same I2C bus.
* There's an address selection pin so you can have two accelerometers share an
*I2C bus.
*
* Adafruit invests time and resources providing this open source code,
* please support Adafruit andopen-source hardware by purchasing products
* from Adafruit!
*
* K. Townsend / Limor Fried (Ladyada) - (Adafruit Industries).
*
* BSD license, all text above must be included in any redistribution
*/
#ifndef ADAFRUIT_CPLAY_LIS3DH_H
#define ADAFRUIT_CPLAY_LIS3DH_H
#include "Arduino.h"
#include <SPI.h>
#include <Wire.h>
#include "Adafruit_CPlay_Sensor.h"
/** I2C ADDRESS/BITS **/
#define LIS3DH_DEFAULT_ADDRESS (0x18) // if SDO/SA0 is 3V, its 0x19
/*!
* STATUS_REG_AUX register
* 321OR 1, 2 and 3 axis data overrun. Default value: 0
* (0: no overrun has occurred; 1: a new set of data has overwritten
* the previous ones) 3OR 3 axis data overrun. Default value: 0 (0: no
* overrun has occurred; 1: a new data for the 3-axis has overwritten the
* previous one) 2OR 2 axis data overrun. Default value: 0 (0: no overrun has
* occurred; 1: a new data for the 4-axis has overwritten the previous one) 1OR
* 1 axis data overrun. Default value: 0 (0: no overrun has occurred; 1: a new
* data for the 1-axis has overwritten the previous one) 321DA 1, 2 and 3 axis
* new data available. Default value: 0 (0: a new set of data is not yet
* available; 1: a new set of data is available) 3DA: 3 axis new data
* available. Default value: 0 (0: a new data for the 3-axis is not yet
* available; 1: a new data for the 3-axis is available) 2DA: 2 axis new data
* available. Default value: 0 (0: a new data for the 2-axis is not yet
* available; 1: a new data for the 2-axis is available) 1DA 1 axis new data
* available. Default value: 0 (0: a new data for the 1-axis is not yet
* available; 1: a new data for the 1-axis is available)
*/
#define LIS3DH_REG_STATUS1 0x07
#define LIS3DH_REG_OUTADC1_L 0x08 /**< 1-axis acceleration data. Low value */
#define LIS3DH_REG_OUTADC1_H 0x09 /**< 1-axis acceleration data. High value */
#define LIS3DH_REG_OUTADC2_L 0x0A /**< 2-axis acceleration data. Low value */
#define LIS3DH_REG_OUTADC2_H 0x0B /**< 2-axis acceleration data. High value */
#define LIS3DH_REG_OUTADC3_L 0x0C /**< 3-axis acceleration data. Low value */
#define LIS3DH_REG_OUTADC3_H 0x0D /**< 3-axis acceleration data. High value */
#define LIS3DH_REG_INTCOUNT \
0x0E /**< INT_COUNTER register [IC7, IC6, IC5, IC4, IC3, IC2, IC1, IC0] */
#define LIS3DH_REG_WHOAMI \
0x0F /**< Device identification register. [0, 0, 1, 1, 0, 0, 1, 1] */
/*!
* TEMP_CFG_REG
* Temperature configuration register.
* ADC_PD ADC enable. Default value: 0
* (0: ADC disabled; 1: ADC enabled)
* TEMP_EN Temperature sensor (T) enable. Default value: 0
* (0: T disabled; 1: T enabled)
*/
#define LIS3DH_REG_TEMPCFG 0x1F
/*!
* CTRL_REG1
* [ODR3, ODR2, ODR1, ODR0, LPen, Zen, Yen, Xen]
* ODR3-0 Data rate selection. Default value: 00
* (0000:50 Hz; Others: Refer to Datasheet Table 26, “Data rate
* configuration”) LPen Low power mode enable. Default value: 0 (0: normal
* mode, 1: low power mode) Zen Z axis enable. Default value: 1 (0: Z axis
* disabled; 1: Z axis enabled) Yen Y axis enable. Default value: 1 (0: Y
* axis disabled; 1: Y axis enabled) Xen X axis enable. Default value: 1 (0:
* X axis disabled; 1: X axis enabled)
*/
#define LIS3DH_REG_CTRL1 0x20
/*!
* CTRL_REG2
* [HPM1, HPM0, HPCF2, HPCF1, FDS, HPCLICK, HPIS2, HPIS1]
* HPM1-0 High pass filter mode selection. Default value: 00
* Refer to Table 29, "High pass filter mode configuration"
* HPCF2-1 High pass filter cut off frequency selection
* FDS Filtered data selection. Default value: 0
* (0: internal filter bypassed; 1: data from
*internal filter sent to output register and FIFO) HPCLICK High pass filter
*enabled for CLICK function. (0: filter bypassed; 1: filter enabled) HPIS2 X
*axis enable. Default value: 1 (0: X axis disabled; 1: X axis enabled) HPIS1
*High pass filter enabled for AOI function on interrupt 1, (0: filter bypassed;
*1: filter enabled)
*/
#define LIS3DH_REG_CTRL2 0x21
/*!
* CTRL_REG3
* [I1_CLICK, I1_AOI1, I1_AOI2, I1_DRDY1, I1_DRDY2, I1_WTM, I1_OVERRUN, --]
* I1_CLICK CLICK interrupt on INT1. Default value 0.
* (0: Disable; 1: Enable)
* I1_AOI1 AOI1 interrupt on INT1. Default value 0.
* (0: Disable; 1: Enable)
* I1_AOI2 AOI2 interrupt on INT1. Default value 0.
* (0: Disable; 1: Enable)
* I1_DRDY1 DRDY1 interrupt on INT1. Default value 0.
* (0: Disable; 1: Enable)
* I1_DRDY2 DRDY2 interrupt on INT1. Default value 0.
* (0: Disable; 1: Enable)
* I1_WTM FIFO Watermark interrupt on INT1. Default value 0.
* (0: Disable; 1: Enable)
* I1_OVERRUN FIFO Overrun interrupt on INT1. Default value 0.
* (0: Disable; 1: Enable)
*/
#define LIS3DH_REG_CTRL3 0x22
/*!
* CTRL_REG4
* [BDU, BLE, FS1, FS0, HR, ST1, ST0, SIM]
* BDU Block data update. Default value: 0
* (0: continuos update; 1: output registers not updated until MSB
* and LSB reading) BLE Big/little endian data selection. Default value 0.
* (0: Data LSB @ lower address; 1: Data MSB @ lower address)
* FS1-FS0 Full scale selection. default value: 00
* (00: +/- 2G; 01: +/- 4G; 10: +/- 8G; 11: +/- 16G)
* HR High resolution output mode: Default value: 0
* (0: High resolution disable; 1: High resolution Enable)
* ST1-ST0 Self test enable. Default value: 00
* (00: Self test disabled; Other: See Table 34)
* SIM SPI serial interface mode selection. Default value: 0
* (0: 4-wire interface; 1: 3-wire interface).
*/
#define LIS3DH_REG_CTRL4 0x23
/*!
* CTRL_REG5
* [BOOT, FIFO_EN, --, --, LIR_INT1, D4D_INT1, 0, 0]
* BOOT Reboot memory content. Default value: 0
* (0: normal mode; 1: reboot memory content)
* FIFO_EN FIFO enable. Default value: 0
* (0: FIFO disable; 1: FIFO Enable)
* LIR_INT1 Latch interrupt request on INT1_SRC register, with INT1_SRC
* register cleared by reading INT1_SRC itself. Default value: 0. (0: interrupt
* request not latched; 1: interrupt request latched) D4D_INT1 4D enable: 4D
* detection is enabled on INT1 when 6D bit on INT1_CFG is set to 1.
*/
#define LIS3DH_REG_CTRL5 0x24
/*!
* CTRL_REG6
* [I2_CLICKen, I2_INT1, 0, BOOT_I1, 0, --, H_L, -]
*/
#define LIS3DH_REG_CTRL6 0x25
#define LIS3DH_REG_REFERENCE 0x26 /**< REFERENCE/DATACAPTURE **/
/*!
* STATUS_REG
* [ZYXOR, ZOR, YOR, XOR, ZYXDA, ZDA, YDA, XDA]
* ZYXOR X, Y and Z axis data overrun. Default value: 0
* (0: no overrun has occurred; 1: a new set of data has overwritten
* the previous ones) ZOR Z axis data overrun. Default value: 0 (0: no
* overrun has occurred; 1: a new data for the Z-axis has overwritten the
* previous one) YOR Y axis data overrun. Default value: 0 (0: no overrun
* has occurred; 1: a new data for the Y-axis has overwritten the previous one)
* XOR X axis data overrun. Default value: 0
* (0: no overrun has occurred; 1: a new data for the X-axis has
* overwritten the previous one) ZYXDA X, Y and Z axis new data available.
* Default value: 0 (0: a new set of data is not yet available; 1: a new set of
* data is available) ZDA Z axis new data available. Default value: 0 (0: a
* new data for the Z-axis is not yet available; 1: a new data for the Z-axis is
* available) YDA Y axis new data available. Default value: 0 (0: a new
* data for the Y-axis is not yet available; 1: a new data for the Y-axis is
* available)
*/
#define LIS3DH_REG_STATUS2 0x27
#define LIS3DH_REG_OUT_X_L 0x28 /**< X-axis acceleration data. Low value */
#define LIS3DH_REG_OUT_X_H 0x29 /**< X-axis acceleration data. High value */
#define LIS3DH_REG_OUT_Y_L 0x2A /**< Y-axis acceleration data. Low value */
#define LIS3DH_REG_OUT_Y_H 0x2B /**< Y-axis acceleration data. High value */
#define LIS3DH_REG_OUT_Z_L 0x2C /**< Z-axis acceleration data. Low value */
#define LIS3DH_REG_OUT_Z_H 0x2D /**< Z-axis acceleration data. High value */
/*!
* FIFO_CTRL_REG
* [FM1, FM0, TR, FTH4, FTH3, FTH2, FTH1, FTH0]
* FM1-FM0 FIFO mode selection. Default value: 00 (see Table 44)
* TR Trigger selection. Default value: 0
* 0: Trigger event liked to trigger signal on INT1
* 1: Trigger event liked to trigger signal on INT2
* FTH4:0 Default value: 0
*/
#define LIS3DH_REG_FIFOCTRL 0x2E
#define LIS3DH_REG_FIFOSRC \
0x2F /**< FIFO_SRC_REG [WTM, OVRN_FIFO, EMPTY, FSS4, FSS3, FSS2, FSS1, FSS0] \
*/
/*!
* INT1_CFG
* [AOI, 6D, ZHIE/ZUPE, ZLIE/ZDOWNE, YHIE/YUPE, XHIE/XUPE, XLIE/XDOWNE]
* AOI And/Or combination of Interrupt events. Default value: 0. Refer
* to Datasheet Table 48, "Interrupt mode" 6D 6 direction detection
* function enabled. Default value: 0. Refer to Datasheet Table 48, "Interrupt
* mode" ZHIE/ZUPE Enable interrupt generation on Z high event or on Direction
* recognition. Default value: 0. (0: disable interrupt request; 1: enable
* interrupt request) ZLIE/ZDOWNE Enable interrupt generation on Z low event or
* on Direction recognition. Default value: 0. YHIE/YUPE Enable interrupt
* generation on Y high event or on Direction recognition. Default value: 0. (0:
* disable interrupt request; 1: enable interrupt request.) YLIE/YDOWNE Enable
* interrupt generation on Y low event or on Direction recognition. Default
* value: 0. (0: disable interrupt request; 1: enable interrupt request.)
* XHIE/XUPE Enable interrupt generation on X high event or on Direction
* recognition. Default value: 0. (0: disable interrupt request; 1: enable
* interrupt request.) XLIE/XDOWNE Enable interrupt generation on X low event or
* on Direction recognition. Default value: 0. (0: disable interrupt request; 1:
* enable interrupt request.)
*/
#define LIS3DH_REG_INT1CFG 0x30
/*!
* INT1_SRC
* [0, IA, ZH, ZL, YH, YL, XH, XL]
* IA Interrupt active. Default value: 0
* (0: no interrupt has been generated; 1: one or more interrupts have
* been generated) ZH Z high. Default value: 0 (0: no interrupt, 1: Z High
* event has occurred) ZL Z low. Default value: 0 (0: no interrupt; 1: Z Low
* event has occurred) YH Y high. Default value: 0 (0: no interrupt, 1: Y High
* event has occurred) YL Y low. Default value: 0 (0: no interrupt, 1: Y Low
* event has occurred) XH X high. Default value: 0 (0: no interrupt, 1: X High
* event has occurred) XL X low. Default value: 0 (0: no interrupt, 1: X Low
* event has occurred)
*
* Interrupt 1 source register. Read only register.
* Reading at this address clears INT1_SRC IA bit (and the interrupt signal
* on INT 1 pin) and allows the refreshment of data in the INT1_SRC register if
* the latched option was chosen.
*/
#define LIS3DH_REG_INT1SRC 0x31
#define LIS3DH_REG_INT1THS \
0x32 /**< INT1_THS register [0, THS6, THS5, THS4, THS3, THS1, THS0] */
#define LIS3DH_REG_INT1DUR \
0x33 /**< INT1_DURATION [0, D6, D5, D4, D3, D2, D1, D0] */
/*!
* CLICK_CFG
* [--, --, ZD, ZS, YD, YS, XD, XS]
* ZD Enable interrupt double CLICK-CLICK on Z axis. Default value: 0
* (0: disable interrupt request;
* 1: enable interrupt request on measured accel. value higher than
* preset threshold) ZS Enable interrupt single CLICK-CLICK on Z axis. Default
* value: 0 (0: disable interrupt request; 1: enable interrupt request on
* measured accel. value higher than preset threshold) YD Enable interrupt
* double CLICK-CLICK on Y axis. Default value: 0 (0: disable interrupt request;
* 1: enable interrupt request on measured accel. value higher than
* preset threshold) YS Enable interrupt single CLICK-CLICK on Y axis. Default
* value: 0 (0: disable interrupt request; 1: enable interrupt request on
* measured accel. value higher than preset threshold) XD Enable interrupt
* double CLICK-CLICK on X axis. Default value: 0 (0: disable interrupt request;
* 1: enable interrupt request on measured accel. value higher than preset
* threshold) XS Enable interrupt single CLICK-CLICK on X axis. Default value:
* 0 (0: disable interrupt request; 1: enable interrupt request on measured
* accel. value higher than preset threshold)
*/
#define LIS3DH_REG_CLICKCFG 0x38
/*!
* CLICK_SRC
* [-, IA, DCLICK, SCLICK, Sign, Z, Y, X]
* IA Interrupt active. Default value: 0
* (0: no interrupt has been generated; 1: one or more interrupts have
* been generated) DCLICK Double CLICK-CLICK enable. Default value: 0 (0:double
* CLICK-CLICK detection disable, 1: double CLICK-CLICK detection enable) SCLICK
* Single CLICK-CLICK enable. Default value: 0 (0:Single CLICK-CLICK detection
* disable, 1: single CLICK-CLICK detection enable) Sign CLICK-CLICK Sign.
* (0: positive detection, 1: negative detection)
* Z Z CLICK-CLICK detection. Default value: 0
* (0: no interrupt, 1: Z High event has occurred)
* Y Y CLICK-CLICK detection. Default value: 0
* (0: no interrupt, 1: Y High event has occurred)
* X X CLICK-CLICK detection. Default value: 0
* (0: no interrupt, 1: X High event has occurred)
*/
#define LIS3DH_REG_CLICKSRC 0x39
/*!
* CLICK_THS
* [-, Ths6, Ths5, Ths4, Ths3, Ths2, Ths1, Ths0]
* Ths6-Ths0 CLICK-CLICK threshold. Default value: 000 0000
*/
#define LIS3DH_REG_CLICKTHS 0x3A
/*!
* TIME_LIMIT
* [-, TLI6, TLI5, TLI4, TLI3, TLI2, TLI1, TLI0]
* TLI7-TLI0 CLICK-CLICK Time Limit. Default value: 000 0000
*/
#define LIS3DH_REG_TIMELIMIT 0x3B
/*!
* TIME_LATANCY
* [-, TLA6, TLIA5, TLA4, TLA3, TLA2, TLA1, TLA0]
* TLA7-TLA0 CLICK-CLICK Time Latency. Default value: 000 0000
*/
#define LIS3DH_REG_TIMELATENCY 0x3C
/*!
* TIME_WINDOW
* [TW7, TW6, TW5, TW4, TW3, TW2, TW1, TW0]
* TW7-TW0 CLICK-CLICK Time window
*/
#define LIS3DH_REG_TIMEWINDOW 0x3D
/** A structure to represent scales **/
typedef enum {
LIS3DH_RANGE_16_G = 0b11, // +/- 16g
LIS3DH_RANGE_8_G = 0b10, // +/- 8g
LIS3DH_RANGE_4_G = 0b01, // +/- 4g
LIS3DH_RANGE_2_G = 0b00 // +/- 2g (default value)
} lis3dh_range_t;
/** A structure to represent axes **/
typedef enum {
LIS3DH_AXIS_X = 0x0,
LIS3DH_AXIS_Y = 0x1,
LIS3DH_AXIS_Z = 0x2,
} lis3dh_axis_t;
/** Used with register 0x2A (LIS3DH_REG_CTRL_REG1) to set bandwidth **/
typedef enum {
LIS3DH_DATARATE_400_HZ = 0b0111, // 400Hz
LIS3DH_DATARATE_200_HZ = 0b0110, // 200Hz
LIS3DH_DATARATE_100_HZ = 0b0101, // 100Hz
LIS3DH_DATARATE_50_HZ = 0b0100, // 50Hz
LIS3DH_DATARATE_25_HZ = 0b0011, // 25Hz
LIS3DH_DATARATE_10_HZ = 0b0010, // 10 Hz
LIS3DH_DATARATE_1_HZ = 0b0001, // 1 Hz
LIS3DH_DATARATE_POWERDOWN = 0,
LIS3DH_DATARATE_LOWPOWER_1K6HZ = 0b1000,
LIS3DH_DATARATE_LOWPOWER_5KHZ = 0b1001,
} lis3dh_dataRate_t;
/*!
* @brief Class that stores state and functions for interacting with
* Adafruit_LIS3DH
*/
class Adafruit_CPlay_LIS3DH : public Adafruit_Sensor {
public:
Adafruit_CPlay_LIS3DH(TwoWire *Wi = &Wire);
Adafruit_CPlay_LIS3DH(int8_t cspin, SPIClass *theSPI = &SPI);
Adafruit_CPlay_LIS3DH(int8_t cspin, int8_t mosipin, int8_t misopin, int8_t sckpin);
bool begin(uint8_t addr = LIS3DH_DEFAULT_ADDRESS, uint8_t nWAI = 0x33);
uint8_t getDeviceID();
bool haveNewData();
void read();
int16_t readADC(uint8_t a);
void setRange(lis3dh_range_t range);
lis3dh_range_t getRange(void);
void setDataRate(lis3dh_dataRate_t dataRate);
lis3dh_dataRate_t getDataRate(void);
bool getEvent(sensors_event_t *event);
void getSensor(sensor_t *sensor);
void setClick(uint8_t c, uint8_t clickthresh, uint8_t timelimit = 10,
uint8_t timelatency = 20, uint8_t timewindow = 255);
uint8_t getClick(void);
int16_t x; /**< x axis value */
int16_t y; /**< y axis value */
int16_t z; /**< z axis value */
float x_g; /**< x_g axis value (calculated by selected range) */
float y_g; /**< y_g axis value (calculated by selected range) */
float z_g; /**< z_g axis value (calculated by selected scale) */
protected:
uint8_t spixfer(uint8_t x = 0xFF);
void writeRegister8(uint8_t reg, uint8_t value);
uint8_t readRegister8(uint8_t reg);
private:
TwoWire *I2Cinterface;
SPIClass *SPIinterface;
uint8_t _wai;
int8_t _cs, _mosi, _miso, _sck;
int8_t _i2caddr;
int32_t _sensorID;
};
#endif

297
arduino-cli/libraries/Adafruit_Circuit_Playground/utility/Adafruit_CPlay_Mic.cpp Normal file
View File

@@ -0,0 +1,297 @@
// Adafruit Circuit Playground microphone library
// by Phil Burgess / Paint Your Dragon.
// Fast Fourier transform section is derived from
// ELM-ChaN FFT library (see comments in ffft.S).
#include <Arduino.h>
#include "Adafruit_CPlay_Mic.h"
#if defined(ARDUINO_ARCH_SAMD)
#define SAMPLERATE_HZ 22000
#define DECIMATION 64
Adafruit_ZeroPDM Adafruit_CPlay_Mic::pdm = Adafruit_ZeroPDM(34, 35);
// a windowed sinc filter for 44 khz, 64 samples
uint16_t sincfilter[DECIMATION] = {0, 2, 9, 21, 39, 63, 94, 132, 179, 236, 302, 379, 467, 565, 674, 792, 920, 1055, 1196, 1341, 1487, 1633, 1776, 1913, 2042, 2159, 2263, 2352, 2422,
2474, 2506, 2516, 2506, 2474, 2422, 2352, 2263, 2159, 2042, 1913, 1776, 1633, 1487, 1341, 1196, 1055, 920, 792, 674, 565, 467, 379, 302, 236, 179, 132, 94, 63, 39, 21, 9, 2, 0, 0};
// a manual loop-unroller!
#define ADAPDM_REPEAT_LOOP_16(X) X X X X X X X X X X X X X X X X
static bool pdmConfigured = false;
#elif defined(ARDUINO_NRF52840_CIRCUITPLAY)
#include <PDM.h>
#define SAMPLERATE_HZ 16000
// buffer to read samples into, each sample is 16-bits
uint16_t sampleBuffer[256];
// number of samples read
volatile int samplesRead;
static void onPDMdata() {
// query the number of bytes available
int bytesAvailable = PDM.available();
// read into the sample buffer
PDM.read(sampleBuffer, bytesAvailable);
// 16-bit, 2 bytes per sample
samplesRead = bytesAvailable / 2;
}
static bool pdmConfigured = false;
#endif
#define DC_OFFSET (1023 / 3)
#define NOISE_THRESHOLD 3
/**************************************************************************/
/*!
@brief Reads ADC for given interval (in milliseconds, 1-65535). Uses ADC free-run mode w/polling on AVR.
Any currently-installed ADC interrupt handler will be temporarily
disabled while this runs.
@param ms the number of milliseconds to sample
@return max deviation from DC_OFFSET (e.g. 0-341)
@deprecated THIS FUNCTION IS DEPRECATED AND WILL BE REMOVED IN A FUTURE RELEASE.
please use soundPressureLevel(ms) instead
@note THIS FUNCTION IS DEPRECATED AND WILL BE REMOVED IN A FUTURE RELEASE.
please use soundPressureLevel(ms) instead
*/
/**************************************************************************/
int Adafruit_CPlay_Mic::peak(uint16_t ms) {
int val = soundPressureLevel(ms);
val = map(val, 56, 130, 0, 350);
return constrain(val, 0, 350);
}
/**************************************************************************/
/*!
@brief capture the passed number of samples and place them in buf.
@param buf the buffer to store the samples in
@param nSamples the number of samples to take
@note ON AVR: Captures ADC audio samples at maximum speed supported by 32u4 (9615 Hz).
Ostensibly for FFT code (below), but might have other uses. Uses ADC
free-run mode w/polling. Any currently-installed ADC interrupt handler
will be temporarily disabled while this runs. No other interrupts are
disabled; as long as interrupt handlers are minor (e.g. Timer/Counter 0
handling of millis() and micros()), this isn't likely to lose readings.
*/
/**************************************************************************/
void Adafruit_CPlay_Mic::capture(int16_t *buf, uint16_t nSamples) {
#ifdef __AVR__
uint8_t admux_save, adcsra_save, adcsrb_save, timsk0_save, channel;
int16_t adc;
channel = analogPinToChannel(4); // Pin A4 to ADC channel
admux_save = ADMUX; // Save ADC config registers
adcsra_save = ADCSRA;
adcsrb_save = ADCSRB;
// Init ADC free-run mode; f = ( 8MHz/prescaler ) / 13 cycles/conversion
ADCSRA = 0; // Stop ADC interrupt, if any
ADMUX = _BV(REFS0) | channel; // Aref=AVcc, channel sel, right-adj
ADCSRB = 0; // Free run mode, no high MUX bit
ADCSRA = _BV(ADEN) | // ADC enable
_BV(ADSC) | // ADC start
_BV(ADATE) | // Auto trigger
_BV(ADIF) | // Reset interrupt flag
_BV(ADPS2) | _BV(ADPS1); // 64:1 / 13 = 9615 Hz
// ADC conversion-ready bit is polled for each sample rather than using
// an interrupt; avoids contention with application or other library
// using ADC ISR for other things (there can be only one) while still
// providing the speed & precise timing of free-run mode (a loop of
// analogRead() won't get you that).
for(uint16_t i=0; i<nSamples; i++) {
while(!(ADCSRA & _BV(ADIF))); // Wait for ADC result
adc = ADC;
ADCSRA |= _BV(ADIF); // Clear bit
// FFT requires signed inputs; ADC output is unsigned. DC offset is
// NOT 512 on Circuit Playground because it uses a 1.1V OpAmp input
// as the midpoint, and may swing asymmetrically on the high side.
// Sign-convert and then clip range to +/- DC_OFFSET.
if(adc <= (DC_OFFSET - NOISE_THRESHOLD)) {
adc -= DC_OFFSET;
} else if(adc >= (DC_OFFSET + NOISE_THRESHOLD)) {
adc -= DC_OFFSET;
if(adc > (DC_OFFSET * 2)) adc = DC_OFFSET * 2;
} else {
adc = 0; // Below noise threshold
}
buf[i] = adc;
}
ADMUX = admux_save; // Restore ADC config
ADCSRB = adcsrb_save;
ADCSRA = adcsra_save;
(void)analogRead(A4); // Purge residue from ADC register
#elif defined(ARDUINO_ARCH_SAMD)
if(!pdmConfigured){
pdm.begin();
pdm.configure(SAMPLERATE_HZ * DECIMATION / 16, true);
pdmConfigured = true;
}
int16_t *ptr = buf;
while(ptr < (buf + nSamples)){
uint16_t runningsum = 0;
uint16_t *sinc_ptr = sincfilter;
for (uint8_t samplenum=0; samplenum < (DECIMATION/16) ; samplenum++) {
uint16_t sample = pdm.read() & 0xFFFF; // we read 16 bits at a time, by default the low half
ADAPDM_REPEAT_LOOP_16( // manually unroll loop: for (int8_t b=0; b<16; b++)
{
// start at the LSB which is the 'first' bit to come down the line, chronologically
// (Note we had to set I2S_SERCTRL_BITREV to get this to work, but saves us time!)
if (sample & 0x1) {
runningsum += *sinc_ptr; // do the convolution
}
sinc_ptr++;
sample >>= 1;
}
)
}
// since we wait for the samples from I2S peripheral, we dont need to delay, we will 'naturally'
// wait the right amount of time between analog writes
//Serial.println(runningsum);
runningsum /= 64 ; // convert 16 bit -> 10 bit
runningsum -= 512; // make it close to 0-offset signed
*ptr++ = runningsum;
}
#elif defined(ARDUINO_NRF52840_CIRCUITPLAY)
if(!pdmConfigured){
PDM.onReceive(onPDMdata);
PDM.begin(1, SAMPLERATE_HZ);
pdmConfigured = true;
}
memset(buf, 0, sizeof(uint16_t)*nSamples);
while (nSamples) {
PDM.IrqHandler();
if (samplesRead) {
int toRead = min(nSamples, samplesRead);
for (int i = 0; i < toRead; i++) {
buf[0] = sampleBuffer[i];
buf++;
nSamples--;
}
samplesRead = 0; // reset so we will get more data next time!
}
yield();
}
#else
#error "no compatible architecture defined."
#endif
}
/**************************************************************************/
/*!
@brief Returns somewhat-calibrated sound pressure level.
@param ms Milliseconds to continuously sample microphone over, 10ms is a good start.
@returns Floating point Sound Pressure Level, tends to range from 40-120 db SPL
*/
/**************************************************************************/
float Adafruit_CPlay_Mic::soundPressureLevel(uint16_t ms){
double gain;
int16_t *ptr;
uint16_t len;
int16_t minVal = 52;
#ifdef __AVR__
gain = 1.3;
len = 9.615 * ms;
#elif defined(ARDUINO_ARCH_SAMD)
gain = 9;
len = (float)(SAMPLERATE_HZ/1000) * ms;
#elif defined(ARDUINO_NRF52840_CIRCUITPLAY)
gain = 2;
len = (float)(SAMPLERATE_HZ/1000) * ms;
#else
#error "no compatible architecture defined."
#endif
int16_t data[len];
capture(data, len);
int16_t *end = data + len;
double pref = 0.00002;
/*******************************
* REMOVE DC OFFSET
******************************/
int32_t avg = 0;
ptr = data;
while(ptr < end) avg += *ptr++;
avg = avg/len;
ptr = data;
while(ptr < end) *ptr++ -= avg;
/*******************************
* GET MAX VALUE
******************************/
int16_t maxVal = 0;
ptr = data;
while(ptr < end){
int32_t v = abs(*ptr++);
if(v > maxVal) maxVal = v;
}
double conv = ((float)maxVal)/1023 * gain;
/*******************************
* CALCULATE SPL
******************************/
conv = 20 * log10(conv/pref);
if(isfinite(conv)) return conv;
else return minVal;
}
/**************************************************************************/
/*!
@brief 16 bit complex data type
*/
/**************************************************************************/
typedef struct {
int16_t r; ///< real portion
int16_t i; ///< imaginary portion
} complex_t;
extern "C" { // In ffft.S
void fft_input(const int16_t *, complex_t *),
fft_execute(complex_t *),
fft_output(complex_t *, uint16_t *);
}
/**************************************************************************/
/*!
@brief AVR ONLY: Performs one cycle of fast Fourier transform (FFT) with audio captured
from mic on A4. Output is 32 'bins,' each covering an equal range of
frequencies from 0 to 4800 Hz (i.e. 0-150 Hz, 150-300 Hz, 300-450, etc).
Needs about 450 bytes free RAM to operate.
@param spectrum the buffer to store the results in. Must be 32 bytes in length.
@note THIS FUNCTION IS DEPRECATED AND WILL BE REMOVED IN A FUTURE RELEASE.
*/
/**************************************************************************/
void Adafruit_CPlay_Mic::fft(
uint16_t *spectrum) { // Spectrum output buffer, uint16_t[32]
if(spectrum) {
int16_t capBuf[64]; // Audio capture buffer
complex_t butterfly[64]; // FFT "butterfly" buffer
capture(capBuf, 64); // Collect mic data into capBuf
fft_input(capBuf, butterfly); // Samples -> complex #s
fft_execute(butterfly); // Process complex data
fft_output(butterfly, spectrum); // Complex -> spectrum (32 bins)
}
}

41
arduino-cli/libraries/Adafruit_Circuit_Playground/utility/Adafruit_CPlay_Mic.h Normal file
View File

@@ -0,0 +1,41 @@
// Adafruit Circuit Playground microphone library
// by Phil Burgess / Paint Your Dragon.
// Fast Fourier transform section is derived from
// ELM-ChaN FFT library (see comments in ffft.S).
#ifndef ADAFRUIT_CPLAY_MIC_H
#define ADAFRUIT_CPLAY_MIC_H
#ifdef __GNUC__
#define DEPRECATED(func) func __attribute__ ((deprecated))
#elif defined(_MSC_VER)
#define DEPRECATED(func) __declspec(deprecated) func
#else
#pragma message("WARNING: You need to implement DEPRECATED for this compiler")
#define DEPRECATED(func) func
#endif
#include "Adafruit_ZeroPDM.h"
/**************************************************************************/
/*!
@brief Class that stores state and functions for the microphone on CircuitPlayground boards
*/
/**************************************************************************/
class Adafruit_CPlay_Mic {
public:
Adafruit_CPlay_Mic(void) {}; // Empty constructor
int peak(uint16_t ms) __attribute__ ((deprecated));
void capture(int16_t *buf, uint16_t nSamples),
fft(uint16_t *spectrum);
float soundPressureLevel(uint16_t ms);
private:
#if defined(ARDUINO_ARCH_SAMD)
static Adafruit_ZeroPDM pdm;
#endif
};
#endif // ADAFRUIT_CPLAY_MIC_H

2572
arduino-cli/libraries/Adafruit_Circuit_Playground/utility/Adafruit_CPlay_NeoPixel.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

362
arduino-cli/libraries/Adafruit_Circuit_Playground/utility/Adafruit_CPlay_NeoPixel.h Normal file
View File

@@ -0,0 +1,362 @@
/*!
* This is part of Adafruit's NeoPixel library for the Arduino platform,
* allowing a broad range of microcontroller boards (most AVR boards,
* many ARM devices, ESP8266 and ESP32, among others) to control Adafruit
* NeoPixels, FLORA RGB Smart Pixels and compatible devices -- WS2811,
* WS2812, WS2812B, SK6812, etc.
*
* Adafruit invests time and resources providing this open source code,
* please support Adafruit and open-source hardware by purchasing products
* from Adafruit!
*
* Written by Phil "Paint Your Dragon" Burgess for Adafruit Industries,
* with contributions by PJRC, Michael Miller and other members of the
* open source community.
*
* This file is part of the Adafruit_NeoPixel library.
*
* Adafruit_NeoPixel 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 3 of the
* License, or (at your option) any later version.
*
* Adafruit_NeoPixel 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 NeoPixel. If not, see
* <http://www.gnu.org/licenses/>.
*
*/
#ifndef ADAFRUIT_CPLAY_NEOPIXEL_H
#define ADAFRUIT_CPLAY_NEOPIXEL_H
#ifdef ARDUINO
#if (ARDUINO >= 100)
#include <Arduino.h>
#else
#include <WProgram.h>
#include <pins_arduino.h>
#endif
#endif
#ifdef TARGET_LPC1768
#include <Arduino.h>
#endif
// The order of primary colors in the NeoPixel data stream can vary among
// device types, manufacturers and even different revisions of the same
// item. The third parameter to the Adafruit_NeoPixel constructor encodes
// the per-pixel byte offsets of the red, green and blue primaries (plus
// white, if present) in the data stream -- the following #defines provide
// an easier-to-use named version for each permutation. e.g. NEO_GRB
// indicates a NeoPixel-compatible device expecting three bytes per pixel,
// with the first byte transmitted containing the green value, second
// containing red and third containing blue. The in-memory representation
// of a chain of NeoPixels is the same as the data-stream order; no
// re-ordering of bytes is required when issuing data to the chain.
// Most of these values won't exist in real-world devices, but it's done
// this way so we're ready for it (also, if using the WS2811 driver IC,
// one might have their pixels set up in any weird permutation).
// Bits 5,4 of this value are the offset (0-3) from the first byte of a
// pixel to the location of the red color byte. Bits 3,2 are the green
// offset and 1,0 are the blue offset. If it is an RGBW-type device
// (supporting a white primary in addition to R,G,B), bits 7,6 are the
// offset to the white byte...otherwise, bits 7,6 are set to the same value
// as 5,4 (red) to indicate an RGB (not RGBW) device.
// i.e. binary representation:
// 0bWWRRGGBB for RGBW devices
// 0bRRRRGGBB for RGB
// RGB NeoPixel permutations; white and red offsets are always same
// Offset: W R G B
#define NEO_RGB ((0<<6) | (0<<4) | (1<<2) | (2)) ///< Transmit as R,G,B
#define NEO_RBG ((0<<6) | (0<<4) | (2<<2) | (1)) ///< Transmit as R,B,G
#define NEO_GRB ((1<<6) | (1<<4) | (0<<2) | (2)) ///< Transmit as G,R,B
#define NEO_GBR ((2<<6) | (2<<4) | (0<<2) | (1)) ///< Transmit as G,B,R
#define NEO_BRG ((1<<6) | (1<<4) | (2<<2) | (0)) ///< Transmit as B,R,G
#define NEO_BGR ((2<<6) | (2<<4) | (1<<2) | (0)) ///< Transmit as B,G,R
// RGBW NeoPixel permutations; all 4 offsets are distinct
// Offset: W R G B
#define NEO_WRGB ((0<<6) | (1<<4) | (2<<2) | (3)) ///< Transmit as W,R,G,B
#define NEO_WRBG ((0<<6) | (1<<4) | (3<<2) | (2)) ///< Transmit as W,R,B,G
#define NEO_WGRB ((0<<6) | (2<<4) | (1<<2) | (3)) ///< Transmit as W,G,R,B
#define NEO_WGBR ((0<<6) | (3<<4) | (1<<2) | (2)) ///< Transmit as W,G,B,R
#define NEO_WBRG ((0<<6) | (2<<4) | (3<<2) | (1)) ///< Transmit as W,B,R,G
#define NEO_WBGR ((0<<6) | (3<<4) | (2<<2) | (1)) ///< Transmit as W,B,G,R
#define NEO_RWGB ((1<<6) | (0<<4) | (2<<2) | (3)) ///< Transmit as R,W,G,B
#define NEO_RWBG ((1<<6) | (0<<4) | (3<<2) | (2)) ///< Transmit as R,W,B,G
#define NEO_RGWB ((2<<6) | (0<<4) | (1<<2) | (3)) ///< Transmit as R,G,W,B
#define NEO_RGBW ((3<<6) | (0<<4) | (1<<2) | (2)) ///< Transmit as R,G,B,W
#define NEO_RBWG ((2<<6) | (0<<4) | (3<<2) | (1)) ///< Transmit as R,B,W,G
#define NEO_RBGW ((3<<6) | (0<<4) | (2<<2) | (1)) ///< Transmit as R,B,G,W
#define NEO_GWRB ((1<<6) | (2<<4) | (0<<2) | (3)) ///< Transmit as G,W,R,B
#define NEO_GWBR ((1<<6) | (3<<4) | (0<<2) | (2)) ///< Transmit as G,W,B,R
#define NEO_GRWB ((2<<6) | (1<<4) | (0<<2) | (3)) ///< Transmit as G,R,W,B
#define NEO_GRBW ((3<<6) | (1<<4) | (0<<2) | (2)) ///< Transmit as G,R,B,W
#define NEO_GBWR ((2<<6) | (3<<4) | (0<<2) | (1)) ///< Transmit as G,B,W,R
#define NEO_GBRW ((3<<6) | (2<<4) | (0<<2) | (1)) ///< Transmit as G,B,R,W
#define NEO_BWRG ((1<<6) | (2<<4) | (3<<2) | (0)) ///< Transmit as B,W,R,G
#define NEO_BWGR ((1<<6) | (3<<4) | (2<<2) | (0)) ///< Transmit as B,W,G,R
#define NEO_BRWG ((2<<6) | (1<<4) | (3<<2) | (0)) ///< Transmit as B,R,W,G
#define NEO_BRGW ((3<<6) | (1<<4) | (2<<2) | (0)) ///< Transmit as B,R,G,W
#define NEO_BGWR ((2<<6) | (3<<4) | (1<<2) | (0)) ///< Transmit as B,G,W,R
#define NEO_BGRW ((3<<6) | (2<<4) | (1<<2) | (0)) ///< Transmit as B,G,R,W
// Add NEO_KHZ400 to the color order value to indicate a 400 KHz device.
// All but the earliest v1 NeoPixels expect an 800 KHz data stream, this is
// the default if unspecified. Because flash space is very limited on ATtiny
// devices (e.g. Trinket, Gemma), v1 NeoPixels aren't handled by default on
// those chips, though it can be enabled by removing the ifndef/endif below,
// but code will be bigger. Conversely, can disable the NEO_KHZ400 line on
// other MCUs to remove v1 support and save a little space.
#define NEO_KHZ800 0x0000 ///< 800 KHz data transmission
#ifndef __AVR_ATtiny85__
#define NEO_KHZ400 0x0100 ///< 400 KHz data transmission
#endif
// If 400 KHz support is enabled, the third parameter to the constructor
// requires a 16-bit value (in order to select 400 vs 800 KHz speed).
// If only 800 KHz is enabled (as is default on ATtiny), an 8-bit value
// is sufficient to encode pixel color order, saving some space.
#ifdef NEO_KHZ400
typedef uint16_t neoPixelType; ///< 3rd arg to Adafruit_NeoPixel constructor
#else
typedef uint8_t neoPixelType; ///< 3rd arg to Adafruit_NeoPixel constructor
#endif
// These two tables are declared outside the Adafruit_NeoPixel class
// because some boards may require oldschool compilers that don't
// handle the C++11 constexpr keyword.
/* A PROGMEM (flash mem) table containing 8-bit unsigned sine wave (0-255).
Copy & paste this snippet into a Python REPL to regenerate:
import math
for x in range(256):
print("{:3},".format(int((math.sin(x/128.0*math.pi)+1.0)*127.5+0.5))),
if x&15 == 15: print
*/
#if !defined(ADAFRUIT_NEOPIXEL_H)
static const uint8_t PROGMEM _NeoPixelSineTable[256] = {
128,131,134,137,140,143,146,149,152,155,158,162,165,167,170,173,
176,179,182,185,188,190,193,196,198,201,203,206,208,211,213,215,
218,220,222,224,226,228,230,232,234,235,237,238,240,241,243,244,
245,246,248,249,250,250,251,252,253,253,254,254,254,255,255,255,
255,255,255,255,254,254,254,253,253,252,251,250,250,249,248,246,
245,244,243,241,240,238,237,235,234,232,230,228,226,224,222,220,
218,215,213,211,208,206,203,201,198,196,193,190,188,185,182,179,
176,173,170,167,165,162,158,155,152,149,146,143,140,137,134,131,
128,124,121,118,115,112,109,106,103,100, 97, 93, 90, 88, 85, 82,
79, 76, 73, 70, 67, 65, 62, 59, 57, 54, 52, 49, 47, 44, 42, 40,
37, 35, 33, 31, 29, 27, 25, 23, 21, 20, 18, 17, 15, 14, 12, 11,
10, 9, 7, 6, 5, 5, 4, 3, 2, 2, 1, 1, 1, 0, 0, 0,
0, 0, 0, 0, 1, 1, 1, 2, 2, 3, 4, 5, 5, 6, 7, 9,
10, 11, 12, 14, 15, 17, 18, 20, 21, 23, 25, 27, 29, 31, 33, 35,
37, 40, 42, 44, 47, 49, 52, 54, 57, 59, 62, 65, 67, 70, 73, 76,
79, 82, 85, 88, 90, 93, 97,100,103,106,109,112,115,118,121,124};
/* Similar to above, but for an 8-bit gamma-correction table.
Copy & paste this snippet into a Python REPL to regenerate:
import math
gamma=2.6
for x in range(256):
print("{:3},".format(int(math.pow((x)/255.0,gamma)*255.0+0.5))),
if x&15 == 15: print
*/
static const uint8_t PROGMEM _NeoPixelGammaTable[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, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3,
3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 5, 6, 6, 6, 6, 7,
7, 7, 8, 8, 8, 9, 9, 9, 10, 10, 10, 11, 11, 11, 12, 12,
13, 13, 13, 14, 14, 15, 15, 16, 16, 17, 17, 18, 18, 19, 19, 20,
20, 21, 21, 22, 22, 23, 24, 24, 25, 25, 26, 27, 27, 28, 29, 29,
30, 31, 31, 32, 33, 34, 34, 35, 36, 37, 38, 38, 39, 40, 41, 42,
42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
58, 59, 60, 61, 62, 63, 64, 65, 66, 68, 69, 70, 71, 72, 73, 75,
76, 77, 78, 80, 81, 82, 84, 85, 86, 88, 89, 90, 92, 93, 94, 96,
97, 99,100,102,103,105,106,108,109,111,112,114,115,117,119,120,
122,124,125,127,129,130,132,134,136,137,139,141,143,145,146,148,
150,152,154,156,158,160,162,164,166,168,170,172,174,176,178,180,
182,184,186,188,191,193,195,197,199,202,204,206,209,211,213,215,
218,220,223,225,227,230,232,235,237,240,242,245,247,250,252,255};
#endif
/*!
@brief Class that stores state and functions for interacting with
Adafruit NeoPixels and compatible devices.
*/
class Adafruit_CPlay_NeoPixel {
public:
// Constructor: number of LEDs, pin number, LED type
Adafruit_CPlay_NeoPixel(uint16_t n, uint16_t pin=6,
neoPixelType type=NEO_GRB + NEO_KHZ800);
Adafruit_CPlay_NeoPixel(void);
~Adafruit_CPlay_NeoPixel();
void begin(void);
void show(void);
void setPin(uint16_t p);
void setPixelColor(uint16_t n, uint8_t r, uint8_t g, uint8_t b);
void setPixelColor(uint16_t n, uint8_t r, uint8_t g, uint8_t b,
uint8_t w);
void setPixelColor(uint16_t n, uint32_t c);
void fill(uint32_t c=0, uint16_t first=0, uint16_t count=0);
void setBrightness(uint8_t);
void clear(void);
void updateLength(uint16_t n);
void updateType(neoPixelType t);
/*!
@brief Check whether a call to show() will start sending data
immediately or will 'block' for a required interval. NeoPixels
require a short quiet time (about 300 microseconds) after the
last bit is received before the data 'latches' and new data can
start being received. Usually one's sketch is implicitly using
this time to generate a new frame of animation...but if it
finishes very quickly, this function could be used to see if
there's some idle time available for some low-priority
concurrent task.
@return 1 or true if show() will start sending immediately, 0 or false
if show() would block (meaning some idle time is available).
*/
boolean canShow(void) const { return (micros()-endTime) >= 300L; }
/*!
@brief Get a pointer directly to the NeoPixel data buffer in RAM.
Pixel data is stored in a device-native format (a la the NEO_*
constants) and is not translated here. Applications that access
this buffer will need to be aware of the specific data format
and handle colors appropriately.
@return Pointer to NeoPixel buffer (uint8_t* array).
@note This is for high-performance applications where calling
setPixelColor() on every single pixel would be too slow (e.g.
POV or light-painting projects). There is no bounds checking
on the array, creating tremendous potential for mayhem if one
writes past the ends of the buffer. Great power, great
responsibility and all that.
*/
uint8_t *getPixels(void) const { return pixels; };
uint8_t getBrightness(void) const;
/*!
@brief Retrieve the pin number used for NeoPixel data output.
@return Arduino pin number (-1 if not set).
*/
int16_t getPin(void) const { return pin; };
/*!
@brief Return the number of pixels in an Adafruit_NeoPixel strip object.
@return Pixel count (0 if not set).
*/
uint16_t numPixels(void) const { return numLEDs; }
uint32_t getPixelColor(uint16_t n) const;
/*!
@brief An 8-bit integer sine wave function, not directly compatible
with standard trigonometric units like radians or degrees.
@param x Input angle, 0-255; 256 would loop back to zero, completing
the circle (equivalent to 360 degrees or 2 pi radians).
One can therefore use an unsigned 8-bit variable and simply
add or subtract, allowing it to overflow/underflow and it
still does the expected contiguous thing.
@return Sine result, 0 to 255, or -128 to +127 if type-converted to
a signed int8_t, but you'll most likely want unsigned as this
output is often used for pixel brightness in animation effects.
*/
static uint8_t sine8(uint8_t x) {
return pgm_read_byte(&_NeoPixelSineTable[x]); // 0-255 in, 0-255 out
}
/*!
@brief An 8-bit gamma-correction function for basic pixel brightness
adjustment. Makes color transitions appear more perceptially
correct.
@param x Input brightness, 0 (minimum or off/black) to 255 (maximum).
@return Gamma-adjusted brightness, can then be passed to one of the
setPixelColor() functions. This uses a fixed gamma correction
exponent of 2.6, which seems reasonably okay for average
NeoPixels in average tasks. If you need finer control you'll
need to provide your own gamma-correction function instead.
*/
static uint8_t gamma8(uint8_t x) {
return pgm_read_byte(&_NeoPixelGammaTable[x]); // 0-255 in, 0-255 out
}
/*!
@brief Convert separate red, green and blue values into a single
"packed" 32-bit RGB color.
@param r Red brightness, 0 to 255.
@param g Green brightness, 0 to 255.
@param b Blue brightness, 0 to 255.
@return 32-bit packed RGB value, which can then be assigned to a
variable for later use or passed to the setPixelColor()
function. Packed RGB format is predictable, regardless of
LED strand color order.
*/
static uint32_t Color(uint8_t r, uint8_t g, uint8_t b) {
return ((uint32_t)r << 16) | ((uint32_t)g << 8) | b;
}
/*!
@brief Convert separate red, green, blue and white values into a
single "packed" 32-bit WRGB color.
@param r Red brightness, 0 to 255.
@param g Green brightness, 0 to 255.
@param b Blue brightness, 0 to 255.
@param w White brightness, 0 to 255.
@return 32-bit packed WRGB value, which can then be assigned to a
variable for later use or passed to the setPixelColor()
function. Packed WRGB format is predictable, regardless of
LED strand color order.
*/
static uint32_t Color(uint8_t r, uint8_t g, uint8_t b, uint8_t w) {
return ((uint32_t)w << 24) | ((uint32_t)r << 16) | ((uint32_t)g << 8) | b;
}
static uint32_t ColorHSV(uint16_t hue, uint8_t sat=255, uint8_t val=255);
/*!
@brief A gamma-correction function for 32-bit packed RGB or WRGB
colors. Makes color transitions appear more perceptially
correct.
@param x 32-bit packed RGB or WRGB color.
@return Gamma-adjusted packed color, can then be passed in one of the
setPixelColor() functions. Like gamma8(), this uses a fixed
gamma correction exponent of 2.6, which seems reasonably okay
for average NeoPixels in average tasks. If you need finer
control you'll need to provide your own gamma-correction
function instead.
*/
static uint32_t gamma32(uint32_t x);
protected:
#ifdef NEO_KHZ400 // If 400 KHz NeoPixel support enabled...
boolean is800KHz; ///< true if 800 KHz pixels
#endif
boolean begun; ///< true if begin() previously called
uint16_t numLEDs; ///< Number of RGB LEDs in strip
uint16_t numBytes; ///< Size of 'pixels' buffer below
int16_t pin; ///< Output pin number (-1 if not yet set)
uint8_t brightness; ///< Strip brightness 0-255 (stored as +1)
uint8_t *pixels; ///< Holds LED color values (3 or 4 bytes each)
uint8_t rOffset; ///< Red index within each 3- or 4-byte pixel
uint8_t gOffset; ///< Index of green byte
uint8_t bOffset; ///< Index of blue byte
uint8_t wOffset; ///< Index of white (==rOffset if no white)
uint32_t endTime; ///< Latch timing reference
#ifdef __AVR__
volatile uint8_t *port; ///< Output PORT register
uint8_t pinMask; ///< Output PORT bitmask
#endif
#ifdef ARDUINO_ARCH_STM32
GPIO_TypeDef *gpioPort; ///< Output GPIO PORT
uint32_t gpioPin; ///< Output GPIO PIN
#endif
};
#endif // ADAFRUIT_NEOPIXEL_H

178
arduino-cli/libraries/Adafruit_Circuit_Playground/utility/Adafruit_CPlay_Sensor.h Normal file
View File

@@ -0,0 +1,178 @@
/*
* Copyright (C) 2008 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software< /span>
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/* Update by K. Townsend (Adafruit Industries) for lighter typedefs, and
* extended sensor support to include color, voltage and current */
#ifndef _ADAFRUIT_SENSOR_H
#define _ADAFRUIT_SENSOR_H
#if ARDUINO >= 100
#include "Arduino.h"
#include "Print.h"
#else
#include "WProgram.h"
#endif
/* Intentionally modeled after sensors.h in the Android API:
* https://github.com/android/platform_hardware_libhardware/blob/master/include/hardware/sensors.h */
/* Constants */
#define SENSORS_GRAVITY_EARTH (9.80665F) ///< Earth's gravity in m/s^2 */
#define SENSORS_GRAVITY_MOON (1.6F) ///< The moon's gravity in m/s^2 */
#define SENSORS_GRAVITY_SUN (275.0F) ///< The sun's gravity in m/s^2 */
#define SENSORS_GRAVITY_STANDARD (SENSORS_GRAVITY_EARTH)
#define SENSORS_MAGFIELD_EARTH_MAX (60.0F) ///< Maximum magnetic field on Earth's surface */
#define SENSORS_MAGFIELD_EARTH_MIN (30.0F) ///< Minimum magnetic field on Earth's surface */
#define SENSORS_PRESSURE_SEALEVELHPA (1013.25F) ///< Average sea level pressure is 1013.25 hPa */
#define SENSORS_DPS_TO_RADS (0.017453293F) ///< Degrees/s to rad/s multiplier */
#define SENSORS_GAUSS_TO_MICROTESLA (100) ///< Gauss to micro-Tesla multiplier */
/** Sensor types */
typedef enum
{
SENSOR_TYPE_ACCELEROMETER = (1), ///< Gravity + linear acceleration */
SENSOR_TYPE_MAGNETIC_FIELD = (2),
SENSOR_TYPE_ORIENTATION = (3),
SENSOR_TYPE_GYROSCOPE = (4),
SENSOR_TYPE_LIGHT = (5),
SENSOR_TYPE_PRESSURE = (6),
SENSOR_TYPE_PROXIMITY = (8),
SENSOR_TYPE_GRAVITY = (9),
SENSOR_TYPE_LINEAR_ACCELERATION = (10), ///< Acceleration not including gravity */
SENSOR_TYPE_ROTATION_VECTOR = (11),
SENSOR_TYPE_RELATIVE_HUMIDITY = (12),
SENSOR_TYPE_AMBIENT_TEMPERATURE = (13),
SENSOR_TYPE_OBJECT_TEMPERATURE = (14),
SENSOR_TYPE_VOLTAGE = (15),
SENSOR_TYPE_CURRENT = (16),
SENSOR_TYPE_COLOR = (17)
} sensors_type_t;
/** struct sensors_vec_s is used to return a vector in a common format. */
typedef struct {
union {
float v[3]; ///< array to store xyz G data
struct {
float x; ///< x-axis G data
float y; ///< y-axis G data
float z; ///< z-axis G data
}; ///< axis data
struct {
float roll; ///< Rotation around the longitudinal axis (the plane body, 'X axis'). Roll is positive and increasing when moving downward. -90°<=roll<=90° */
float pitch; ///< Rotation around the lateral axis (the wing span, 'Y axis'). Pitch is positive and increasing when moving upwards. -180°<=pitch<=180°) */
float heading; ///< Angle between the longitudinal axis (the plane body) and magnetic north, measured clockwise when viewing from the top of the device. 0-359° */
}; ///< Orientation sensors */
}; ///< union of orientation data
int8_t status; ///< sensor status
uint8_t reserved[3]; ///< reserved
} sensors_vec_t;
/** struct sensors_color_s is used to return color data in a common format. */
typedef struct {
union {
float c[3]; ///< array to hold floating point RGB color
struct {
float r; ///< Red component */
float g; ///< Green component */
float b; ///< Blue component */
}; ///< RGB color space
}; ///< union of RGB color space data
uint32_t rgba; ///< 24-bit RGBA value */
} sensors_color_t;
/* Sensor event (36 bytes) */
/** struct sensor_event_s is used to provide a single sensor event in a common format. */
typedef struct
{
int32_t version; ///< must be sizeof(struct sensors_event_t) */
int32_t sensor_id; ///< unique sensor identifier */
int32_t type; ///< sensor type */
int32_t reserved0; ///< reserved */
int32_t timestamp; ///< time is in milliseconds */
union
{
float data[4]; ///< array for floating point general data
sensors_vec_t acceleration; ///< acceleration values are in meter per second per second (m/s^2) */
sensors_vec_t magnetic; ///< magnetic vector values are in micro-Tesla (uT) */
sensors_vec_t orientation; ///< orientation values are in degrees */
sensors_vec_t gyro; ///< gyroscope values are in rad/s */
float temperature; ///< temperature is in degrees centigrade (Celsius) */
float distance; ///< distance in centimeters */
float light; ///< light in SI lux units */
float pressure; ///< pressure in hectopascal (hPa) */
float relative_humidity; ///< relative humidity in percent */
float current; ///< current in milliamps (mA) */
float voltage; ///< voltage in volts (V) */
sensors_color_t color; ///< color in RGB component values */
}; ///< union of sensor event data
} sensors_event_t;
/* Sensor details (40 bytes) */
/** struct sensor_s is used to describe basic information about a specific sensor. */
typedef struct
{
char name[12]; ///< sensor name */
int32_t version; ///< version of the hardware + driver */
int32_t sensor_id; ///< unique sensor identifier */
int32_t type; ///< this sensor's type (ex. SENSOR_TYPE_LIGHT) */
float max_value; ///< maximum value of this sensor's value in SI units */
float min_value; ///< minimum value of this sensor's value in SI units */
float resolution; ///< smallest difference between two values reported by this sensor */
int32_t min_delay; ///< min delay in microseconds between events. zero = not a constant rate */
} sensor_t;
/**************************************************************************/
/*!
@brief Sensor API class for CircuitPlayground board
*/
/**************************************************************************/
class Adafruit_Sensor {
public:
// Constructor(s)
Adafruit_Sensor() {}
virtual ~Adafruit_Sensor() {}
// These must be defined by the subclass
/**************************************************************************/
/*!
@brief enable or disable auto-ranging for the sensor
@param enabled pass true to enable auto-ranging, false to disable
*/
/**************************************************************************/
virtual void enableAutoRange(bool enabled) {};
/**************************************************************************/
/*!
@brief enable auto-ranging for the sensor
@return true on success, false on failure
*/
/**************************************************************************/
virtual bool getEvent(sensors_event_t*) = 0;
/**************************************************************************/
/*!
@brief get information on the sensor
*/
/**************************************************************************/
virtual void getSensor(sensor_t*) = 0;
private:
bool _autoRange; ///< state of auto-ranging for this sensor. True if enabled, false if disabled
};
#endif

177
arduino-cli/libraries/Adafruit_Circuit_Playground/utility/Adafruit_CPlay_Speaker.cpp Normal file
View File

@@ -0,0 +1,177 @@
// Adafruit Circuit Playground speaker library
// by Phil Burgess / Paint Your Dragon.
#include <Arduino.h>
#include "Adafruit_CPlay_Speaker.h"
/**************************************************************************/
/*!
@brief Sets up Circuit Playground speaker for PWM audio output: enables 48 KHz
high-speed PWM mode, configures Timer/Counter 4, sets PWM duty cycle to
50% (speaker idle position).
*/
/**************************************************************************/
void Adafruit_CPlay_Speaker::begin(void) {
if(!started) {
#ifdef __AVR__
// Set up Timer4 for fast PWM on !OC4A
PLLFRQ = (PLLFRQ & 0xCF) | 0x30; // Route PLL to async clk
TCCR4A = _BV(COM4A0) | _BV(PWM4A); // Clear on match, PWMA on
TCCR4B = _BV(PWM4X) | _BV(CS40); // PWM invert, 1:1 prescale
TCCR4D = 0; // Fast PWM mode
TCCR4E = 0; // Not enhanced mode
DT4 = 0; // No dead time
noInterrupts(); // TC4H accesses must be atomic
TC4H = 0; // Not 10-bit mode
OCR4C = 255; // TOP
TC4H = 0;
OCR4A = 127; // 50% duty (idle position) to start
interrupts();
pinMode(5, OUTPUT); // Enable output
#else
pinMode(CPLAY_SPEAKER_SHUTDOWN, OUTPUT);
digitalWrite(CPLAY_SPEAKER_SHUTDOWN, HIGH);
// PWM/timer not needed on CPlay Express, has true analog out.
// Set analogWrite resolution to 8 bits to match AVR calls.
analogWriteResolution(8);
pinMode(A0, OUTPUT); // Enable output
#endif
started = true;
}
}
/**************************************************************************/
/*!
@brief enable or disable the speaker. This function only works on 'Express' boards.
@param e pass true to enable, false to disable
*/
/**************************************************************************/
void Adafruit_CPlay_Speaker::enable(bool e) {
#if !defined(__AVR__) // circuit playground express has nicer amp w/shutdown
digitalWrite(CPLAY_SPEAKER_SHUTDOWN, e);
#endif
}
/**************************************************************************/
/*!
@brief Turns off PWM output to the speaker.
*/
/**************************************************************************/
void Adafruit_CPlay_Speaker::end(void) {
if(started) {
#ifdef __AVR__
TCCR4A = 0; // PWMA off
pinMode(5, INPUT);
#else
pinMode(A0, INPUT);
enable(false);
#endif
started = false;
}
}
/**************************************************************************/
/*!
@brief Sets speaker position, enables PWM output if needed.
@param value the value to set (0-255; 127=idle)
*/
/**************************************************************************/
void Adafruit_CPlay_Speaker::set(uint8_t value) {
if(!started) begin();
#ifdef __AVR__
OCR4A = value;
#else
analogWrite(A0, value);
#endif
}
/**************************************************************************/
/*!
@brief Plays digitized 8-bit audio (optionally 10 bits on Express board) from
a PROGMEM (flash memory) buffer. Maybe 1-3 seconds tops depending on
sampling rate (e.g. 8000 Hz = 8 Kbytes/second). Max ~20K space avail on
Circuit Playground, lots more on Circuit Playground Express.
This function currently "blocks" -- it will not play sounds in the
background while other code runs.
@param data pointer to the audio data to play
@param len the length of the data in samples
@param sampleRate the sample rate of the data in samples per second
@param tenBit Optional flag if true 10-bit mode is enabled. AVR ONLY
*/
/**************************************************************************/
void Adafruit_CPlay_Speaker::playSound(
const uint8_t *data, uint32_t len, uint16_t sampleRate, bool tenBit) {
uint32_t i;
if(!started) begin();
#ifdef __AVR__
uint16_t interval = 1000000L / sampleRate;
#else
uint32_t r2 = sampleRate / 2;
uint32_t startTime = micros();
#endif
if(tenBit) { // 10-bit audio samples?
uint8_t loIdx = 4;
#ifdef __AVR__
// Because it uses 8-bit PWM for output, the AVR code must filter
// 10-bit data down to 8 bits. This is ONLY here for compatibility
// with sketches with 10-bit samples. If targeting a project for AVR,
// it's best to produce and use optimized 8-bit audio, else it's just
// wasted space! Timer/Counter 4 DOES offer a 10-bit mode, but it's
// not used in this library, just not worth it in the limited flash
// space of the 32U4 chip.
uint16_t idx = 0;
uint8_t hiBits;
for(i=0; i<len; i++) {
if(++loIdx >= 4) {
hiBits = pgm_read_byte(&data[idx++]);
loIdx = 0;
}
OCR4A = ((hiBits & 0xC0) | (pgm_read_byte(&data[idx++]) >> 2));
hiBits <<= 2; // Do this after write, because of masking op above
delayMicroseconds(interval);
}
OCR4A = 127;
#else
uint32_t idx = 0;
uint16_t hiBits;
#if defined(NRF52_SERIES)
analogWriteResolution(8);
#else
// Circuit Playground Express -- use 10-bit analogWrite()
analogWriteResolution(10);
#endif
for(i=0; i<len; i++) {
if(++loIdx >= 4) {
hiBits = (uint16_t)pgm_read_byte(&data[idx++]);
loIdx = 0;
}
hiBits <<= 2; // Do this before write, because of masking op below
analogWrite(A0, (hiBits & 0x300) | pgm_read_byte(&data[idx++]));
while(((micros()-startTime+50)/100) < ((i*10000UL+r2)/sampleRate));
}
analogWriteResolution(8); // Return to 8 bits for set() compatibility
analogWrite(A0, 127);
#endif
} else { // 8-bit audio samples
#ifdef __AVR__
for(i=0; i<len; i++) {
OCR4A = pgm_read_byte(&data[i]);
delayMicroseconds(interval);
}
OCR4A = 127;
#else
for(i=0; i<len; i++) {
analogWrite(A0, pgm_read_byte(&data[i]));
while(((micros()-startTime+50)/100) < ((i*10000UL+r2)/sampleRate));
}
analogWrite(A0, 127);
#endif
}
}

50
arduino-cli/libraries/Adafruit_Circuit_Playground/utility/Adafruit_CPlay_Speaker.h Normal file
View File

@@ -0,0 +1,50 @@
// Adafruit Circuit Playground speaker library
// by Phil Burgess / Paint Your Dragon.
#ifndef ADAFRUIT_CPLAY_SPEAKER_H
#define ADAFRUIT_CPLAY_SPEAKER_H
#include <Arduino.h>
#if !defined(__AVR__) // circuit playground express has nicer amp w/shutdown
#define CPLAY_SPEAKER_SHUTDOWN 11 ///< shutdown pin (Express boards only)
#endif
/**************************************************************************/
/*!
@brief Class that stores state and functions for the speaker on CircuitPlayground boards
*/
/**************************************************************************/
class Adafruit_CPlay_Speaker {
public:
Adafruit_CPlay_Speaker(void) { started = false; };
void begin(void),
end(void),
set(uint8_t value),
playSound(const uint8_t *data, uint32_t length, uint16_t sampleRate,
bool tenBit=false),
say(const uint8_t *addr);
void enable(bool e);
/**************************************************************************/
/*!
@brief disable the speaker.
@note this function only has an effect on 'Express' boards
*/
/**************************************************************************/
void off(void) { enable(false); };
/**************************************************************************/
/*!
@brief enable the speaker.
@note this function only has an effect on 'Express' boards
*/
/**************************************************************************/
void on(void) { enable(true); };
private:
bool started;
};
#endif // ADAFRUIT_CPLAY_SPEAKER_H

381
arduino-cli/libraries/Adafruit_Circuit_Playground/utility/Adafruit_ZeroPDM.cpp Normal file
View File

@@ -0,0 +1,381 @@
// Adafruit Arduino Zero / Feather M0 I2S audio library.
// Author: Tony DiCola & Limor "ladyada" Fried
//
// The MIT License (MIT)
//
// Copyright (c) 2016 Adafruit Industries
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.
#include "Adafruit_ZeroPDM.h"
#if defined(ARDUINO_ARCH_SAMD)
// Define macros for debug output that optimize out when debug mode is disabled.
#ifdef DEBUG
#define DEBUG_PRINT(...) DEBUG_PRINTER.print(__VA_ARGS__)
#define DEBUG_PRINTLN(...) DEBUG_PRINTER.println(__VA_ARGS__)
#else
#define DEBUG_PRINT(...)
#define DEBUG_PRINTLN(...)
#endif
Adafruit_ZeroPDM::Adafruit_ZeroPDM(int clockpin, int datapin, uint8_t gclk):
_gclk(gclk), _clk(clockpin), _data(datapin) {
}
bool Adafruit_ZeroPDM::begin(void) {
// check the pins are valid!
_clk_pin = _clk_mux = _data_pin = _data_mux = 0;
// Clock pin, can only be one of 3 options
uint32_t clockport = g_APinDescription[_clk].ulPort;
uint32_t clockpin = g_APinDescription[_clk].ulPin;
if ((clockport == 0) && (clockpin == 10)) {
// PA10
_i2sclock = I2S_CLOCK_UNIT_0;
_clk_pin = PIN_PA10G_I2S_SCK0;
_clk_mux = MUX_PA10G_I2S_SCK0;
} else if ((clockport == 1) && (clockpin == 10)) {
// PB11
_i2sclock = I2S_CLOCK_UNIT_1;
_clk_pin = PIN_PB11G_I2S_SCK1;
_clk_mux = MUX_PB11G_I2S_SCK1;
} else if ((clockport == 0) && (clockpin == 20)) {
// PA20
_i2sclock = I2S_CLOCK_UNIT_0;
_clk_pin = PIN_PA20G_I2S_SCK0;
_clk_mux = MUX_PA20G_I2S_SCK0;
} else {
DEBUG_PRINTLN("Clock isnt on a valid pin");
return false;
}
// Data pin, can only be one of 3 options
uint32_t datapin = g_APinDescription[_data].ulPin;
uint32_t dataport = g_APinDescription[_data].ulPort;
if ((dataport == 0) && (datapin == 7)) {
// PA07
_i2sserializer = I2S_SERIALIZER_0;
_data_pin = PIN_PA07G_I2S_SD0;
_data_mux = MUX_PA07G_I2S_SD0;
} else if ((dataport == 0) && (datapin == 8)) {
// PA08
_i2sserializer = I2S_SERIALIZER_1;
_data_pin = PIN_PA08G_I2S_SD1;
_data_mux = MUX_PA08G_I2S_SD1;
} else if ((dataport == 0) && (datapin == 19)) {
// PA19
_i2sserializer = I2S_SERIALIZER_0;
_data_pin = PIN_PA19G_I2S_SD0;
_data_mux = MUX_PA19G_I2S_SD0;
} else {
DEBUG_PRINTLN("Data isnt on a valid pin");
return false;
}
// Initialize I2S module from the ASF.
// replace "status_code res = i2s_init(&_i2s_instance, I2S);
// if (res != STATUS_OK) {
// DEBUG_PRINT("i2s_init failed with result: "); DEBUG_PRINTLN(res);
// return false;
// }" with:
/* Enable the user interface clock in the PM */
//system_apb_clock_set_mask(SYSTEM_CLOCK_APB_APBC, PM_APBCMASK_I2S);
PM->APBCMASK.reg |= PM_APBCMASK_I2S;
/* Status check */
uint32_t ctrla = I2S->CTRLA.reg;
if (ctrla & I2S_CTRLA_ENABLE) {
if (ctrla & (I2S_CTRLA_SEREN1 |
I2S_CTRLA_SEREN0 | I2S_CTRLA_CKEN1 | I2S_CTRLA_CKEN0)) {
//return STATUS_BUSY;
return false;
} else {
//return STATUS_ERR_DENIED;
return false;
}
}
/* Initialize module */
_hw = I2S;
return true;
}
void Adafruit_ZeroPDM::end(void) {
while (_hw->SYNCBUSY.reg & I2S_SYNCBUSY_ENABLE); // Sync wait
_hw->CTRLA.reg &= ~I2S_SYNCBUSY_ENABLE;
}
bool Adafruit_ZeroPDM::configure(uint32_t sampleRateHz, boolean stereo) {
// Convert bit per sample int into explicit ASF values.
// Disable I2S while it is being reconfigured to prevent unexpected output.
end();
/******************************* Set the GCLK generator config and enable it. *************/
{
/* Cache new register configurations to minimize sync requirements. */
uint32_t new_genctrl_config = (_gclk << GCLK_GENCTRL_ID_Pos);
uint32_t new_gendiv_config = (_gclk << GCLK_GENDIV_ID_Pos);
/* Select the requested source clock for the generator */
// Set the clock generator to use the 48mhz main CPU clock and divide it down
// to the SCK frequency.
new_genctrl_config |= GCLK_SOURCE_DFLL48M << GCLK_GENCTRL_SRC_Pos;
uint32_t division_factor = F_CPU / (sampleRateHz*16); // 16 clocks for 16 stereo bits
/* Set division factor */
if (division_factor > 1) {
/* Check if division is a power of two */
if (((division_factor & (division_factor - 1)) == 0)) {
/* Determine the index of the highest bit set to get the
* division factor that must be loaded into the division
* register */
uint32_t div2_count = 0;
uint32_t mask;
for (mask = (1UL << 1); mask < division_factor;
mask <<= 1) {
div2_count++;
}
/* Set binary divider power of 2 division factor */
new_gendiv_config |= div2_count << GCLK_GENDIV_DIV_Pos;
new_genctrl_config |= GCLK_GENCTRL_DIVSEL;
} else {
/* Set integer division factor */
new_gendiv_config |=
(division_factor) << GCLK_GENDIV_DIV_Pos;
/* Enable non-binary division with increased duty cycle accuracy */
new_genctrl_config |= GCLK_GENCTRL_IDC;
}
}
noInterrupts(); // cpu_irq_enter_critical();
while (GCLK->STATUS.reg & GCLK_STATUS_SYNCBUSY); // Wait for synchronization
*((uint8_t*)&GCLK->GENDIV.reg) = _gclk; /* Select the correct generator */
while (GCLK->STATUS.reg & GCLK_STATUS_SYNCBUSY); // Wait for synchronization
GCLK->GENDIV.reg = new_gendiv_config; /* Write the new generator configuration */
while (GCLK->STATUS.reg & GCLK_STATUS_SYNCBUSY); // Wait for synchronization
GCLK->GENCTRL.reg = new_genctrl_config | (GCLK->GENCTRL.reg & GCLK_GENCTRL_GENEN);
// Replace "system_gclk_gen_enable(_gclk);" with:
while (GCLK->STATUS.reg & GCLK_STATUS_SYNCBUSY); // Wait for synchronization
*((uint8_t*)&GCLK->GENCTRL.reg) = _gclk; /* Select the requested generator */
while (GCLK->STATUS.reg & GCLK_STATUS_SYNCBUSY); // Wait for synchronization
GCLK->GENCTRL.reg |= GCLK_GENCTRL_GENEN; /* Enable generator */
interrupts(); // cpu_irq_leave_critical();
}
/******************************* Configure I2S clock *************/
{
/* Status check */
/* Busy ? */
if (_hw->SYNCBUSY.reg & (I2S_SYNCBUSY_CKEN0 << _i2sclock)) {
return false; //return STATUS_BUSY;
}
/* Already enabled ? */
if (_hw->CTRLA.reg & (I2S_CTRLA_CKEN0 << _i2sclock)) {
return false; //return STATUS_ERR_DENIED;
}
/***************************** Initialize Clock Unit *************/
uint32_t clkctrl =
// I2S_CLKCTRL_MCKOUTINV | // mck out not inverted
// I2S_CLKCTRL_SCKOUTINV | // sck out not inverted
// I2S_CLKCTRL_FSOUTINV | // fs not inverted
// I2S_CLKCTRL_MCKEN | // Disable MCK output
// I2S_CLKCTRL_MCKSEL | // Disable MCK output
// I2S_CLKCTRL_SCKSEL | // SCK source is GCLK
// I2S_CLKCTRL_FSINV | // do not invert frame sync
// I2S_CLKCTRL_FSSEL | // Configure FS generation from SCK clock.
// I2S_CLKCTRL_BITDELAY | // No bit delay (PDM)
0;
clkctrl |= I2S_CLKCTRL_MCKOUTDIV(0);
clkctrl |= I2S_CLKCTRL_MCKDIV(0);
clkctrl |= I2S_CLKCTRL_NBSLOTS(1); // STEREO is '1' (subtract one from #)
clkctrl |= I2S_CLKCTRL_FSWIDTH(I2S_FRAME_SYNC_WIDTH_SLOT); // Frame Sync (FS) Pulse is 1 Slot width
if (stereo) {
clkctrl |= I2S_CLKCTRL_SLOTSIZE(I2S_SLOT_SIZE_16_BIT);
} else {
clkctrl |= I2S_CLKCTRL_SLOTSIZE(I2S_SLOT_SIZE_32_BIT);
}
/* Write clock unit configurations */
_hw->CLKCTRL[_i2sclock].reg = clkctrl;
/* Select general clock source */
const uint8_t i2s_gclk_ids[2] = {I2S_GCLK_ID_0, I2S_GCLK_ID_1};
/* Cache the new config to reduce sync requirements */
uint32_t new_clkctrl_config = (i2s_gclk_ids[_i2sclock] << GCLK_CLKCTRL_ID_Pos);
/* Select the desired generic clock generator */
new_clkctrl_config |= _gclk << GCLK_CLKCTRL_GEN_Pos;
/* Disable generic clock channel */
noInterrupts();
/* Select the requested generator channel */
*((uint8_t*)&GCLK->CLKCTRL.reg) = i2s_gclk_ids[_i2sclock];
/* Switch to known-working source so that the channel can be disabled */
uint32_t prev_gen_id = GCLK->CLKCTRL.bit.GEN;
GCLK->CLKCTRL.bit.GEN = 0;
/* Disable the generic clock */
GCLK->CLKCTRL.reg &= ~GCLK_CLKCTRL_CLKEN;
while (GCLK->CLKCTRL.reg & GCLK_CLKCTRL_CLKEN); /* Wait for clock to become disabled */
/* Restore previous configured clock generator */
GCLK->CLKCTRL.bit.GEN = prev_gen_id;
/* Write the new configuration */
GCLK->CLKCTRL.reg = new_clkctrl_config;
// enable it
*((uint8_t*)&GCLK->CLKCTRL.reg) = i2s_gclk_ids[_i2sclock]; /* Select the requested generator channel */
GCLK->CLKCTRL.reg |= GCLK_CLKCTRL_CLKEN; /* Enable the generic clock */
interrupts();
/* Initialize pins */
pinPeripheral(_clk, (EPioType)_clk_mux);
}
/***************************** Configure I2S serializer *************/
{
/* Status check */
/* Busy ? */
while (_hw->SYNCBUSY.reg & ((I2S_SYNCBUSY_SEREN0 | I2S_SYNCBUSY_DATA0) << _i2sserializer)) {
//return STATUS_BUSY;
return false;
}
/* Already enabled ? */
if (_hw->CTRLA.reg & (I2S_CTRLA_CKEN0 << _i2sserializer)) {
// return STATUS_ERR_DENIED;
return false;
}
/* Initialize Serializer */
uint32_t serctrl =
// I2S_SERCTRL_RXLOOP | // Dont use loopback mode
// I2S_SERCTRL_DMA | // Single DMA channel for all I2S channels
// I2S_SERCTRL_MONO | // Dont use MONO mode
// I2S_SERCTRL_SLOTDIS7 | // Dont have any slot disabling
// I2S_SERCTRL_SLOTDIS6 |
// I2S_SERCTRL_SLOTDIS5 |
// I2S_SERCTRL_SLOTDIS4 |
// I2S_SERCTRL_SLOTDIS3 |
// I2S_SERCTRL_SLOTDIS2 |
// I2S_SERCTRL_SLOTDIS1 |
// I2S_SERCTRL_SLOTDIS0 |
I2S_SERCTRL_BITREV | // Do not transfer LSB first (MSB first!)
// I2S_SERCTRL_WORDADJ | // Data NOT left in word
I2S_SERCTRL_SLOTADJ | // Data is left in slot
// I2S_SERCTRL_TXSAME | // Pad 0 on underrun
0;
// Configure clock unit to use with serializer, and set serializer as an output.
if (_i2sclock < 2) {
serctrl |= (_i2sclock ? I2S_SERCTRL_CLKSEL : 0);
} else {
return false; //return STATUS_ERR_INVALID_ARG;
}
if (stereo) {
serctrl |= I2S_SERCTRL_SERMODE(I2S_SERIALIZER_PDM2); //Serializer is used to receive PDM data on each clock edge
} else {
serctrl |= I2S_SERCTRL_SERMODE(I2S_SERIALIZER_RECEIVE); // act like I2S
}
// Configure serializer data size.
serctrl |= I2S_SERCTRL_DATASIZE(I2S_DATA_SIZE_32BIT); // anything other than 32 bits is ridiculous to manage, force this to be 32
serctrl |= I2S_SERCTRL_TXDEFAULT(I2S_LINE_DEFAULT_0) | /** Output default value is 0 */
I2S_SERCTRL_EXTEND(I2S_DATA_PADDING_0); /** Padding 0 in case of under-run */
/* Write Serializer configuration */
_hw->SERCTRL[_i2sserializer].reg = serctrl;
/* Initialize pins */
// Enable SD pin. See Adafruit_ZeroI2S.h for default pin value.
pinPeripheral(_data, (EPioType)_data_mux);
}
/***************************** Enable everything configured above *************/
// Replace "i2s_enable(&_i2s_instance);" with:
while (_hw->SYNCBUSY.reg & I2S_SYNCBUSY_ENABLE); // Sync wait
_hw->CTRLA.reg |= I2S_SYNCBUSY_ENABLE;
// Replace "i2s_clock_unit_enable(&_i2s_instance, _i2sclock);" with:
uint32_t cken_bit = I2S_CTRLA_CKEN0 << _i2sclock;
while (_hw->SYNCBUSY.reg & cken_bit); // Sync wait
_hw->CTRLA.reg |= cken_bit;
// Replace "i2s_serializer_enable(&_i2s_instance, _i2sserializer);" with:
uint32_t seren_bit = I2S_CTRLA_SEREN0 << _i2sserializer;
while (_hw->SYNCBUSY.reg & seren_bit); // Sync wait
_hw->CTRLA.reg |= seren_bit;
return true;
}
uint32_t Adafruit_ZeroPDM::read(void) {
// Read the sample from the I2S data register.
// This will wait for the I2S hardware to be ready to send the byte.
//return i2s_serializer_read_wait(&_i2s_instance, _i2sserializer);
// replace i2s_serializer_read_wait with deASF'd code:
{
uint32_t sync_bit, ready_bit;
uint32_t data;
ready_bit = I2S_INTFLAG_RXRDY0 << _i2sserializer;
while (!(_hw->INTFLAG.reg & ready_bit)) {
/* Wait until ready to transmit */
}
sync_bit = I2S_SYNCBUSY_DATA0 << _i2sserializer;
while (_hw->SYNCBUSY.reg & sync_bit) {
/* Wait sync */
}
/* Read data */
data = _hw->DATA[_i2sserializer].reg;
_hw->INTFLAG.reg = ready_bit;
return data;
}
}
#endif

307
arduino-cli/libraries/Adafruit_Circuit_Playground/utility/Adafruit_ZeroPDM.h Normal file
View File

@@ -0,0 +1,307 @@
// Adafruit Arduino Zero / Feather M0 PDM mic library.
// Author: Tony DiCola & Limor "Ladyada" Fried
//
// The MIT License (MIT)
//
// Copyright (c) 2016 Adafruit Industries
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.
#ifndef ADAFRUIT_ZEROPDM_H
#define ADAFRUIT_ZEROPDM_H
#include <Arduino.h>
#include "wiring_private.h"
#if defined(ARDUINO_ARCH_SAMD)
// Uncomment to enable debug message output.
#define DEBUG
// Define where debug output is printed (the native USB port on the Zero).
#define DEBUG_PRINTER Serial
class Adafruit_ZeroPDM {
public:
// Create a new instance of an I2S audio transmitter.
// Can specify the pins to use and the generic clock ID to use for driving the I2S
// hardware (default is GCLK 3).
Adafruit_ZeroPDM(int clockpin, int datapin, uint8_t gclk = 3);
// Initialize the I2S audio receiver.
bool begin();
void end();
// Configure the transmitter with the sample rate (in hertz
bool configure(uint32_t sampleRateHz, boolean stereo);
// Read a single sample from the I2S subsystem. Will wait until the I2S
// hardware is ready to receive the sample.
uint32_t read(void);
uint8_t getSerializer(void) { return _i2sserializer; };
bool read(uint32_t *buffer, int bufsiz);
private:
int _clk, _data;
uint32_t _clk_pin, _clk_mux, _data_pin, _data_mux;
uint8_t _i2sserializer;
uint8_t _i2sclock;
uint8_t _gclk;
I2s *_hw;
};
#ifndef I2S_H_INCLUDED
/**
* Master Clock (MCK) source selection
*/
enum i2s_master_clock_source {
/** Master Clock (MCK) is from general clock */
I2S_MASTER_CLOCK_SOURCE_GCLK,
/** Master Clock (MCK) is from MCK input pin */
I2S_MASTER_CLOCK_SOURCE_MCKPIN
};
/**
* Serial Clock (SCK) source selection
*/
enum i2s_serial_clock_source {
/** Serial Clock (SCK) is divided from Master Clock */
I2S_SERIAL_CLOCK_SOURCE_MCKDIV,
/** Serial Clock (SCK) is input from SCK input pin */
I2S_SERIAL_CLOCK_SOURCE_SCKPIN
};
/**
* Data delay from Frame Sync (FS)
*/
enum i2s_data_delay {
/** Left Justified (no delay) */
I2S_DATA_DELAY_0,
/** I2S data delay (1-bit delay) */
I2S_DATA_DELAY_1,
/** Left Justified (no delay) */
I2S_DATA_DELAY_LEFT_JUSTIFIED = I2S_DATA_DELAY_0,
/** I2S data delay (1-bit delay) */
I2S_DATA_DELAY_I2S = I2S_DATA_DELAY_1
};
/**
* Frame Sync (FS) source
*/
enum i2s_frame_sync_source {
/** Frame Sync (FS) is divided from I2S Serial Clock */
I2S_FRAME_SYNC_SOURCE_SCKDIV,
/** Frame Sync (FS) is input from FS input pin */
I2S_FRAME_SYNC_SOURCE_FSPIN
};
/**
* Frame Sync (FS) output pulse width
*/
enum i2s_frame_sync_width {
/** Frame Sync (FS) Pulse is 1 Slot width */
I2S_FRAME_SYNC_WIDTH_SLOT,
/** Frame Sync (FS) Pulse is half a Frame width */
I2S_FRAME_SYNC_WIDTH_HALF_FRAME,
/** Frame Sync (FS) Pulse is 1 Bit width */
I2S_FRAME_SYNC_WIDTH_BIT,
/** 1-bit wide Frame Sync (FS) per Data sample, only used when Data transfer
* is requested */
I2S_FRAME_SYNC_WIDTH_BURST
};
/**
* Time Slot Size in number of I2S serial clocks (bits)
*/
enum i2s_slot_size {
/** 8-bit slot */
I2S_SLOT_SIZE_8_BIT,
/** 16-bit slot */
I2S_SLOT_SIZE_16_BIT,
/** 24-bit slot */
I2S_SLOT_SIZE_24_BIT,
/** 32-bit slot */
I2S_SLOT_SIZE_32_BIT
};
/**
* DMA channels usage for I2S
*/
enum i2s_dma_usage {
/** Single DMA channel for all I2S channels */
I2S_DMA_USE_SINGLE_CHANNEL_FOR_ALL,
/** One DMA channel per data channel */
I2S_DMA_USE_ONE_CHANNEL_PER_DATA_CHANNEL
};
/**
* I2S data format, to extend mono data to 2 channels
*/
enum i2s_data_format {
/** Normal mode, keep data to its right channel */
I2S_DATA_FORMAT_STEREO,
/** Assume input is mono data for left channel, the data is duplicated to
* right channel */
I2S_DATA_FORMAT_MONO
};
/**
* I2S data bit order
*/
enum i2s_bit_order {
/** Transfer Data Most Significant Bit first (Default for I2S protocol) */
I2S_BIT_ORDER_MSB_FIRST,
/** Transfer Data Least Significant Bit first */
I2S_BIT_ORDER_LSB_FIRST
};
/**
* I2S data bit padding
*/
enum i2s_bit_padding {
/** Padding with 0 */
I2S_BIT_PADDING_0,
/** Padding with 1 */
I2S_BIT_PADDING_1,
/** Padding with MSBit */
I2S_BIT_PADDING_MSB,
/** Padding with LSBit */
I2S_BIT_PADDING_LSB,
};
/**
* I2S data word adjust
*/
enum i2s_data_adjust {
/** Data is right adjusted in word */
I2S_DATA_ADJUST_RIGHT,
/** Data is left adjusted in word */
I2S_DATA_ADJUST_LEFT
};
/**
* I2S data word size
*/
enum i2s_data_size {
/** 32-bit */
I2S_DATA_SIZE_32BIT,
/** 24-bit */
I2S_DATA_SIZE_24BIT,
/** 20-bit */
I2S_DATA_SIZE_20BIT,
/** 18-bit */
I2S_DATA_SIZE_18BIT,
/** 16-bit */
I2S_DATA_SIZE_16BIT,
/** 16-bit compact stereo */
I2S_DATA_SIZE_16BIT_COMPACT,
/** 8-bit */
I2S_DATA_SIZE_8BIT,
/** 8-bit compact stereo */
I2S_DATA_SIZE_8BIT_COMPACT
};
/**
* I2S data slot adjust
*/
enum i2s_slot_adjust {
/** Data is right adjusted in slot */
I2S_SLOT_ADJUST_RIGHT,
/** Data is left adjusted in slot */
I2S_SLOT_ADJUST_LEFT
};
/**
* I2S data padding
*/
enum i2s_data_padding {
/** Padding 0 in case of under-run */
I2S_DATA_PADDING_0,
/** Padding last data in case of under-run */
I2S_DATA_PADDING_SAME_AS_LAST,
/** Padding last data in case of under-run
* (abbr. \c I2S_DATA_PADDING_SAME_AS_LAST) */
I2S_DATA_PADDING_LAST = I2S_DATA_PADDING_SAME_AS_LAST,
/** Padding last data in case of under-run
* (abbr. \c I2S_DATA_PADDING_SAME_AS_LAST) */
I2S_DATA_PADDING_SAME = I2S_DATA_PADDING_SAME_AS_LAST
};
/**
* I2S line default value when slot disabled
*/
enum i2s_line_default_state {
/** Output default value is 0 */
I2S_LINE_DEFAULT_0,
/** Output default value is 1 */
I2S_LINE_DEFAULT_1,
/** Output default value is high impedance */
I2S_LINE_DEFAULT_HIGH_IMPEDANCE = 3,
/** Output default value is high impedance
* (abbr. \c I2S_LINE_DEFAULT_HIGH_IMPEDANCE) */
I2S_LINE_DEFAULT_HIZ = I2S_LINE_DEFAULT_HIGH_IMPEDANCE
};
/**
* I2S Serializer mode
*/
enum i2s_serializer_mode {
/** Serializer is used to receive data */
I2S_SERIALIZER_RECEIVE,
/** Serializer is used to transmit data */
I2S_SERIALIZER_TRANSMIT,
/** Serializer is used to receive PDM data on each clock edge */
I2S_SERIALIZER_PDM2
};
/**
* I2S clock unit selection
*/
enum i2s_clock_unit {
/** Clock Unit channel 0 */
I2S_CLOCK_UNIT_0,
/** Clock Unit channel 1 */
I2S_CLOCK_UNIT_1,
/** Number of Clock Unit channels */
I2S_CLOCK_UNIT_N
};
/**
* I2S Serializer selection
*/
enum i2s_serializer {
/** Serializer channel 0 */
I2S_SERIALIZER_0,
/** Serializer channel 1 */
I2S_SERIALIZER_1,
/** Number of Serializer channels */
I2S_SERIALIZER_N
};
#endif
#endif
#endif

843
arduino-cli/libraries/Adafruit_Circuit_Playground/utility/CP_Boards.h Normal file
View File

@@ -0,0 +1,843 @@
/*
Boards.h - Hardware Abstraction Layer for Firmata library
Copyright (c) 2006-2008 Hans-Christoph Steiner. All rights reserved.
Copyright (C) 2009-2016 Jeff Hoefs. All rights reserved.
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.
See file LICENSE.txt for further informations on licensing terms.
Last updated April 10th, 2016
*/
#ifndef Firmata_Boards_h
#define Firmata_Boards_h
#include <inttypes.h>
#if defined(ARDUINO) && ARDUINO >= 100
#include "Arduino.h" // for digitalRead, digitalWrite, etc
#else
#include "WProgram.h"
#endif
// Normally Servo.h must be included before Firmata.h (which then includes
// this file). If Servo.h wasn't included, this allows the code to still
// compile, but without support for any Servos. Hopefully that's what the
// user intended by not including Servo.h
#ifndef MAX_SERVOS
#define MAX_SERVOS 0
#endif
/*
Firmata Hardware Abstraction Layer
Firmata is built on top of the hardware abstraction functions of Arduino,
specifically digitalWrite, digitalRead, analogWrite, analogRead, and
pinMode. While these functions offer simple integer pin numbers, Firmata
needs more information than is provided by Arduino. This file provides
all other hardware specific details. To make Firmata support a new board,
only this file should require editing.
The key concept is every "pin" implemented by Firmata may be mapped to
any pin as implemented by Arduino. Usually a simple 1-to-1 mapping is
best, but such mapping should not be assumed. This hardware abstraction
layer allows Firmata to implement any number of pins which map onto the
Arduino implemented pins in almost any arbitrary way.
General Constants:
These constants provide basic information Firmata requires.
TOTAL_PINS: The total number of pins Firmata implemented by Firmata.
Usually this will match the number of pins the Arduino functions
implement, including any pins pins capable of analog or digital.
However, Firmata may implement any number of pins. For example,
on Arduino Mini with 8 analog inputs, 6 of these may be used
for digital functions, and 2 are analog only. On such boards,
Firmata can implement more pins than Arduino's pinMode()
function, in order to accommodate those special pins. The
Firmata protocol supports a maximum of 128 pins, so this
constant must not exceed 128.
TOTAL_ANALOG_PINS: The total number of analog input pins implemented.
The Firmata protocol allows up to 16 analog inputs, accessed
using offsets 0 to 15. Because Firmata presents the analog
inputs using different offsets than the actual pin numbers
(a legacy of Arduino's analogRead function, and the way the
analog input capable pins are physically labeled on all
Arduino boards), the total number of analog input signals
must be specified. 16 is the maximum.
VERSION_BLINK_PIN: When Firmata starts up, it will blink the version
number. This constant is the Arduino pin number where a
LED is connected.
Pin Mapping Macros:
These macros provide the mapping between pins as implemented by
Firmata protocol and the actual pin numbers used by the Arduino
functions. Even though such mappings are often simple, pin
numbers received by Firmata protocol should always be used as
input to these macros, and the result of the macro should be
used with with any Arduino function.
When Firmata is extended to support a new pin mode or feature,
a pair of macros should be added and used for all hardware
access. For simple 1:1 mapping, these macros add no actual
overhead, yet their consistent use allows source code which
uses them consistently to be easily adapted to all other boards
with different requirements.
IS_PIN_XXXX(pin): The IS_PIN macros resolve to true or non-zero
if a pin as implemented by Firmata corresponds to a pin
that actually implements the named feature.
PIN_TO_XXXX(pin): The PIN_TO macros translate pin numbers as
implemented by Firmata to the pin numbers needed as inputs
to the Arduino functions. The corresponding IS_PIN macro
should always be tested before using a PIN_TO macro, so
these macros only need to handle valid Firmata pin
numbers for the named feature.
Port Access Inline Funtions:
For efficiency, Firmata protocol provides access to digital
input and output pins grouped by 8 bit ports. When these
groups of 8 correspond to actual 8 bit ports as implemented
by the hardware, these inline functions can provide high
speed direct port access. Otherwise, a default implementation
using 8 calls to digitalWrite or digitalRead is used.
When porting Firmata to a new board, it is recommended to
use the default functions first and focus only on the constants
and macros above. When those are working, if optimized port
access is desired, these inline functions may be extended.
The recommended approach defines a symbol indicating which
optimization to use, and then conditional complication is
used within these functions.
readPort(port, bitmask): Read an 8 bit port, returning the value.
port: The port number, Firmata pins port*8 to port*8+7
bitmask: The actual pins to read, indicated by 1 bits.
writePort(port, value, bitmask): Write an 8 bit port.
port: The port number, Firmata pins port*8 to port*8+7
value: The 8 bit value to write
bitmask: The actual pins to write, indicated by 1 bits.
*/
/*==============================================================================
* Board Specific Configuration
*============================================================================*/
#ifndef digitalPinHasPWM
#define digitalPinHasPWM(p) IS_PIN_DIGITAL(p)
#endif
// Arduino Duemilanove, Diecimila, and NG
#if defined(__AVR_ATmega168__) || defined(__AVR_ATmega328P__) || defined(__AVR_ATmega328__)
#if defined(NUM_ANALOG_INPUTS) && NUM_ANALOG_INPUTS == 6
#define TOTAL_ANALOG_PINS 6
#define TOTAL_PINS 20 // 14 digital + 6 analog
#else
#define TOTAL_ANALOG_PINS 8
#define TOTAL_PINS 22 // 14 digital + 8 analog
#endif
#define VERSION_BLINK_PIN 13
#define IS_PIN_DIGITAL(p) ((p) >= 2 && (p) <= 19)
#define IS_PIN_ANALOG(p) ((p) >= 14 && (p) < 14 + TOTAL_ANALOG_PINS)
#define IS_PIN_PWM(p) digitalPinHasPWM(p)
#define IS_PIN_SERVO(p) (IS_PIN_DIGITAL(p) && (p) - 2 < MAX_SERVOS)
#define IS_PIN_I2C(p) ((p) == 18 || (p) == 19)
#define IS_PIN_SPI(p) ((p) == SS || (p) == MOSI || (p) == MISO || (p) == SCK)
#define PIN_TO_DIGITAL(p) (p)
#define PIN_TO_ANALOG(p) ((p) - 14)
#define PIN_TO_PWM(p) PIN_TO_DIGITAL(p)
#define PIN_TO_SERVO(p) ((p) - 2)
#define ARDUINO_PINOUT_OPTIMIZE 1
// Wiring (and board)
#elif defined(WIRING)
#define VERSION_BLINK_PIN WLED
#define IS_PIN_DIGITAL(p) ((p) >= 0 && (p) < TOTAL_PINS)
#define IS_PIN_ANALOG(p) ((p) >= FIRST_ANALOG_PIN && (p) < (FIRST_ANALOG_PIN+TOTAL_ANALOG_PINS))
#define IS_PIN_PWM(p) digitalPinHasPWM(p)
#define IS_PIN_SERVO(p) ((p) >= 0 && (p) < MAX_SERVOS)
#define IS_PIN_I2C(p) ((p) == SDA || (p) == SCL)
#define IS_PIN_SPI(p) ((p) == SS || (p) == MOSI || (p) == MISO || (p) == SCK)
#define PIN_TO_DIGITAL(p) (p)
#define PIN_TO_ANALOG(p) ((p) - FIRST_ANALOG_PIN)
#define PIN_TO_PWM(p) PIN_TO_DIGITAL(p)
#define PIN_TO_SERVO(p) (p)
// old Arduinos
#elif defined(__AVR_ATmega8__)
#define TOTAL_ANALOG_PINS 6
#define TOTAL_PINS 20 // 14 digital + 6 analog
#define VERSION_BLINK_PIN 13
#define IS_PIN_DIGITAL(p) ((p) >= 2 && (p) <= 19)
#define IS_PIN_ANALOG(p) ((p) >= 14 && (p) <= 19)
#define IS_PIN_PWM(p) digitalPinHasPWM(p)
#define IS_PIN_SERVO(p) (IS_PIN_DIGITAL(p) && (p) - 2 < MAX_SERVOS)
#define IS_PIN_I2C(p) ((p) == 18 || (p) == 19)
#define PIN_TO_DIGITAL(p) (p)
#define PIN_TO_ANALOG(p) ((p) - 14)
#define PIN_TO_PWM(p) PIN_TO_DIGITAL(p)
#define PIN_TO_SERVO(p) ((p) - 2)
#define ARDUINO_PINOUT_OPTIMIZE 1
// Arduino Mega
#elif defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)
#define TOTAL_ANALOG_PINS 16
#define TOTAL_PINS 70 // 54 digital + 16 analog
#define VERSION_BLINK_PIN 13
#define PIN_SERIAL1_RX 19
#define PIN_SERIAL1_TX 18
#define PIN_SERIAL2_RX 17
#define PIN_SERIAL2_TX 16
#define PIN_SERIAL3_RX 15
#define PIN_SERIAL3_TX 14
#define IS_PIN_DIGITAL(p) ((p) >= 2 && (p) < TOTAL_PINS)
#define IS_PIN_ANALOG(p) ((p) >= 54 && (p) < TOTAL_PINS)
#define IS_PIN_PWM(p) digitalPinHasPWM(p)
#define IS_PIN_SERVO(p) ((p) >= 2 && (p) - 2 < MAX_SERVOS)
#define IS_PIN_I2C(p) ((p) == 20 || (p) == 21)
#define IS_PIN_SPI(p) ((p) == SS || (p) == MOSI || (p) == MISO || (p) == SCK)
#define IS_PIN_SERIAL(p) ((p) > 13 && (p) < 20)
#define PIN_TO_DIGITAL(p) (p)
#define PIN_TO_ANALOG(p) ((p) - 54)
#define PIN_TO_PWM(p) PIN_TO_DIGITAL(p)
#define PIN_TO_SERVO(p) ((p) - 2)
// Arduino DUE
#elif defined(__SAM3X8E__)
#define TOTAL_ANALOG_PINS 12
#define TOTAL_PINS 66 // 54 digital + 12 analog
#define VERSION_BLINK_PIN 13
#define PIN_SERIAL1_RX 19
#define PIN_SERIAL1_TX 18
#define PIN_SERIAL2_RX 17
#define PIN_SERIAL2_TX 16
#define PIN_SERIAL3_RX 15
#define PIN_SERIAL3_TX 14
#define IS_PIN_DIGITAL(p) ((p) >= 2 && (p) < TOTAL_PINS)
#define IS_PIN_ANALOG(p) ((p) >= 54 && (p) < TOTAL_PINS)
#define IS_PIN_PWM(p) digitalPinHasPWM(p)
#define IS_PIN_SERVO(p) ((p) >= 2 && (p) - 2 < MAX_SERVOS)
#define IS_PIN_I2C(p) ((p) == 20 || (p) == 21) // 70 71
#define IS_PIN_SERIAL(p) ((p) > 13 && (p) < 20)
#define PIN_TO_DIGITAL(p) (p)
#define PIN_TO_ANALOG(p) ((p) - 54)
#define PIN_TO_PWM(p) PIN_TO_DIGITAL(p)
#define PIN_TO_SERVO(p) ((p) - 2)
// Arduino/Genuino MKR1000
#elif defined(ARDUINO_SAMD_MKR1000)
#define TOTAL_ANALOG_PINS 7
#define TOTAL_PINS 22 // 8 digital + 3 spi + 2 i2c + 2 uart + 7 analog
#define IS_PIN_DIGITAL(p) (((p) >= 0 && (p) <= 21) && !IS_PIN_SERIAL(p))
#define IS_PIN_ANALOG(p) ((p) >= 15 && (p) < 15 + TOTAL_ANALOG_PINS)
#define IS_PIN_PWM(p) digitalPinHasPWM(p)
#define IS_PIN_SERVO(p) (IS_PIN_DIGITAL(p) && (p) < MAX_SERVOS) // deprecated since v2.4
#define IS_PIN_I2C(p) ((p) == 11 || (p) == 12) // SDA = 11, SCL = 12
#define IS_PIN_SPI(p) ((p) == SS || (p) == MOSI || (p) == MISO || (p) == SCK)
#define IS_PIN_SERIAL(p) ((p) == PIN_SERIAL1_RX || (p) == PIN_SERIAL1_TX) //defined in variant.h RX = 13, TX = 14
#define PIN_TO_DIGITAL(p) (p)
#define PIN_TO_ANALOG(p) ((p) - 15)
#define PIN_TO_PWM(p) PIN_TO_DIGITAL(p)
#define PIN_TO_SERVO(p) (p) // deprecated since v2.4
// Arduino Zero
// Note this will work with an Arduino Zero Pro, but not with an Arduino M0 Pro
// Arduino M0 Pro does not properly map pins to the board labeled pin numbers
#elif defined(_VARIANT_ARDUINO_ZERO_)
#define TOTAL_ANALOG_PINS 6
#define TOTAL_PINS 25 // 14 digital + 6 analog + 2 i2c + 3 spi
#define TOTAL_PORTS 3 // set when TOTAL_PINS > num digitial I/O pins
#define VERSION_BLINK_PIN LED_BUILTIN
//#define PIN_SERIAL1_RX 0 // already defined in zero core variant.h
//#define PIN_SERIAL1_TX 1 // already defined in zero core variant.h
#define IS_PIN_DIGITAL(p) ((p) >= 0 && (p) <= 19)
#define IS_PIN_ANALOG(p) ((p) >= 14 && (p) < 14 + TOTAL_ANALOG_PINS)
#define IS_PIN_PWM(p) digitalPinHasPWM(p)
#define IS_PIN_SERVO(p) (IS_PIN_DIGITAL(p) && (p) < MAX_SERVOS) // deprecated since v2.4
#define IS_PIN_I2C(p) ((p) == 20 || (p) == 21) // SDA = 20, SCL = 21
#define IS_PIN_SPI(p) ((p) == SS || (p) == MOSI || (p) == MISO || (p) == SCK) // SS = A2
#define IS_PIN_SERIAL(p) ((p) == 0 || (p) == 1)
#define PIN_TO_DIGITAL(p) (p)
#define PIN_TO_ANALOG(p) ((p) - 14)
#define PIN_TO_PWM(p) PIN_TO_DIGITAL(p)
#define PIN_TO_SERVO(p) (p) // deprecated since v2.4
// Arduino 101
#elif defined(_VARIANT_ARDUINO_101_X_)
#define TOTAL_ANALOG_PINS NUM_ANALOG_INPUTS
#define TOTAL_PINS NUM_DIGITAL_PINS // 15 digital (including ATN pin) + 6 analog
#define VERSION_BLINK_PIN LED_BUILTIN
#define PIN_SERIAL1_RX 0
#define PIN_SERIAL1_TX 1
#define IS_PIN_DIGITAL(p) ((p) >= 0 && (p) <= 20)
#define IS_PIN_ANALOG(p) ((p) >= 14 && (p) < 14 + TOTAL_ANALOG_PINS)
#define IS_PIN_PWM(p) digitalPinHasPWM(p) // 3, 5, 6, 9
#define IS_PIN_SERVO(p) (IS_PIN_DIGITAL(p) && (p) < MAX_SERVOS) // deprecated since v2.4
#define IS_PIN_I2C(p) ((p) == SDA || (p) == SCL) // SDA = 18, SCL = 19
#define IS_PIN_SPI(p) ((p) == SS || (p) == MOSI || (p) == MISO || (p) == SCK)
#define IS_PIN_SERIAL(p) ((p) == 0 || (p) == 1)
#define PIN_TO_DIGITAL(p) (p)
#define PIN_TO_ANALOG(p) ((p) - 14)
#define PIN_TO_PWM(p) PIN_TO_DIGITAL(p)
#define PIN_TO_SERVO(p) (p) // deprecated since v2.4
// Teensy 1.0
#elif defined(__AVR_AT90USB162__)
#define TOTAL_ANALOG_PINS 0
#define TOTAL_PINS 21 // 21 digital + no analog
#define VERSION_BLINK_PIN 6
#define PIN_SERIAL1_RX 2
#define PIN_SERIAL1_TX 3
#define IS_PIN_DIGITAL(p) ((p) >= 0 && (p) < TOTAL_PINS)
#define IS_PIN_ANALOG(p) (0)
#define IS_PIN_PWM(p) digitalPinHasPWM(p)
#define IS_PIN_SERVO(p) ((p) >= 0 && (p) < MAX_SERVOS)
#define IS_PIN_I2C(p) (0)
#define IS_PIN_SPI(p) ((p) == SS || (p) == MOSI || (p) == MISO || (p) == SCK)
#define IS_PIN_SERIAL(p) ((p) == 2 || (p) == 3)
#define PIN_TO_DIGITAL(p) (p)
#define PIN_TO_ANALOG(p) (0)
#define PIN_TO_PWM(p) PIN_TO_DIGITAL(p)
#define PIN_TO_SERVO(p) (p)
// Teensy 2.0
#elif defined(__AVR_ATmega32U4__) && defined(CORE_TEENSY)
#define TOTAL_ANALOG_PINS 12
#define TOTAL_PINS 25 // 11 digital + 12 analog
#define VERSION_BLINK_PIN 11
#define PIN_SERIAL1_RX 7
#define PIN_SERIAL1_TX 8
#define IS_PIN_DIGITAL(p) ((p) >= 0 && (p) < TOTAL_PINS)
#define IS_PIN_ANALOG(p) ((p) >= 11 && (p) <= 22)
#define IS_PIN_PWM(p) digitalPinHasPWM(p)
#define IS_PIN_SERVO(p) ((p) >= 0 && (p) < MAX_SERVOS)
#define IS_PIN_I2C(p) ((p) == 5 || (p) == 6)
#define IS_PIN_SPI(p) ((p) == SS || (p) == MOSI || (p) == MISO || (p) == SCK)
#define IS_PIN_SERIAL(p) ((p) == 7 || (p) == 8)
#define PIN_TO_DIGITAL(p) (p)
#define PIN_TO_ANALOG(p) (((p) < 22) ? 21 - (p) : 11)
#define PIN_TO_PWM(p) PIN_TO_DIGITAL(p)
#define PIN_TO_SERVO(p) (p)
// Teensy 3.0, 3.1 and 3.2
#elif defined(__MK20DX128__) || defined(__MK20DX256__)
#define TOTAL_ANALOG_PINS 14
#define TOTAL_PINS 38 // 24 digital + 10 analog-digital + 4 analog
#define VERSION_BLINK_PIN 13
#define PIN_SERIAL1_RX 0
#define PIN_SERIAL1_TX 1
#define PIN_SERIAL2_RX 9
#define PIN_SERIAL2_TX 10
#define PIN_SERIAL3_RX 7
#define PIN_SERIAL3_TX 8
#define IS_PIN_DIGITAL(p) ((p) >= 0 && (p) <= 33)
#define IS_PIN_ANALOG(p) (((p) >= 14 && (p) <= 23) || ((p) >= 34 && (p) <= 38))
#define IS_PIN_PWM(p) digitalPinHasPWM(p)
#define IS_PIN_SERVO(p) ((p) >= 0 && (p) < MAX_SERVOS)
#define IS_PIN_I2C(p) ((p) == 18 || (p) == 19)
#define IS_PIN_SERIAL(p) (((p) > 6 && (p) < 11) || ((p) == 0 || (p) == 1))
#define PIN_TO_DIGITAL(p) (p)
#define PIN_TO_ANALOG(p) (((p) <= 23) ? (p) - 14 : (p) - 24)
#define PIN_TO_PWM(p) PIN_TO_DIGITAL(p)
#define PIN_TO_SERVO(p) (p)
// Teensy-LC
#elif defined(__MKL26Z64__)
#define TOTAL_ANALOG_PINS 13
#define TOTAL_PINS 27 // 27 digital + 13 analog-digital
#define VERSION_BLINK_PIN 13
#define PIN_SERIAL1_RX 0
#define PIN_SERIAL1_TX 1
#define PIN_SERIAL2_RX 9
#define PIN_SERIAL2_TX 10
#define PIN_SERIAL3_RX 7
#define PIN_SERIAL3_TX 8
#define IS_PIN_DIGITAL(p) ((p) >= 0 && (p) <= 26)
#define IS_PIN_ANALOG(p) ((p) >= 14)
#define IS_PIN_PWM(p) digitalPinHasPWM(p)
#define IS_PIN_SERVO(p) ((p) >= 0 && (p) < MAX_SERVOS)
#define IS_PIN_I2C(p) ((p) == 18 || (p) == 19)
#define IS_PIN_SERIAL(p) (((p) > 6 && (p) < 11) || ((p) == 0 || (p) == 1))
#define PIN_TO_DIGITAL(p) (p)
#define PIN_TO_ANALOG(p) ((p) - 14)
#define PIN_TO_PWM(p) PIN_TO_DIGITAL(p)
#define PIN_TO_SERVO(p) (p)
// Teensy++ 1.0 and 2.0
#elif defined(__AVR_AT90USB646__) || defined(__AVR_AT90USB1286__)
#define TOTAL_ANALOG_PINS 8
#define TOTAL_PINS 46 // 38 digital + 8 analog
#define VERSION_BLINK_PIN 6
#define PIN_SERIAL1_RX 2
#define PIN_SERIAL1_TX 3
#define IS_PIN_DIGITAL(p) ((p) >= 0 && (p) < TOTAL_PINS)
#define IS_PIN_ANALOG(p) ((p) >= 38 && (p) < TOTAL_PINS)
#define IS_PIN_PWM(p) digitalPinHasPWM(p)
#define IS_PIN_SERVO(p) ((p) >= 0 && (p) < MAX_SERVOS)
#define IS_PIN_I2C(p) ((p) == 0 || (p) == 1)
#define IS_PIN_SPI(p) ((p) == SS || (p) == MOSI || (p) == MISO || (p) == SCK)
#define IS_PIN_SERIAL(p) ((p) == 2 || (p) == 3)
#define PIN_TO_DIGITAL(p) (p)
#define PIN_TO_ANALOG(p) ((p) - 38)
#define PIN_TO_PWM(p) PIN_TO_DIGITAL(p)
#define PIN_TO_SERVO(p) (p)
// Leonardo
#elif defined(__AVR_ATmega32U4__)
#define TOTAL_ANALOG_PINS 12
#define TOTAL_PINS 30 // 14 digital + 12 analog + 4 SPI (D14-D17 on ISP header)
#define VERSION_BLINK_PIN 13
#define PIN_SERIAL1_RX 0
#define PIN_SERIAL1_TX 1
#define IS_PIN_DIGITAL(p) ((p) >= 0 && (p) < TOTAL_PINS)
#define IS_PIN_ANALOG(p) ((p) >= 18 && (p) < TOTAL_PINS)
#define IS_PIN_PWM(p) ((p) == 3 || (p) == 5 || (p) == 6 || (p) == 9 || (p) == 10 || (p) == 11 || (p) == 13)
#define IS_PIN_SERVO(p) ((p) >= 0 && (p) < MAX_SERVOS)
#define IS_PIN_I2C(p) ((p) == 2 || (p) == 3)
#define IS_PIN_SPI(p) ((p) == SS || (p) == MOSI || (p) == MISO || (p) == SCK)
#define IS_PIN_SERIAL(p) ((p) == 0 || (p) == 1)
#define PIN_TO_DIGITAL(p) (p)
#define PIN_TO_ANALOG(p) (p) - 18
#define PIN_TO_PWM(p) PIN_TO_DIGITAL(p)
#define PIN_TO_SERVO(p) (p)
// Intel Galileo Board (gen 1 and 2) and Intel Edison
#elif defined(ARDUINO_LINUX)
#define TOTAL_ANALOG_PINS 6
#define TOTAL_PINS 20 // 14 digital + 6 analog
#define VERSION_BLINK_PIN 13
#define PIN_SERIAL1_RX 0
#define PIN_SERIAL1_TX 1
#define IS_PIN_DIGITAL(p) ((p) >= 2 && (p) <= 19)
#define IS_PIN_ANALOG(p) ((p) >= 14 && (p) <= 19)
#define IS_PIN_PWM(p) digitalPinHasPWM(p)
#define IS_PIN_SERVO(p) (IS_PIN_DIGITAL(p) && (p) - 2 < MAX_SERVOS)
#define IS_PIN_I2C(p) ((p) == SDA || (p) == SCL)
#define IS_PIN_SPI(p) ((p) == SS || (p) == MOSI || (p) == MISO || (p) == SCK)
#define IS_PIN_SERIAL(p) ((p) == 0 || (p) == 1)
#define PIN_TO_DIGITAL(p) (p)
#define PIN_TO_ANALOG(p) ((p) - 14)
#define PIN_TO_PWM(p) PIN_TO_DIGITAL(p)
#define PIN_TO_SERVO(p) ((p) - 2)
// RedBearLab BLE Nano with factory switch settings (S1 - S10)
#elif defined(BLE_NANO)
#define TOTAL_ANALOG_PINS 6
#define TOTAL_PINS 15 // 9 digital + 3 analog
#define IS_PIN_DIGITAL(p) ((p) >= 2 && (p) <= 14)
#define IS_PIN_ANALOG(p) ((p) == 8 || (p) == 9 || (p) == 10 || (p) == 11 || (p) == 12 || (p) == 14) //A0~A5
#define IS_PIN_PWM(p) ((p) == 3 || (p) == 5 || (p) == 6)
#define IS_PIN_SERVO(p) ((p) >= 2 && (p) <= 7)
#define IS_PIN_I2C(p) ((p) == SDA || (p) == SCL)
#define IS_PIN_SPI(p) ((p) == CS || (p) == MOSI || (p) == MISO || (p) == SCK)
#define PIN_TO_DIGITAL(p) (p)
#define PIN_TO_ANALOG(p) ((p) - 8)
#define PIN_TO_PWM(p) PIN_TO_DIGITAL(p)
#define PIN_TO_SERVO(p) (p)
// Sanguino
#elif defined(__AVR_ATmega644P__) || defined(__AVR_ATmega644__)
#define TOTAL_ANALOG_PINS 8
#define TOTAL_PINS 32 // 24 digital + 8 analog
#define VERSION_BLINK_PIN 0
#define IS_PIN_DIGITAL(p) ((p) >= 2 && (p) < TOTAL_PINS)
#define IS_PIN_ANALOG(p) ((p) >= 24 && (p) < TOTAL_PINS)
#define IS_PIN_PWM(p) digitalPinHasPWM(p)
#define IS_PIN_SERVO(p) ((p) >= 0 && (p) < MAX_SERVOS)
#define IS_PIN_I2C(p) ((p) == 16 || (p) == 17)
#define PIN_TO_DIGITAL(p) (p)
#define PIN_TO_ANALOG(p) ((p) - 24)
#define PIN_TO_PWM(p) PIN_TO_DIGITAL(p)
#define PIN_TO_SERVO(p) ((p) - 2)
// Illuminato
#elif defined(__AVR_ATmega645__)
#define TOTAL_ANALOG_PINS 6
#define TOTAL_PINS 42 // 36 digital + 6 analog
#define VERSION_BLINK_PIN 13
#define IS_PIN_DIGITAL(p) ((p) >= 2 && (p) < TOTAL_PINS)
#define IS_PIN_ANALOG(p) ((p) >= 36 && (p) < TOTAL_PINS)
#define IS_PIN_PWM(p) digitalPinHasPWM(p)
#define IS_PIN_SERVO(p) ((p) >= 0 && (p) < MAX_SERVOS)
#define IS_PIN_I2C(p) ((p) == 4 || (p) == 5)
#define PIN_TO_DIGITAL(p) (p)
#define PIN_TO_ANALOG(p) ((p) - 36)
#define PIN_TO_PWM(p) PIN_TO_DIGITAL(p)
#define PIN_TO_SERVO(p) ((p) - 2)
// Pic32 chipKIT FubarinoSD
#elif defined(_BOARD_FUBARINO_SD_)
#define TOTAL_ANALOG_PINS NUM_ANALOG_PINS // 15
#define TOTAL_PINS NUM_DIGITAL_PINS // 45, All pins can be digital
#define MAX_SERVOS NUM_DIGITAL_PINS
#define VERSION_BLINK_PIN PIN_LED1
#define IS_PIN_DIGITAL(p) 1
#define IS_PIN_ANALOG(p) ((p) >= 30 && (p) <= 44)
#define IS_PIN_PWM(p) IS_PIN_DIGITAL(p)
#define IS_PIN_SERVO(p) IS_PIN_DIGITAL(p)
#define IS_PIN_I2C(p) ((p) == 1 || (p) == 2)
#define IS_PIN_SPI(p) ((p) == SS || (p) == MOSI || (p) == MISO || (p) == SCK)
#define PIN_TO_DIGITAL(p) (p)
#define PIN_TO_ANALOG(p) (14 - (p - 30))
#define PIN_TO_PWM(p) (p)
#define PIN_TO_SERVO(p) (p)
// Pic32 chipKIT FubarinoMini
// Note, FubarinoMini analog pin 20 will not function in Firmata as analog input due to limitation in analog mapping
#elif defined(_BOARD_FUBARINO_MINI_)
#define TOTAL_ANALOG_PINS 14 // We have to fake this because of the poor analog pin mapping planning in FubarinoMini
#define TOTAL_PINS NUM_DIGITAL_PINS // 33
#define MAX_SERVOS NUM_DIGITAL_PINS
#define VERSION_BLINK_PIN PIN_LED1
#define IS_PIN_DIGITAL(p) ((p) != 14 && (p) != 15 && (p) != 31 && (p) != 32)
#define IS_PIN_ANALOG(p) ((p) == 0 || ((p) >= 3 && (p) <= 13))
#define IS_PIN_PWM(p) IS_PIN_DIGITAL(p)
#define IS_PIN_SERVO(p) IS_PIN_DIGITAL(p)
#define IS_PIN_I2C(p) ((p) == 25 || (p) == 26)
#define IS_PIN_SPI(p) ((p) == SS || (p) == MOSI || (p) == MISO || (p) == SCK)
#define PIN_TO_DIGITAL(p) (p)
#define PIN_TO_ANALOG(p) (p)
#define PIN_TO_PWM(p) (p)
#define PIN_TO_SERVO(p) (p)
// Pic32 chipKIT UNO32
#elif defined(_BOARD_UNO_) && defined(__PIC32) // NOTE: no _BOARD_UNO32_ to use
#define TOTAL_ANALOG_PINS NUM_ANALOG_PINS // 12
#define TOTAL_PINS NUM_DIGITAL_PINS // 47 All pins can be digital
#define MAX_SERVOS NUM_DIGITAL_PINS // All pins can be servo with SoftPWMservo
#define VERSION_BLINK_PIN PIN_LED1
#define IS_PIN_DIGITAL(p) ((p) >= 2)
#define IS_PIN_ANALOG(p) ((p) >= 14 && (p) <= 25)
#define IS_PIN_PWM(p) IS_PIN_DIGITAL(p)
#define IS_PIN_SERVO(p) IS_PIN_DIGITAL(p)
#define IS_PIN_I2C(p) ((p) == 45 || (p) == 46)
#define IS_PIN_SPI(p) ((p) == SS || (p) == MOSI || (p) == MISO || (p) == SCK)
#define PIN_TO_DIGITAL(p) (p)
#define PIN_TO_ANALOG(p) ((p) - 14)
#define PIN_TO_PWM(p) (p)
#define PIN_TO_SERVO(p) (p)
// Pic32 chipKIT DP32
#elif defined(_BOARD_DP32_)
#define TOTAL_ANALOG_PINS 15 // Really only has 9, but have to override because of mistake in variant file
#define TOTAL_PINS NUM_DIGITAL_PINS // 19
#define MAX_SERVOS NUM_DIGITAL_PINS // All pins can be servo with SoftPWMservo
#define VERSION_BLINK_PIN PIN_LED1
#define IS_PIN_DIGITAL(p) (((p) != 1) && ((p) != 4) && ((p) != 5) && ((p) != 15) && ((p) != 16))
#define IS_PIN_ANALOG(p) ((p) >= 6 && (p) <= 14)
#define IS_PIN_PWM(p) IS_PIN_DIGITAL(p)
#define IS_PIN_SERVO(p) IS_PIN_DIGITAL(p)
#define IS_PIN_I2C(p) ((p) == 2 || (p) == 3)
#define IS_PIN_SPI(p) ((p) == SS || (p) == MOSI || (p) == MISO || (p) == SCK)
#define PIN_TO_DIGITAL(p) (p)
#define PIN_TO_ANALOG(p) (p)
#define PIN_TO_PWM(p) (p)
#define PIN_TO_SERVO(p) (p)
// Pic32 chipKIT uC32
#elif defined(_BOARD_UC32_)
#define TOTAL_ANALOG_PINS NUM_ANALOG_PINS // 12
#define TOTAL_PINS NUM_DIGITAL_PINS // 47 All pins can be digital
#define MAX_SERVOS NUM_DIGITAL_PINS // All pins can be servo with SoftPWMservo
#define VERSION_BLINK_PIN PIN_LED1
#define IS_PIN_DIGITAL(p) ((p) >= 2)
#define IS_PIN_ANALOG(p) ((p) >= 14 && (p) <= 25)
#define IS_PIN_PWM(p) IS_PIN_DIGITAL(p)
#define IS_PIN_SERVO(p) IS_PIN_DIGITAL(p)
#define IS_PIN_I2C(p) ((p) == 45 || (p) == 46)
#define IS_PIN_SPI(p) ((p) == SS || (p) == MOSI || (p) == MISO || (p) == SCK)
#define PIN_TO_DIGITAL(p) (p)
#define PIN_TO_ANALOG(p) ((p) - 14)
#define PIN_TO_PWM(p) (p)
#define PIN_TO_SERVO(p) (p)
// Pic32 chipKIT WF32
#elif defined(_BOARD_WF32_)
#define TOTAL_ANALOG_PINS NUM_ANALOG_PINS
#define TOTAL_PINS NUM_DIGITAL_PINS
#define MAX_SERVOS NUM_DIGITAL_PINS
#define VERSION_BLINK_PIN PIN_LED1
#define IS_PIN_DIGITAL(p) ((p) >= 2 && (p) <= 49) // Accounts for SD and WiFi dedicated pins
#define IS_PIN_ANALOG(p) ((p) >= 14 && (p) <= 25)
#define IS_PIN_PWM(p) IS_PIN_DIGITAL(p)
#define IS_PIN_SERVO(p) IS_PIN_DIGITAL(p)
#define IS_PIN_I2C(p) ((p) == 34 || (p) == 35)
#define IS_PIN_SPI(p) ((p) == SS || (p) == MOSI || (p) == MISO || (p) == SCK)
#define PIN_TO_DIGITAL(p) (p)
#define PIN_TO_ANALOG(p) ((p) - 14)
#define PIN_TO_PWM(p) (p)
#define PIN_TO_SERVO(p) (p)
// Pic32 chipKIT WiFire
#elif defined(_BOARD_WIFIRE_)
#define TOTAL_ANALOG_PINS NUM_ANALOG_PINS // 14
#define TOTAL_PINS NUM_DIGITAL_PINS // 71
#define MAX_SERVOS NUM_DIGITAL_PINS
#define VERSION_BLINK_PIN PIN_LED1
#define IS_PIN_DIGITAL(p) ((p) >= 2 && (p) <= 47) // Accounts for SD and WiFi dedicated pins
#define IS_PIN_ANALOG(p) ((p) >= 14 && (p) <= 25)
#define IS_PIN_PWM(p) IS_PIN_DIGITAL(p)
#define IS_PIN_SERVO(p) IS_PIN_DIGITAL(p)
#define IS_PIN_I2C(p) ((p) == 34 || (p) == 35)
#define IS_PIN_SPI(p) ((p) == SS || (p) == MOSI || (p) == MISO || (p) == SCK)
#define PIN_TO_DIGITAL(p) (p)
#define PIN_TO_ANALOG(p) ((p) <= 25 ? ((p) - 14) : (p) - 36)
#define PIN_TO_PWM(p) (p)
#define PIN_TO_SERVO(p) (p)
// Pic32 chipKIT MAX32
#elif defined(_BOARD_MEGA_) && defined(__PIC32) // NOTE: no _BOARD_MAX32_ to use
#define TOTAL_ANALOG_PINS NUM_ANALOG_PINS // 16
#define TOTAL_PINS NUM_DIGITAL_PINS // 87
#define MAX_SERVOS NUM_DIGITAL_PINS
#define VERSION_BLINK_PIN PIN_LED1
#define IS_PIN_DIGITAL(p) ((p) >= 2)
#define IS_PIN_ANALOG(p) ((p) >= 54 && (p) <= 69)
#define IS_PIN_PWM(p) IS_PIN_DIGITAL(p)
#define IS_PIN_SERVO(p) IS_PIN_DIGITAL(p)
#define IS_PIN_I2C(p) ((p) == 34 || (p) == 35)
#define IS_PIN_SPI(p) ((p) == SS || (p) == MOSI || (p) == MISO || (p) == SCK)
#define PIN_TO_DIGITAL(p) (p)
#define PIN_TO_ANALOG(p) ((p) - 54)
#define PIN_TO_PWM(p) (p)
#define PIN_TO_SERVO(p) (p)
// Pic32 chipKIT Pi
#elif defined(_BOARD_CHIPKIT_PI_)
#define TOTAL_ANALOG_PINS 16
#define TOTAL_PINS NUM_DIGITAL_PINS // 19
#define MAX_SERVOS NUM_DIGITAL_PINS
#define VERSION_BLINK_PIN PIN_LED1
#define IS_PIN_DIGITAL(p) (((p) >= 2) && ((p) <= 3) || (((p) >= 8) && ((p) <= 13)) || (((p) >= 14) && ((p) <= 17)))
#define IS_PIN_ANALOG(p) ((p) >= 14 && (p) <= 17)
#define IS_PIN_PWM(p) IS_PIN_DIGITAL(p)
#define IS_PIN_SERVO(p) IS_PIN_DIGITAL(p)
#define IS_PIN_I2C(p) ((p) == 16 || (p) == 17)
#define IS_PIN_SPI(p) ((p) == SS || (p) == MOSI || (p) == MISO || (p) == SCK)
#define PIN_TO_DIGITAL(p) (p)
#define PIN_TO_ANALOG(p) ((p) <= 15 ? (p) - 14 : (p) - 12)
//#define PIN_TO_ANALOG(p) (((p) <= 16) ? ((p) - 14) : ((p) - 16))
#define PIN_TO_PWM(p) (p)
#define PIN_TO_SERVO(p) (p)
// Pinoccio Scout
// Note: digital pins 9-16 are usable but not labeled on the board numerically.
// SS=9, MOSI=10, MISO=11, SCK=12, RX1=13, TX1=14, SCL=15, SDA=16
#elif defined(ARDUINO_PINOCCIO)
#define TOTAL_ANALOG_PINS 8
#define TOTAL_PINS NUM_DIGITAL_PINS // 32
#define VERSION_BLINK_PIN 23
#define PIN_SERIAL1_RX 13
#define PIN_SERIAL1_TX 14
#define IS_PIN_DIGITAL(p) (((p) >= 2) && ((p) <= 16)) || (((p) >= 24) && ((p) <= 31))
#define IS_PIN_ANALOG(p) ((p) >= 24 && (p) <= 31)
#define IS_PIN_PWM(p) digitalPinHasPWM(p)
#define IS_PIN_SERVO(p) IS_PIN_DIGITAL(p)
#define IS_PIN_I2C(p) ((p) == SCL || (p) == SDA)
#define IS_PIN_SPI(p) ((p) == SS || (p) == MOSI || (p) == MISO || (p) == SCK)
#define IS_PIN_SERIAL(p) ((p) == 13 || (p) == 14)
#define PIN_TO_DIGITAL(p) (p)
#define PIN_TO_ANALOG(p) ((p) - 24)
#define PIN_TO_PWM(p) PIN_TO_DIGITAL(p)
#define PIN_TO_SERVO(p) ((p) - 2)
// ESP8266
// note: boot mode GPIOs 0, 2 and 15 can be used as outputs, GPIOs 6-11 are in use for flash IO
#elif defined(ESP8266)
#define TOTAL_ANALOG_PINS NUM_ANALOG_INPUTS
#define TOTAL_PINS A0 + NUM_ANALOG_INPUTS
#define PIN_SERIAL_RX 3
#define PIN_SERIAL_TX 1
#define IS_PIN_DIGITAL(p) (((p) >= 0 && (p) <= 5) || ((p) >= 12 && (p) < A0))
#define IS_PIN_ANALOG(p) ((p) >= A0 && (p) < A0 + NUM_ANALOG_INPUTS)
#define IS_PIN_PWM(p) digitalPinHasPWM(p)
#define IS_PIN_SERVO(p) (IS_PIN_DIGITAL(p) && (p) < MAX_SERVOS)
#define IS_PIN_I2C(p) ((p) == SDA || (p) == SCL)
#define IS_PIN_SPI(p) ((p) == SS || (p) == MOSI || (p) == MISO || (p) == SCK)
#define IS_PIN_INTERRUPT(p) (digitalPinToInterrupt(p) > NOT_AN_INTERRUPT)
#define IS_PIN_SERIAL(p) ((p) == PIN_SERIAL_RX || (p) == PIN_SERIAL_TX)
#define PIN_TO_DIGITAL(p) (p)
#define PIN_TO_ANALOG(p) ((p) - A0)
#define PIN_TO_PWM(p) PIN_TO_DIGITAL(p)
#define PIN_TO_SERVO(p) (p)
#define DEFAULT_PWM_RESOLUTION 10
// Circuit Playground Express
#elif defined(__SAMD21G18A__)
#define TOTAL_ANALOG_PINS 6
#define TOTAL_PINS 25 // 14 digital + 6 analog + 2 i2c + 3 spi
#define TOTAL_PORTS 3 // set when TOTAL_PINS > num digitial I/O pins
#define VERSION_BLINK_PIN LED_BUILTIN
//#define PIN_SERIAL1_RX 0 // already defined in zero core variant.h
//#define PIN_SERIAL1_TX 1 // already defined in zero core variant.h
#define IS_PIN_DIGITAL(p) ((p) >= 0 && (p) <= 19)
#define IS_PIN_ANALOG(p) ((p) >= 14 && (p) < 14 + TOTAL_ANALOG_PINS)
#define IS_PIN_PWM(p) digitalPinHasPWM(p)
#define IS_PIN_SERVO(p) (IS_PIN_DIGITAL(p) && (p) < MAX_SERVOS) // deprecated since v2.4
#define IS_PIN_I2C(p) ((p) == 20 || (p) == 21) // SDA = 20, SCL = 21
#define IS_PIN_SPI(p) ((p) == SS || (p) == MOSI || (p) == MISO || (p) == SCK) // SS = A2
#define IS_PIN_SERIAL(p) ((p) == 0 || (p) == 1)
#define PIN_TO_DIGITAL(p) (p)
#define PIN_TO_ANALOG(p) ((p) - 14)
#define PIN_TO_PWM(p) PIN_TO_DIGITAL(p)
// Circuit Playground Bluefruit
#elif defined(ARDUINO_NRF52840_CIRCUITPLAY)
#define TOTAL_ANALOG_PINS 6
#define TOTAL_PINS 25 // 14 digital + 6 analog + 2 i2c + 3 spi
#define TOTAL_PORTS 3 // set when TOTAL_PINS > num digitial I/O pins
#define VERSION_BLINK_PIN LED_BUILTIN
//#define PIN_SERIAL1_RX 0 // already defined in zero core variant.h
//#define PIN_SERIAL1_TX 1 // already defined in zero core variant.h
#define IS_PIN_DIGITAL(p) ((p) >= 0 && (p) <= 19)
#define IS_PIN_ANALOG(p) ((p) >= 14 && (p) < 14 + TOTAL_ANALOG_PINS)
#define IS_PIN_PWM(p) digitalPinHasPWM(p)
#define IS_PIN_SERVO(p) (IS_PIN_DIGITAL(p) && (p) < MAX_SERVOS) // deprecated since v2.4
#define IS_PIN_I2C(p) ((p) == 20 || (p) == 21) // SDA = 20, SCL = 21
#define IS_PIN_SPI(p) ((p) == SS || (p) == MOSI || (p) == MISO || (p) == SCK) // SS = A2
#define IS_PIN_SERIAL(p) ((p) == 0 || (p) == 1)
#define PIN_TO_DIGITAL(p) (p)
#define PIN_TO_ANALOG(p) ((p) - 14)
#define PIN_TO_PWM(p) PIN_TO_DIGITAL(p)
// anything else
#else
#error "Please edit CP_Boards.h with a hardware abstraction for this board"
#endif
// as long this is not defined for all boards:
#ifndef IS_PIN_SPI
#define IS_PIN_SPI(p) 0
#endif
#ifndef IS_PIN_SERIAL
#define IS_PIN_SERIAL(p) 0
#endif
#ifndef DEFAULT_PWM_RESOLUTION
#define DEFAULT_PWM_RESOLUTION 8
#endif
/*==============================================================================
* readPort() - Read an 8 bit port
*============================================================================*/
static inline unsigned char readPort(byte, byte) __attribute__((always_inline, unused));
static inline unsigned char readPort(byte port, byte bitmask)
{
#if defined(ARDUINO_PINOUT_OPTIMIZE)
if (port == 0) return (PIND & 0xFC) & bitmask; // ignore Rx/Tx 0/1
if (port == 1) return ((PINB & 0x3F) | ((PINC & 0x03) << 6)) & bitmask;
if (port == 2) return ((PINC & 0x3C) >> 2) & bitmask;
return 0;
#else
unsigned char out = 0, pin = port * 8;
if (IS_PIN_DIGITAL(pin + 0) && (bitmask & 0x01) && digitalRead(PIN_TO_DIGITAL(pin + 0))) out |= 0x01;
if (IS_PIN_DIGITAL(pin + 1) && (bitmask & 0x02) && digitalRead(PIN_TO_DIGITAL(pin + 1))) out |= 0x02;
if (IS_PIN_DIGITAL(pin + 2) && (bitmask & 0x04) && digitalRead(PIN_TO_DIGITAL(pin + 2))) out |= 0x04;
if (IS_PIN_DIGITAL(pin + 3) && (bitmask & 0x08) && digitalRead(PIN_TO_DIGITAL(pin + 3))) out |= 0x08;
if (IS_PIN_DIGITAL(pin + 4) && (bitmask & 0x10) && digitalRead(PIN_TO_DIGITAL(pin + 4))) out |= 0x10;
if (IS_PIN_DIGITAL(pin + 5) && (bitmask & 0x20) && digitalRead(PIN_TO_DIGITAL(pin + 5))) out |= 0x20;
if (IS_PIN_DIGITAL(pin + 6) && (bitmask & 0x40) && digitalRead(PIN_TO_DIGITAL(pin + 6))) out |= 0x40;
if (IS_PIN_DIGITAL(pin + 7) && (bitmask & 0x80) && digitalRead(PIN_TO_DIGITAL(pin + 7))) out |= 0x80;
return out;
#endif
}
/*==============================================================================
* writePort() - Write an 8 bit port, only touch pins specified by a bitmask
*============================================================================*/
static inline unsigned char writePort(byte, byte, byte) __attribute__((always_inline, unused));
static inline unsigned char writePort(byte port, byte value, byte bitmask)
{
#if defined(ARDUINO_PINOUT_OPTIMIZE)
if (port == 0) {
bitmask = bitmask & 0xFC; // do not touch Tx & Rx pins
byte valD = value & bitmask;
byte maskD = ~bitmask;
cli();
PORTD = (PORTD & maskD) | valD;
sei();
} else if (port == 1) {
byte valB = (value & bitmask) & 0x3F;
byte valC = (value & bitmask) >> 6;
byte maskB = ~(bitmask & 0x3F);
byte maskC = ~((bitmask & 0xC0) >> 6);
cli();
PORTB = (PORTB & maskB) | valB;
PORTC = (PORTC & maskC) | valC;
sei();
} else if (port == 2) {
bitmask = bitmask & 0x0F;
byte valC = (value & bitmask) << 2;
byte maskC = ~(bitmask << 2);
cli();
PORTC = (PORTC & maskC) | valC;
sei();
}
return 1;
#else
byte pin = port * 8;
if ((bitmask & 0x01)) digitalWrite(PIN_TO_DIGITAL(pin + 0), (value & 0x01));
if ((bitmask & 0x02)) digitalWrite(PIN_TO_DIGITAL(pin + 1), (value & 0x02));
if ((bitmask & 0x04)) digitalWrite(PIN_TO_DIGITAL(pin + 2), (value & 0x04));
if ((bitmask & 0x08)) digitalWrite(PIN_TO_DIGITAL(pin + 3), (value & 0x08));
if ((bitmask & 0x10)) digitalWrite(PIN_TO_DIGITAL(pin + 4), (value & 0x10));
if ((bitmask & 0x20)) digitalWrite(PIN_TO_DIGITAL(pin + 5), (value & 0x20));
if ((bitmask & 0x40)) digitalWrite(PIN_TO_DIGITAL(pin + 6), (value & 0x40));
if ((bitmask & 0x80)) digitalWrite(PIN_TO_DIGITAL(pin + 7), (value & 0x80));
return 1;
#endif
}
#ifndef TOTAL_PORTS
#define TOTAL_PORTS ((TOTAL_PINS + 7) / 8)
#endif
#endif /* Firmata_Boards_h */

668
arduino-cli/libraries/Adafruit_Circuit_Playground/utility/CP_Firmata.cpp Normal file
View File

@@ -0,0 +1,668 @@
/*
Firmata.cpp - Firmata library v2.5.3 - 2016-06-18
Copyright (c) 2006-2008 Hans-Christoph Steiner. All rights reserved.
Copyright (C) 2009-2016 Jeff Hoefs. All rights reserved.
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.
See file LICENSE.txt for further informations on licensing terms.
*/
//******************************************************************************
//* Includes
//******************************************************************************
#include "CP_Firmata.h"
#include "HardwareSerial.h"
extern "C" {
#include <string.h>
#include <stdlib.h>
}
//******************************************************************************
//* Support Functions
//******************************************************************************
/**
* Split a 16-bit byte into two 7-bit values and write each value.
* @param value The 16-bit value to be split and written separately.
*/
void FirmataClass::sendValueAsTwo7bitBytes(int value)
{
FirmataStream->write(value & 0x7F); // LSB
FirmataStream->write(value >> 7 & 0x7F); // MSB
}
/**
* A helper method to write the beginning of a Sysex message transmission.
*/
void FirmataClass::startSysex(void)
{
FirmataStream->write(START_SYSEX);
}
/**
* A helper method to write the end of a Sysex message transmission.
*/
void FirmataClass::endSysex(void)
{
FirmataStream->write(END_SYSEX);
}
//******************************************************************************
//* Constructors
//******************************************************************************
/**
* The Firmata class.
* An instance named "Firmata" is created automatically for the user.
*/
FirmataClass::FirmataClass()
{
firmwareVersionCount = 0;
firmwareVersionVector = 0;
systemReset();
}
//******************************************************************************
//* Public Methods
//******************************************************************************
/**
* Initialize the default Serial transport at the default baud of 57600.
*/
void FirmataClass::begin(void)
{
begin(57600);
}
/**
* Initialize the default Serial transport and override the default baud.
* Sends the protocol version to the host application followed by the firmware version and name.
* blinkVersion is also called. To skip the call to blinkVersion, call Firmata.disableBlinkVersion()
* before calling Firmata.begin(baud).
* @param speed The baud to use. 57600 baud is the default value.
*/
void FirmataClass::begin(long speed)
{
Serial.begin(speed);
FirmataStream = &Serial;
blinkVersion();
printVersion(); // send the protocol version
printFirmwareVersion(); // send the firmware name and version
}
/**
* Reassign the Firmata stream transport.
* @param s A reference to the Stream transport object. This can be any type of
* transport that implements the Stream interface. Some examples include Ethernet, WiFi
* and other UARTs on the board (Serial1, Serial2, etc).
*/
void FirmataClass::begin(Stream &s)
{
FirmataStream = &s;
// do not call blinkVersion() here because some hardware such as the
// Ethernet shield use pin 13
printVersion();
printFirmwareVersion();
}
/**
* Send the Firmata protocol version to the Firmata host application.
*/
void FirmataClass::printVersion(void)
{
FirmataStream->write(REPORT_VERSION);
FirmataStream->write(FIRMATA_PROTOCOL_MAJOR_VERSION);
FirmataStream->write(FIRMATA_PROTOCOL_MINOR_VERSION);
}
/**
* Blink the Firmata protocol version to the onboard LEDs (if the board has an onboard LED).
* If VERSION_BLINK_PIN is not defined in Boards.h for a particular board, then this method
* does nothing.
* The first series of flashes indicates the firmware major version (2 flashes = 2).
* The second series of flashes indicates the firmware minor version (5 flashes = 5).
*/
void FirmataClass::blinkVersion(void)
{
#if defined(VERSION_BLINK_PIN)
if (blinkVersionDisabled) return;
// flash the pin with the protocol version
pinMode(VERSION_BLINK_PIN, OUTPUT);
strobeBlinkPin(VERSION_BLINK_PIN, FIRMATA_FIRMWARE_MAJOR_VERSION, 40, 210);
delay(250);
strobeBlinkPin(VERSION_BLINK_PIN, FIRMATA_FIRMWARE_MINOR_VERSION, 40, 210);
delay(125);
#endif
}
/**
* Provides a means to disable the version blink sequence on the onboard LED, trimming startup
* time by a couple of seconds.
* Call this before Firmata.begin(). It only applies when using the default Serial transport.
*/
void FirmataClass::disableBlinkVersion()
{
blinkVersionDisabled = true;
}
/**
* Sends the firmware name and version to the Firmata host application. The major and minor version
* numbers are the first 2 bytes in the message. The following bytes are the characters of the
* firmware name.
*/
void FirmataClass::printFirmwareVersion(void)
{
byte i;
if (firmwareVersionCount) { // make sure that the name has been set before reporting
startSysex();
FirmataStream->write(REPORT_FIRMWARE);
FirmataStream->write(firmwareVersionVector[0]); // major version number
FirmataStream->write(firmwareVersionVector[1]); // minor version number
for (i = 2; i < firmwareVersionCount; ++i) {
sendValueAsTwo7bitBytes(firmwareVersionVector[i]);
}
endSysex();
}
}
/**
* Sets the name and version of the firmware. This is not the same version as the Firmata protocol
* (although at times the firmware version and protocol version may be the same number).
* @param name A pointer to the name char array
* @param major The major version number
* @param minor The minor version number
*/
void FirmataClass::setFirmwareNameAndVersion(const char *name, byte major, byte minor)
{
const char *firmwareName;
const char *extension;
// parse out ".cpp" and "applet/" that comes from using __FILE__
extension = strstr(name, ".cpp");
firmwareName = strrchr(name, '/');
if (!firmwareName) {
// windows
firmwareName = strrchr(name, '\\');
}
if (!firmwareName) {
// user passed firmware name
firmwareName = name;
} else {
firmwareName ++;
}
if (!extension) {
firmwareVersionCount = strlen(firmwareName) + 2;
} else {
firmwareVersionCount = extension - firmwareName + 2;
}
// in case anyone calls setFirmwareNameAndVersion more than once
free(firmwareVersionVector);
firmwareVersionVector = (byte *) malloc(firmwareVersionCount + 1);
firmwareVersionVector[firmwareVersionCount] = 0;
firmwareVersionVector[0] = major;
firmwareVersionVector[1] = minor;
strncpy((char *)firmwareVersionVector + 2, firmwareName, firmwareVersionCount - 2);
}
//------------------------------------------------------------------------------
// Serial Receive Handling
/**
* A wrapper for Stream::available()
* @return The number of bytes remaining in the input stream buffer.
*/
int FirmataClass::available(void)
{
return FirmataStream->available();
}
/**
* Process incoming sysex messages. Handles REPORT_FIRMWARE and STRING_DATA internally.
* Calls callback function for STRING_DATA and all other sysex messages.
* @private
*/
void FirmataClass::processSysexMessage(void)
{
switch (storedInputData[0]) { //first byte in buffer is command
case REPORT_FIRMWARE:
printFirmwareVersion();
break;
case STRING_DATA:
if (currentStringCallback) {
byte bufferLength = (sysexBytesRead - 1) / 2;
byte i = 1;
byte j = 0;
while (j < bufferLength) {
// The string length will only be at most half the size of the
// stored input buffer so we can decode the string within the buffer.
storedInputData[j] = storedInputData[i];
i++;
storedInputData[j] += (storedInputData[i] << 7);
i++;
j++;
}
// Make sure string is null terminated. This may be the case for data
// coming from client libraries in languages that don't null terminate
// strings.
if (storedInputData[j - 1] != '\0') {
storedInputData[j] = '\0';
}
(*currentStringCallback)((char *)&storedInputData[0]);
}
break;
default:
if (currentSysexCallback)
(*currentSysexCallback)(storedInputData[0], sysexBytesRead - 1, storedInputData + 1);
}
}
/**
* Read a single int from the input stream. If the value is not = -1, pass it on to parse(byte)
*/
void FirmataClass::processInput(void)
{
int inputData = FirmataStream->read(); // this is 'int' to handle -1 when no data
if (inputData != -1) {
parse(inputData);
}
}
/**
* Parse data from the input stream.
* @param inputData A single byte to be added to the parser.
*/
void FirmataClass::parse(byte inputData)
{
int command;
if (parsingSysex) {
if (inputData == END_SYSEX) {
//stop sysex byte
parsingSysex = false;
//fire off handler function
processSysexMessage();
} else {
//normal data byte - add to buffer
storedInputData[sysexBytesRead] = inputData;
sysexBytesRead++;
}
} else if ( (waitForData > 0) && (inputData < 128) ) {
waitForData--;
storedInputData[waitForData] = inputData;
if ( (waitForData == 0) && executeMultiByteCommand ) { // got the whole message
switch (executeMultiByteCommand) {
case ANALOG_MESSAGE:
if (currentAnalogCallback) {
(*currentAnalogCallback)(multiByteChannel,
(storedInputData[0] << 7)
+ storedInputData[1]);
}
break;
case DIGITAL_MESSAGE:
if (currentDigitalCallback) {
(*currentDigitalCallback)(multiByteChannel,
(storedInputData[0] << 7)
+ storedInputData[1]);
}
break;
case SET_PIN_MODE:
if (currentPinModeCallback)
(*currentPinModeCallback)(storedInputData[1], storedInputData[0]);
break;
case SET_DIGITAL_PIN_VALUE:
if (currentPinValueCallback)
(*currentPinValueCallback)(storedInputData[1], storedInputData[0]);
break;
case REPORT_ANALOG:
if (currentReportAnalogCallback)
(*currentReportAnalogCallback)(multiByteChannel, storedInputData[0]);
break;
case REPORT_DIGITAL:
if (currentReportDigitalCallback)
(*currentReportDigitalCallback)(multiByteChannel, storedInputData[0]);
break;
}
executeMultiByteCommand = 0;
}
} else {
// remove channel info from command byte if less than 0xF0
if (inputData < 0xF0) {
command = inputData & 0xF0;
multiByteChannel = inputData & 0x0F;
} else {
command = inputData;
// commands in the 0xF* range don't use channel data
}
switch (command) {
case ANALOG_MESSAGE:
case DIGITAL_MESSAGE:
case SET_PIN_MODE:
case SET_DIGITAL_PIN_VALUE:
waitForData = 2; // two data bytes needed
executeMultiByteCommand = command;
break;
case REPORT_ANALOG:
case REPORT_DIGITAL:
waitForData = 1; // one data byte needed
executeMultiByteCommand = command;
break;
case START_SYSEX:
parsingSysex = true;
sysexBytesRead = 0;
break;
case SYSTEM_RESET:
systemReset();
break;
case REPORT_VERSION:
Firmata.printVersion();
break;
}
}
}
/**
* @return Returns true if the parser is actively parsing data.
*/
boolean FirmataClass::isParsingMessage(void)
{
return (waitForData > 0 || parsingSysex);
}
//------------------------------------------------------------------------------
// Output Stream Handling
/**
* Send an analog message to the Firmata host application. The range of pins is limited to [0..15]
* when using the ANALOG_MESSAGE. The maximum value of the ANALOG_MESSAGE is limited to 14 bits
* (16384). To increase the pin range or value, see the documentation for the EXTENDED_ANALOG
* message.
* @param pin The analog pin to send the value of (limited to pins 0 - 15).
* @param value The value of the analog pin (0 - 1024 for 10-bit analog, 0 - 4096 for 12-bit, etc).
* The maximum value is 14-bits (16384).
*/
void FirmataClass::sendAnalog(byte pin, int value)
{
// pin can only be 0-15, so chop higher bits
FirmataStream->write(ANALOG_MESSAGE | (pin & 0xF));
sendValueAsTwo7bitBytes(value);
}
/* (intentionally left out asterix here)
* STUB - NOT IMPLEMENTED
* Send a single digital pin value to the Firmata host application.
* @param pin The digital pin to send the value of.
* @param value The value of the pin.
*/
void FirmataClass::sendDigital(byte pin, int value)
{
/* TODO add single pin digital messages to the protocol, this needs to
* track the last digital data sent so that it can be sure to change just
* one bit in the packet. This is complicated by the fact that the
* numbering of the pins will probably differ on Arduino, Wiring, and
* other boards.
*/
// TODO: the digital message should not be sent on the serial port every
// time sendDigital() is called. Instead, it should add it to an int
// which will be sent on a schedule. If a pin changes more than once
// before the digital message is sent on the serial port, it should send a
// digital message for each change.
// if(value == 0)
// sendDigitalPortPair();
}
/**
* Send an 8-bit port in a single digital message (protocol v2 and later).
* Send 14-bits in a single digital message (protocol v1).
* @param portNumber The port number to send. Note that this is not the same as a "port" on the
* physical microcontroller. Ports are defined in order per every 8 pins in ascending order
* of the Arduino digital pin numbering scheme. Port 0 = pins D0 - D7, port 1 = pins D8 - D15, etc.
* @param portData The value of the port. The value of each pin in the port is represented by a bit.
*/
void FirmataClass::sendDigitalPort(byte portNumber, int portData)
{
FirmataStream->write(DIGITAL_MESSAGE | (portNumber & 0xF));
FirmataStream->write((byte)portData % 128); // Tx bits 0-6 (protocol v1 and higher)
FirmataStream->write(portData >> 7); // Tx bits 7-13 (bit 7 only for protocol v2 and higher)
}
/**
* Send a sysex message where all values after the command byte are packet as 2 7-bit bytes
* (this is not always the case so this function is not always used to send sysex messages).
* @param command The sysex command byte.
* @param bytec The number of data bytes in the message (excludes start, command and end bytes).
* @param bytev A pointer to the array of data bytes to send in the message.
*/
void FirmataClass::sendSysex(byte command, byte bytec, byte *bytev)
{
byte i;
startSysex();
FirmataStream->write(command);
for (i = 0; i < bytec; i++) {
sendValueAsTwo7bitBytes(bytev[i]);
}
endSysex();
}
/**
* Send a string to the Firmata host application.
* @param command Must be STRING_DATA
* @param string A pointer to the char string
*/
void FirmataClass::sendString(byte command, const char *string)
{
if (command == STRING_DATA) {
sendSysex(command, strlen(string), (byte *)string);
}
}
/**
* Send a string to the Firmata host application.
* @param string A pointer to the char string
*/
void FirmataClass::sendString(const char *string)
{
sendString(STRING_DATA, string);
}
/**
* A wrapper for Stream::available().
* Write a single byte to the output stream.
* @param c The byte to be written.
*/
void FirmataClass::write(byte c)
{
FirmataStream->write(c);
}
/**
* Attach a generic sysex callback function to a command (options are: ANALOG_MESSAGE,
* DIGITAL_MESSAGE, REPORT_ANALOG, REPORT DIGITAL, SET_PIN_MODE and SET_DIGITAL_PIN_VALUE).
* @param command The ID of the command to attach a callback function to.
* @param newFunction A reference to the callback function to attach.
*/
void FirmataClass::attach(byte command, callbackFunction newFunction)
{
switch (command) {
case ANALOG_MESSAGE: currentAnalogCallback = newFunction; break;
case DIGITAL_MESSAGE: currentDigitalCallback = newFunction; break;
case REPORT_ANALOG: currentReportAnalogCallback = newFunction; break;
case REPORT_DIGITAL: currentReportDigitalCallback = newFunction; break;
case SET_PIN_MODE: currentPinModeCallback = newFunction; break;
case SET_DIGITAL_PIN_VALUE: currentPinValueCallback = newFunction; break;
}
}
/**
* Attach a callback function for the SYSTEM_RESET command.
* @param command Must be set to SYSTEM_RESET or it will be ignored.
* @param newFunction A reference to the system reset callback function to attach.
*/
void FirmataClass::attach(byte command, systemResetCallbackFunction newFunction)
{
switch (command) {
case SYSTEM_RESET: currentSystemResetCallback = newFunction; break;
}
}
/**
* Attach a callback function for the STRING_DATA command.
* @param command Must be set to STRING_DATA or it will be ignored.
* @param newFunction A reference to the string callback function to attach.
*/
void FirmataClass::attach(byte command, stringCallbackFunction newFunction)
{
switch (command) {
case STRING_DATA: currentStringCallback = newFunction; break;
}
}
/**
* Attach a generic sysex callback function to sysex command.
* @param command The ID of the command to attach a callback function to.
* @param newFunction A reference to the sysex callback function to attach.
*/
void FirmataClass::attach(byte command, sysexCallbackFunction newFunction)
{
currentSysexCallback = newFunction;
}
/**
* Detach a callback function for a specified command (such as SYSTEM_RESET, STRING_DATA,
* ANALOG_MESSAGE, DIGITAL_MESSAGE, etc).
* @param command The ID of the command to detatch the callback function from.
*/
void FirmataClass::detach(byte command)
{
switch (command) {
case SYSTEM_RESET: currentSystemResetCallback = NULL; break;
case STRING_DATA: currentStringCallback = NULL; break;
case START_SYSEX: currentSysexCallback = NULL; break;
default:
attach(command, (callbackFunction)NULL);
}
}
/**
* @param pin The pin to get the configuration of.
* @return The configuration of the specified pin.
*/
byte FirmataClass::getPinMode(byte pin)
{
return pinConfig[pin];
}
/**
* Set the pin mode/configuration. The pin configuration (or mode) in Firmata represents the
* current function of the pin. Examples are digital input or output, analog input, pwm, i2c,
* serial (uart), etc.
* @param pin The pin to configure.
* @param config The configuration value for the specified pin.
*/
void FirmataClass::setPinMode(byte pin, byte config)
{
if (pinConfig[pin] == PIN_MODE_IGNORE)
return;
pinConfig[pin] = config;
}
/**
* @param pin The pin to get the state of.
* @return The state of the specified pin.
*/
int FirmataClass::getPinState(byte pin)
{
return pinState[pin];
}
/**
* Set the pin state. The pin state of an output pin is the pin value. The state of an
* input pin is 0, unless the pin has it's internal pull up resistor enabled, then the value is 1.
* @param pin The pin to set the state of
* @param state Set the state of the specified pin
*/
void FirmataClass::setPinState(byte pin, int state)
{
pinState[pin] = state;
}
// sysex callbacks
/*
* this is too complicated for analogReceive, but maybe for Sysex?
void FirmataClass::attachSysex(sysexFunction newFunction)
{
byte i;
byte tmpCount = analogReceiveFunctionCount;
analogReceiveFunction* tmpArray = analogReceiveFunctionArray;
analogReceiveFunctionCount++;
analogReceiveFunctionArray = (analogReceiveFunction*) calloc(analogReceiveFunctionCount, sizeof(analogReceiveFunction));
for(i = 0; i < tmpCount; i++) {
analogReceiveFunctionArray[i] = tmpArray[i];
}
analogReceiveFunctionArray[tmpCount] = newFunction;
free(tmpArray);
}
*/
//******************************************************************************
//* Private Methods
//******************************************************************************
/**
* Resets the system state upon a SYSTEM_RESET message from the host software.
* @private
*/
void FirmataClass::systemReset(void)
{
byte i;
waitForData = 0; // this flag says the next serial input will be data
executeMultiByteCommand = 0; // execute this after getting multi-byte data
multiByteChannel = 0; // channel data for multiByteCommands
for (i = 0; i < MAX_DATA_BYTES; i++) {
storedInputData[i] = 0;
}
parsingSysex = false;
sysexBytesRead = 0;
if (currentSystemResetCallback)
(*currentSystemResetCallback)();
}
/**
* Flashing the pin for the version number
* @private
* @param pin The pin the LED is attached to.
* @param count The number of times to flash the LED.
* @param onInterval The number of milliseconds for the LED to be ON during each interval.
* @param offInterval The number of milliseconds for the LED to be OFF during each interval.
*/
void FirmataClass::strobeBlinkPin(byte pin, int count, int onInterval, int offInterval)
{
byte i;
for (i = 0; i < count; i++) {
delay(offInterval);
digitalWrite(pin, HIGH);
delay(onInterval);
digitalWrite(pin, LOW);
}
}
// make one instance for the user to use
FirmataClass Firmata;

224
arduino-cli/libraries/Adafruit_Circuit_Playground/utility/CP_Firmata.h Normal file
View File

@@ -0,0 +1,224 @@
/*
Firmata.h - Firmata library v2.5.3 - 2016-06-18
Copyright (c) 2006-2008 Hans-Christoph Steiner. All rights reserved.
Copyright (C) 2009-2015 Jeff Hoefs. All rights reserved.
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.
See file LICENSE.txt for further informations on licensing terms.
*/
#ifndef Firmata_h
#define Firmata_h
#include "CP_Boards.h" /* Hardware Abstraction Layer + Wiring/Arduino */
/* Version numbers for the protocol. The protocol is still changing, so these
* version numbers are important.
* Query using the REPORT_VERSION message.
*/
#define FIRMATA_PROTOCOL_MAJOR_VERSION 2 // for non-compatible changes
#define FIRMATA_PROTOCOL_MINOR_VERSION 5 // for backwards compatible changes
#define FIRMATA_PROTOCOL_BUGFIX_VERSION 1 // for bugfix releases
/* Version numbers for the Firmata library.
* The firmware version will not always equal the protocol version going forward.
* Query using the REPORT_FIRMWARE message.
*/
#define FIRMATA_FIRMWARE_MAJOR_VERSION 2
#define FIRMATA_FIRMWARE_MINOR_VERSION 5
#define FIRMATA_FIRMWARE_BUGFIX_VERSION 3
/* DEPRECATED as of Firmata v2.5.1. As of 2.5.1 there are separate version numbers for
* the protocol version and the firmware version.
*/
#define FIRMATA_MAJOR_VERSION 2 // same as FIRMATA_PROTOCOL_MAJOR_VERSION
#define FIRMATA_MINOR_VERSION 5 // same as FIRMATA_PROTOCOL_MINOR_VERSION
#define FIRMATA_BUGFIX_VERSION 1 // same as FIRMATA_PROTOCOL_BUGFIX_VERSION
#define MAX_DATA_BYTES 64 // max number of data bytes in incoming messages
// Arduino 101 also defines SET_PIN_MODE as a macro in scss_registers.h
#ifdef SET_PIN_MODE
#undef SET_PIN_MODE
#endif
// message command bytes (128-255/0x80-0xFF)
#define DIGITAL_MESSAGE 0x90 // send data for a digital port (collection of 8 pins)
#define ANALOG_MESSAGE 0xE0 // send data for an analog pin (or PWM)
#define REPORT_ANALOG 0xC0 // enable analog input by pin #
#define REPORT_DIGITAL 0xD0 // enable digital input by port pair
//
#define SET_PIN_MODE 0xF4 // set a pin to INPUT/OUTPUT/PWM/etc
#define SET_DIGITAL_PIN_VALUE 0xF5 // set value of an individual digital pin
//
#define REPORT_VERSION 0xF9 // report protocol version
#define SYSTEM_RESET 0xFF // reset from MIDI
//
#define START_SYSEX 0xF0 // start a MIDI Sysex message
#define END_SYSEX 0xF7 // end a MIDI Sysex message
// extended command set using sysex (0-127/0x00-0x7F)
/* 0x00-0x0F reserved for user-defined commands */
#define SERIAL_MESSAGE 0x60 // communicate with serial devices, including other boards
#define ENCODER_DATA 0x61 // reply with encoders current positions
#define SERVO_CONFIG 0x70 // set max angle, minPulse, maxPulse, freq
#define STRING_DATA 0x71 // a string message with 14-bits per char
#define STEPPER_DATA 0x72 // control a stepper motor
#define ONEWIRE_DATA 0x73 // send an OneWire read/write/reset/select/skip/search request
#define SHIFT_DATA 0x75 // a bitstream to/from a shift register
#define I2C_REQUEST 0x76 // send an I2C read/write request
#define I2C_REPLY 0x77 // a reply to an I2C read request
#define I2C_CONFIG 0x78 // config I2C settings such as delay times and power pins
#define EXTENDED_ANALOG 0x6F // analog write (PWM, Servo, etc) to any pin
#define PIN_STATE_QUERY 0x6D // ask for a pin's current mode and value
#define PIN_STATE_RESPONSE 0x6E // reply with pin's current mode and value
#define CAPABILITY_QUERY 0x6B // ask for supported modes and resolution of all pins
#define CAPABILITY_RESPONSE 0x6C // reply with supported modes and resolution
#define ANALOG_MAPPING_QUERY 0x69 // ask for mapping of analog to pin numbers
#define ANALOG_MAPPING_RESPONSE 0x6A // reply with mapping info
#define REPORT_FIRMWARE 0x79 // report name and version of the firmware
#define SAMPLING_INTERVAL 0x7A // set the poll rate of the main loop
#define SCHEDULER_DATA 0x7B // send a createtask/deletetask/addtotask/schedule/querytasks/querytask request to the scheduler
#define SYSEX_NON_REALTIME 0x7E // MIDI Reserved for non-realtime messages
#define SYSEX_REALTIME 0x7F // MIDI Reserved for realtime messages
// these are DEPRECATED to make the naming more consistent
#define FIRMATA_STRING 0x71 // same as STRING_DATA
#define SYSEX_I2C_REQUEST 0x76 // same as I2C_REQUEST
#define SYSEX_I2C_REPLY 0x77 // same as I2C_REPLY
#define SYSEX_SAMPLING_INTERVAL 0x7A // same as SAMPLING_INTERVAL
// pin modes
//#define INPUT 0x00 // defined in Arduino.h
//#define OUTPUT 0x01 // defined in Arduino.h
#define PIN_MODE_ANALOG 0x02 // analog pin in analogInput mode
#define PIN_MODE_PWM 0x03 // digital pin in PWM output mode
#define PIN_MODE_SERVO 0x04 // digital pin in Servo output mode
#define PIN_MODE_SHIFT 0x05 // shiftIn/shiftOut mode
#define PIN_MODE_I2C 0x06 // pin included in I2C setup
#define PIN_MODE_ONEWIRE 0x07 // pin configured for 1-wire
#define PIN_MODE_STEPPER 0x08 // pin configured for stepper motor
#define PIN_MODE_ENCODER 0x09 // pin configured for rotary encoders
#define PIN_MODE_SERIAL 0x0A // pin configured for serial communication
#define PIN_MODE_PULLUP 0x0B // enable internal pull-up resistor for pin
#define PIN_MODE_IGNORE 0x7F // pin configured to be ignored by digitalWrite and capabilityResponse
#define TOTAL_PIN_MODES 13
// DEPRECATED as of Firmata v2.5
#define ANALOG 0x02 // same as PIN_MODE_ANALOG
#define PWM 0x03 // same as PIN_MODE_PWM
#define SERVO 0x04 // same as PIN_MODE_SERVO
#define SHIFT 0x05 // same as PIN_MODE_SHIFT
#define I2C 0x06 // same as PIN_MODE_I2C
#define ONEWIRE 0x07 // same as PIN_MODE_ONEWIRE
#define STEPPER 0x08 // same as PIN_MODE_STEPPER
#define ENCODER 0x09 // same as PIN_MODE_ENCODER
#define IGNORE 0x7F // same as PIN_MODE_IGNORE
extern "C" {
// callback function types
typedef void (*callbackFunction)(byte, int);
typedef void (*systemResetCallbackFunction)(void);
typedef void (*stringCallbackFunction)(char *);
typedef void (*sysexCallbackFunction)(byte command, byte argc, byte *argv);
}
// TODO make it a subclass of a generic Serial/Stream base class
class FirmataClass
{
public:
FirmataClass();
/* Arduino constructors */
void begin();
void begin(long);
void begin(Stream &s);
/* querying functions */
void printVersion(void);
void blinkVersion(void);
void printFirmwareVersion(void);
//void setFirmwareVersion(byte major, byte minor); // see macro below
void setFirmwareNameAndVersion(const char *name, byte major, byte minor);
void disableBlinkVersion();
/* serial receive handling */
int available(void);
void processInput(void);
void parse(unsigned char value);
boolean isParsingMessage(void);
/* serial send handling */
void sendAnalog(byte pin, int value);
void sendDigital(byte pin, int value); // TODO implement this
void sendDigitalPort(byte portNumber, int portData);
void sendString(const char *string);
void sendString(byte command, const char *string);
void sendSysex(byte command, byte bytec, byte *bytev);
void write(byte c);
/* attach & detach callback functions to messages */
void attach(byte command, callbackFunction newFunction);
void attach(byte command, systemResetCallbackFunction newFunction);
void attach(byte command, stringCallbackFunction newFunction);
void attach(byte command, sysexCallbackFunction newFunction);
void detach(byte command);
/* access pin state and config */
byte getPinMode(byte pin);
void setPinMode(byte pin, byte config);
/* access pin state */
int getPinState(byte pin);
void setPinState(byte pin, int state);
/* utility methods */
void sendValueAsTwo7bitBytes(int value);
void startSysex(void);
void endSysex(void);
private:
Stream *FirmataStream;
/* firmware name and version */
byte firmwareVersionCount;
byte *firmwareVersionVector;
/* input message handling */
byte waitForData; // this flag says the next serial input will be data
byte executeMultiByteCommand; // execute this after getting multi-byte data
byte multiByteChannel; // channel data for multiByteCommands
byte storedInputData[MAX_DATA_BYTES]; // multi-byte data
/* sysex */
boolean parsingSysex;
int sysexBytesRead;
/* pin configuration */
byte pinConfig[TOTAL_PINS];
int pinState[TOTAL_PINS];
/* callback functions */
callbackFunction currentAnalogCallback;
callbackFunction currentDigitalCallback;
callbackFunction currentReportAnalogCallback;
callbackFunction currentReportDigitalCallback;
callbackFunction currentPinModeCallback;
callbackFunction currentPinValueCallback;
systemResetCallbackFunction currentSystemResetCallback;
stringCallbackFunction currentStringCallback;
sysexCallbackFunction currentSysexCallback;
boolean blinkVersionDisabled;
/* private methods ------------------------------ */
void processSysexMessage(void);
void systemReset(void);
void strobeBlinkPin(byte pin, int count, int onInterval, int offInterval);
};
extern FirmataClass Firmata;
/*==============================================================================
* MACROS
*============================================================================*/
/* shortcut for setFirmwareNameAndVersion() that uses __FILE__ to set the
* firmware name. It needs to be a macro so that __FILE__ is included in the
* firmware source file rather than the library source file.
*/
#define setFirmwareVersion(x, y) setFirmwareNameAndVersion(__FILE__, x, y)
#endif /* Firmata_h */

247
arduino-cli/libraries/Adafruit_Circuit_Playground/utility/CPlay_CapacitiveSensor.cpp Normal file
View File

@@ -0,0 +1,247 @@
/*
CapacitiveSense.h v.04 - Capacitive Sensing Library for 'duino / Wiring
https://github.com/PaulStoffregen/CapacitiveSensor
http://www.pjrc.com/teensy/td_libs_CapacitiveSensor.html
http://playground.arduino.cc/Main/CapacitiveSensor
Copyright (c) 2009 Paul Bagder All right reserved.
Version 05 by Paul Stoffregen - Support non-AVR board: Teensy 3.x, Arduino Due
Version 04 by Paul Stoffregen - Arduino 1.0 compatibility, issue 146 fix
vim: set ts=4:
*/
#if ARDUINO >= 100
#include "Arduino.h"
#else
#include "WProgram.h"
#include "pins_arduino.h"
#include "WConstants.h"
#endif
#include "CPlay_CapacitiveSensor.h"
/**************************************************************************/
/*!
@brief Function that handles the creation and setup of instances
@param sendPin send pin for the sensor
@param receivePin the receiving pin for the sensor
*/
/**************************************************************************/
CPlay_CapacitiveSensor::CPlay_CapacitiveSensor(uint8_t sendPin, uint8_t receivePin)
{
// initialize this instance's variables
error = 1;
loopTimingFactor = 300; // determined empirically - a hack
CS_Timeout_Millis = (2000 * (float)loopTimingFactor * (float)F_CPU) / 16000000;
CS_AutocaL_Millis = 20000;
_sendPin = sendPin;
_receivePin = receivePin;
// Serial.print("timeOut = ");
// Serial.println(CS_Timeout_Millis);
// get pin mapping and port for send Pin - from PinMode function in core
#ifdef NUM_DIGITAL_PINS
if ((sendPin != 255) && (sendPin >= NUM_DIGITAL_PINS)) error = -3;
if (receivePin >= NUM_DIGITAL_PINS) error = -2;
#endif
if (sendPin != -1) { // sendpin to OUTPUT if we have one
#ifdef ARDUINO_TEEONARDU_FLORA // terrible hack!
DDRD |= _BV(5);
#else
pinMode(sendPin, OUTPUT);
#endif
}
pinMode(receivePin, INPUT); // receivePin to INPUT
#ifdef ARDUINO_TEEONARDU_FLORA
// terrible hack!
PORTD &= ~_BV(5);
#else
digitalWrite(sendPin, LOW);
#endif
if (sendPin != -1) {
send_outport = portOutputRegister(digitalPinToPort(sendPin));
send_mask = digitalPinToBitMask(sendPin);
} else {
send_outport = NULL;
send_mask = 0;
}
recv_outport = portOutputRegister(digitalPinToPort(receivePin));
recv_inport = portInputRegister(digitalPinToPort(receivePin));
recv_mask = digitalPinToBitMask(receivePin);
recv_direction = portModeRegister(digitalPinToPort(receivePin));
// get pin mapping and port for receive Pin - from digital pin functions in Wiring.c
leastTotal = 0x0FFFFFFFL; // input large value for autocalibrate begin
lastCal = millis(); // set millis for start
}
// Public Methods //////////////////////////////////////////////////////////////
// Functions available in Wiring sketches, this library, and other libraries
/**************************************************************************/
/*!
@brief get a capacitive sensor reading
@param samples number of samples to take
@return the sensor reading
*/
/**************************************************************************/
long CPlay_CapacitiveSensor::capacitiveSensor(uint8_t samples)
{
total = 0;
if (samples == 0) return 0;
if (error < 0) {
return -1; // bad pin
}
pinMode(_receivePin, INPUT);
for (uint8_t i = 0; i < samples; i++) { // loop for samples parameter - simple lowpass filter
if (SenseOneCycle() < 0) return -2; // variable over timeout
}
// only calibrate if time is greater than CS_AutocaL_Millis and total is less than 10% of baseline
// this is an attempt to keep from calibrating when the sensor is seeing a "touched" signal
if ( (millis() - lastCal > CS_AutocaL_Millis) &&
abs(total - leastTotal) < (int)(.10 * (float)leastTotal) ) {
// Serial.println(); // debugging
// Serial.println("auto-calibrate");
// Serial.println();
// delay(2000); */
leastTotal = 0x0FFFFFFFL; // reset for "autocalibrate"
lastCal = millis();
}
/*else{ // debugging
Serial.print(" total = ");
Serial.print(total);
Serial.print(" leastTotal = ");
Serial.println(leastTotal);
Serial.print("total - leastTotal = ");
x = total - leastTotal ;
Serial.print(x);
Serial.print(" .1 * leastTotal = ");
x = (int)(.1 * (float)leastTotal);
Serial.println(x);
} */
// routine to subtract baseline (non-sensed capacitance) from sensor return
if (total < leastTotal) leastTotal = total; // set floor value to subtract from sensed value
return(total - leastTotal);
}
/**************************************************************************/
/*!
@brief get a raw sensor reading
@param samples the number of samples to take
@return -1 for error, -2 for timeout, other values are a raw sensor reading
*/
/**************************************************************************/
long CPlay_CapacitiveSensor::capacitiveSensorRaw(uint8_t samples)
{
total = 0;
if (samples == 0) return 0;
if (error < 0) return -1; // bad pin - this appears not to work
for (uint8_t i = 0; i < samples; i++) { // loop for samples parameter - simple lowpass filter
if (SenseOneCycle() < 0) return -2; // variable over timeout
}
return total;
}
/**************************************************************************/
/*!
@brief reset the auto calibration
*/
/**************************************************************************/
void CPlay_CapacitiveSensor::reset_CS_AutoCal(void){
leastTotal = 0x0FFFFFFFL;
}
/**************************************************************************/
/*!
@brief set the auto-calibration time
@param autoCal_millis the desired calibration time in milliseconds
*/
/**************************************************************************/
void CPlay_CapacitiveSensor::set_CS_AutocaL_Millis(unsigned long autoCal_millis){
CS_AutocaL_Millis = autoCal_millis;
}
/**************************************************************************/
/*!
@brief set the sensor timeout
@param timeout_millis the number of milliseconds to set the timeout to
*/
/**************************************************************************/
void CPlay_CapacitiveSensor::set_CS_Timeout_Millis(unsigned long timeout_millis){
CS_Timeout_Millis = (timeout_millis * (float)loopTimingFactor * (float)F_CPU) / 16000000; // floats to deal with large numbers
}
// Private Methods /////////////////////////////////////////////////////////////
// Functions only available to other functions in this library
/**************************************************************************/
/*!
@brief sense a single sicle
@return the reading
*/
/**************************************************************************/
int CPlay_CapacitiveSensor::SenseOneCycle(void)
{
if (send_mask != 0) {
noInterrupts();
*send_outport &= ~send_mask; // sendPin Register low
*recv_direction &= ~recv_mask; // receivePin to input (pullups are off)
*recv_direction |= recv_mask; // receivePin to OUTPUT
*recv_outport &= ~recv_mask; // pin is now LOW AND OUTPUT
delayMicroseconds(10);
*recv_direction &= ~recv_mask; // receivePin to input (pullups are off)
*send_outport |= send_mask; // sendPin Register high
interrupts();
while ( !(*recv_inport & recv_mask) && (total < CS_Timeout_Millis) ) { // while receive pin is LOW AND total is positive value
total++;
}
//Serial.print("SenseOneCycle(1): "); Serial.println(total);
if (total > CS_Timeout_Millis) {
return -2; // total variable over timeout
}
}
// set receive pin HIGH briefly to charge up fully - because the while loop above will exit when pin is ~ 2.5V
noInterrupts();
*send_outport &= ~send_mask; // sendPin Register low
*recv_direction |= recv_mask; // receivePin to OUTPUT
*recv_outport |= recv_mask; // pin is now HIGH AND OUTPUT
delayMicroseconds(10);
*recv_direction &= ~recv_mask; // receivePin to input (pullups are off)
*recv_outport &= ~recv_mask;
if (send_mask != 0) {
*send_outport &= ~send_mask; // sendPin Register high
}
interrupts();
while ((*recv_inport & recv_mask) && (total < CS_Timeout_Millis) ) {
total++; // while receive pin is HIGH AND total is less than timeout
}
//Serial.print("SenseOneCycle(2): "); Serial.println(total);
if (total >= CS_Timeout_Millis) {
return -2; // total variable over timeout
} else {
return 1;
}
}

63
arduino-cli/libraries/Adafruit_Circuit_Playground/utility/CPlay_CapacitiveSensor.h Normal file
View File

@@ -0,0 +1,63 @@
/*
CapacitiveSense.h v.04 - Capacitive Sensing Library for 'duino / Wiring
https://github.com/PaulStoffregen/CapacitiveSensor
http://www.pjrc.com/teensy/td_libs_CapacitiveSensor.html
http://playground.arduino.cc/Main/CapacitiveSensor
Copyright (c) 2008 Paul Bagder All rights reserved.
Version 05 by Paul Stoffregen - Support non-AVR board: Teensy 3.x, Arduino Due
Version 04 by Paul Stoffregen - Arduino 1.0 compatibility, issue 146 fix
vim: set ts=4:
*/
// ensure this library description is only included once
#ifndef CapacitiveSensor_h
#define CapacitiveSensor_h
#if ARDUINO >= 100
#include "Arduino.h"
#else
#include "WProgram.h"
#endif
#if defined(ARDUINO_NRF52840_CIRCUITPLAY)
#define RwReg uint32_t
#elif defined(__AVR__)
#define RwReg uint8_t
#endif
/**************************************************************************/
/*!
@brief Class that stores state and functions for the capacitive sensor on CircuitPlayground boards
*/
/**************************************************************************/
class CPlay_CapacitiveSensor
{
// user-accessible "public" interface
public:
// methods
CPlay_CapacitiveSensor(uint8_t sendPin = 0, uint8_t receivePin = 0);
long capacitiveSensorRaw(uint8_t samples);
long capacitiveSensor(uint8_t samples);
void set_CS_Timeout_Millis(unsigned long timeout_millis);
void reset_CS_AutoCal();
void set_CS_AutocaL_Millis(unsigned long autoCal_millis);
// library-accessible "private" interface
private:
// variables
int error;
unsigned long leastTotal;
unsigned int loopTimingFactor;
unsigned long CS_Timeout_Millis;
unsigned long CS_AutocaL_Millis;
unsigned long lastCal;
unsigned long total;
uint8_t _sendPin, _receivePin;
volatile RwReg *send_outport, *recv_outport, *recv_inport, *recv_direction;
RwReg send_mask, recv_mask;
// methods
int SenseOneCycle(void);
};
#endif

30
arduino-cli/libraries/Adafruit_Circuit_Playground/utility/IRLibCPE.h Normal file
View File

@@ -0,0 +1,30 @@
/* IRLibCPE.h
* Part of IRLib Library for Arduino receiving, decoding, and sending
* infrared signals. See COPYRIGHT.txt and LICENSE.txt for more information.
*/
/*
* Combines all of the necessary libraries for implementing IR transmit and receive
* on the Adafruit Circuit Playground Express. Similar to the IRLibAll.h in the
* regular IRLib2.xx.
*/
#ifndef IRLIB_CPE_H
#define IRLIB_CPE_H
#include "IRLibDecodeBase.h"
#include "IRLibSendBase.h"
#include "IRLib_P01_NEC.h"
#include "IRLib_P02_Sony.h"
#include "IRLib_P03_RC5.h"
#include "IRLib_P04_RC6.h"
#include "IRLib_P05_Panasonic_Old.h"
#include "IRLib_P06_JVC.h"
#include "IRLib_P07_NECx.h"
#include "IRLib_P08_Samsung36.h"
#include "IRLib_P09_GICable.h"
#include "IRLib_P10_DirecTV.h"
#include "IRLib_P11_RCMM.h"
#include "IRLib_P12_CYKM.h"
//include additional protocols here
#include "IRLibCombo.h"
#include "IRLibRecvPCI.h"
#endif //IRLIB_CPE_H

251
arduino-cli/libraries/Adafruit_Circuit_Playground/utility/IRLibCombo.h Normal file
View File

@@ -0,0 +1,251 @@
/* IRLibCombo.h
* Part of IRLib Library for Arduino receiving, decoding, and sending
* infrared signals. See COPYRIGHT.txt and LICENSE.txt for more information.
*/
/*
* This file is for creating a customer decode or send class which contains only
* the protocols that you will actually use. At the top of your sketch you should
* include the Send and/or Decode base modules followed by at least one or more
* protocol module. Then conclude with this module.
* WARNING: The lowest numbered protocol which you are using MUST be included first.
* The remaining protocol modules technically could be in any order however we
* recommend that you maintain numerical order because you might at some point
* comment out the top one and then the lowest would not be first causing an error.
*
* Here is an example...
*
* #include <IRLibSendBase.h> //Only include if you are sending
* #include <IRLibDecodeBase.h> //Only include if you are decoding
* #include <IRLib_Pxx_protocol_name.h> //Include at least one protocol
* #include <IRLib_Pxx_another_name.h> //Include as many as you want
* #include <IRLibCombo.h> //Include this file
* IRdecode My_Decoder; //declare an instance of the decoder if needed
* IRsend My_Sender; //declarative sense of the sending routine if needed
* //The rest of your code goes here
*/
#ifndef IRLIB_COMBO_H
#define IRLIB_COMBO_H
#ifndef IRLIB_HASHRAW_H
#define IR_SEND_RAW
#define IR_DECODE_HASH
#define PV_IR_DECODE_HASH
#define PV_IR_SEND_RAW
#endif
#ifndef IRLIB_PROTOCOL_01_H
#define IR_SEND_PROTOCOL_01
#define IR_DECODE_PROTOCOL_01
#define PV_IR_DECODE_PROTOCOL_01
#define PV_IR_SEND_PROTOCOL_01
#endif
#ifndef IRLIB_PROTOCOL_02_H
#define IR_SEND_PROTOCOL_02
#define IR_DECODE_PROTOCOL_02
#define PV_IR_DECODE_PROTOCOL_02
#define PV_IR_SEND_PROTOCOL_02
#endif
#ifndef IRLIB_PROTOCOL_03_H
#define IR_SEND_PROTOCOL_03
#define IR_DECODE_PROTOCOL_03
#define PV_IR_DECODE_PROTOCOL_03
#define PV_IR_SEND_PROTOCOL_03
#endif
#ifndef IRLIB_PROTOCOL_04_H
#define IR_SEND_PROTOCOL_04
#define IR_DECODE_PROTOCOL_04
#define PV_IR_DECODE_PROTOCOL_04
#define PV_IR_SEND_PROTOCOL_04
#endif
#ifndef IRLIB_PROTOCOL_05_H
#define IR_SEND_PROTOCOL_05
#define IR_DECODE_PROTOCOL_05
#define PV_IR_DECODE_PROTOCOL_05
#define PV_IR_SEND_PROTOCOL_05
#endif
#ifndef IRLIB_PROTOCOL_06_H
#define IR_SEND_PROTOCOL_06
#define IR_DECODE_PROTOCOL_06
#define PV_IR_DECODE_PROTOCOL_06
#define PV_IR_SEND_PROTOCOL_06
#endif
#ifndef IRLIB_PROTOCOL_07_H
#define IR_SEND_PROTOCOL_07
#define IR_DECODE_PROTOCOL_07
#define PV_IR_DECODE_PROTOCOL_07
#define PV_IR_SEND_PROTOCOL_07
#endif
#ifndef IRLIB_PROTOCOL_08_H
#define IR_SEND_PROTOCOL_08
#define IR_DECODE_PROTOCOL_08
#define PV_IR_DECODE_PROTOCOL_08
#define PV_IR_SEND_PROTOCOL_08
#endif
#ifndef IRLIB_PROTOCOL_09_H
#define IR_SEND_PROTOCOL_09
#define IR_DECODE_PROTOCOL_09
#define PV_IR_DECODE_PROTOCOL_09
#define PV_IR_SEND_PROTOCOL_09
#endif
#ifndef IRLIB_PROTOCOL_10_H
#define IR_SEND_PROTOCOL_10
#define IR_DECODE_PROTOCOL_10
#define PV_IR_DECODE_PROTOCOL_10
#define PV_IR_SEND_PROTOCOL_10
#endif
#ifndef IRLIB_PROTOCOL_11_H
#define IR_SEND_PROTOCOL_11
#define IR_DECODE_PROTOCOL_11
#define PV_IR_DECODE_PROTOCOL_11
#define PV_IR_SEND_PROTOCOL_11
#endif
#ifndef IRLIB_PROTOCOL_12_H
#define IR_SEND_PROTOCOL_12
#define IR_DECODE_PROTOCOL_12
#define PV_IR_DECODE_PROTOCOL_12
#define PV_IR_SEND_PROTOCOL_12
#endif
#ifndef IRLIB_PROTOCOL_13_H
#define IR_SEND_PROTOCOL_13
#define IR_DECODE_PROTOCOL_13
#define PV_IR_DECODE_PROTOCOL_13
#define PV_IR_SEND_PROTOCOL_13
#endif
#ifndef IRLIB_PROTOCOL_14_H
#define IR_SEND_PROTOCOL_14
#define IR_DECODE_PROTOCOL_14
#define PV_IR_DECODE_PROTOCOL_14
#define PV_IR_SEND_PROTOCOL_14
#endif
//Add additional protocols 15, 16, etc. above.
//Note protocol 90- 99 for sample code that will be unsupported in the final version.
//See IRLibProtocols/unsupported/IRLib_P90_Unsupported.h for details
#ifndef IRLIB_PROTOCOL_90_H
#define IR_SEND_PROTOCOL_90
#define IR_DECODE_PROTOCOL_90
#define PV_IR_DECODE_PROTOCOL_90
#define PV_IR_SEND_PROTOCOL_90
#endif
#ifndef IRLIB_PROTOCOL_91_H
#define IR_SEND_PROTOCOL_91
#define IR_DECODE_PROTOCOL_91
#define PV_IR_DECODE_PROTOCOL_91
#define PV_IR_SEND_PROTOCOL_91
#endif
#ifndef IRLIB_PROTOCOL_92_H
#define IR_SEND_PROTOCOL_92
#define IR_DECODE_PROTOCOL_92
#define PV_IR_DECODE_PROTOCOL_92
#define PV_IR_SEND_PROTOCOL_92
#endif
/*
* You may add additional protocols by copying and modifying the previous six lines.
* You must also add appropriate macros in each segment below. Be sure to maintain
* numerical order. Also the final entry in each list MUST BE the Hash_Raw version.
*/
#ifdef IRLIBDECODEBASE_H
class IRdecode:
PV_IR_DECODE_PROTOCOL_01
PV_IR_DECODE_PROTOCOL_02
PV_IR_DECODE_PROTOCOL_03
PV_IR_DECODE_PROTOCOL_04
PV_IR_DECODE_PROTOCOL_05
PV_IR_DECODE_PROTOCOL_06
PV_IR_DECODE_PROTOCOL_07
PV_IR_DECODE_PROTOCOL_08
PV_IR_DECODE_PROTOCOL_09
PV_IR_DECODE_PROTOCOL_10
PV_IR_DECODE_PROTOCOL_11
PV_IR_DECODE_PROTOCOL_12
PV_IR_DECODE_PROTOCOL_13
PV_IR_DECODE_PROTOCOL_14
PV_IR_DECODE_PROTOCOL_90 //Add additional 15, 16 etc. above this
PV_IR_DECODE_PROTOCOL_91
PV_IR_DECODE_PROTOCOL_92
PV_IR_DECODE_HASH //Must be last one.
{
public:
bool decode(void) {
IR_DECODE_PROTOCOL_01
IR_DECODE_PROTOCOL_02
IR_DECODE_PROTOCOL_03
IR_DECODE_PROTOCOL_04
IR_DECODE_PROTOCOL_05
IR_DECODE_PROTOCOL_06
IR_DECODE_PROTOCOL_07
IR_DECODE_PROTOCOL_08
IR_DECODE_PROTOCOL_09
IR_DECODE_PROTOCOL_10
IR_DECODE_PROTOCOL_11
IR_DECODE_PROTOCOL_12
IR_DECODE_PROTOCOL_13
IR_DECODE_PROTOCOL_14
IR_DECODE_PROTOCOL_90 //Add additional 15, 16 etc. above this
IR_DECODE_PROTOCOL_91
IR_DECODE_PROTOCOL_92
IR_DECODE_HASH //Must be last one.
return false;
};
#ifdef IRLIB_PROTOCOL_12_H
void dumpResults(bool verbose=true) {
if(protocolNum==12) {
IRdecodeCYKM::dumpResults();
if(verbose)IRdecodeBase::dumpResults(true);
} else {
IRdecodeBase::dumpResults(verbose);
}
}
#endif
};
#endif //IRLIBDECODEBASE_H
#ifdef IRLIBSENDBASE_H
class IRsend:
PV_IR_SEND_PROTOCOL_01
PV_IR_SEND_PROTOCOL_02
PV_IR_SEND_PROTOCOL_03
PV_IR_SEND_PROTOCOL_04
PV_IR_SEND_PROTOCOL_05
PV_IR_SEND_PROTOCOL_06
PV_IR_SEND_PROTOCOL_07
PV_IR_SEND_PROTOCOL_08
PV_IR_SEND_PROTOCOL_09
PV_IR_SEND_PROTOCOL_10
PV_IR_SEND_PROTOCOL_11
PV_IR_SEND_PROTOCOL_12
PV_IR_SEND_PROTOCOL_13
PV_IR_SEND_PROTOCOL_14
PV_IR_SEND_PROTOCOL_90 //Add additional 15, 16 etc. above this
PV_IR_SEND_PROTOCOL_91
PV_IR_SEND_PROTOCOL_92
PV_IR_SEND_RAW //Must be last one.
{
public:
void send(uint8_t protocolNum, uint32_t data, uint16_t data2=0, uint8_t khz=38) {
if(khz==0)khz=38;
switch(protocolNum) {
IR_SEND_PROTOCOL_01
IR_SEND_PROTOCOL_02
IR_SEND_PROTOCOL_03
IR_SEND_PROTOCOL_04
IR_SEND_PROTOCOL_05
IR_SEND_PROTOCOL_06
IR_SEND_PROTOCOL_07
IR_SEND_PROTOCOL_08
IR_SEND_PROTOCOL_09
IR_SEND_PROTOCOL_10
IR_SEND_PROTOCOL_11
IR_SEND_PROTOCOL_12
IR_SEND_PROTOCOL_13
IR_SEND_PROTOCOL_14
IR_SEND_PROTOCOL_90 //Add additional 15, 16 etc. above this
IR_SEND_PROTOCOL_91
IR_SEND_PROTOCOL_92
IR_SEND_RAW //Must be last one.
}
}
};
#endif //IRLIBSENDBASE_H
#endif //IRLIB_COMBO_H

187
arduino-cli/libraries/Adafruit_Circuit_Playground/utility/IRLibDecodeBase.cpp Normal file
View File

@@ -0,0 +1,187 @@
/* IRLibDecodeBase.cpp
* Part of IRLib Library for Arduino receiving, decoding, and sending
* infrared signals. See COPYRIGHT.txt and LICENSE.txt for more information.
*/
/*
* This module contains the base classes for decoding. You will not create instances
* of these classes, rather you will use them as base classes in creating derived
* protocol specific decoders.
*/
#if !defined(ARDUINO_NRF52840_CIRCUITPLAY)
#include "IRLibDecodeBase.h"
#include "IRLibHardware.h"
IRdecodeBase::IRdecodeBase(void) {
recvGlobal.decoderWantsData=false; //turned on by enableIRIn.
recvGlobal.decodeBuffer=recvGlobal.recvBuffer;//default buffer
ignoreHeader=false;
resetDecoder();
};
/*
* Reinitialize the decoder clearing out previous data.
*/
void IRdecodeBase::resetDecoder(void) {
protocolNum= UNKNOWN;
value=0;
address=0;
bits=0;
};
void IRdecodeBase::dumpResults(bool verbose) {
int i;uint32_t Extent;int interval;
if((protocolNum>89) || (protocolNum<=LAST_PROTOCOL)) {
Serial.print(F("Decoded ")); Serial.print(Pnames(protocolNum));
Serial.print(F("(")); Serial.print(protocolNum,DEC);
Serial.print(F("): Value:")); Serial.print(value, HEX);
Serial.print(F(" Adrs:" )); Serial.print(address, HEX);
};
Serial.print(F(" (")); Serial.print(bits, DEC); Serial.print(F(" bits) "));
if(recvGlobal.didAutoResume) Serial.print(F("Auto Resumed"));
Serial.println();
if(!verbose)
return;
Serial.print(F("Raw samples(")); Serial.print(recvGlobal.decodeLength, DEC);
Serial.print(F("): Gap:")); Serial.println(recvGlobal.decodeBuffer[0], DEC);
Serial.print(F(" Head: m")); Serial.print(recvGlobal.decodeBuffer[1], DEC);
Serial.print(F(" s")); Serial.println(recvGlobal.decodeBuffer[2], DEC);
int LowSpace= 32767; int LowMark= 32767;
int HiSpace=0; int HiMark= 0;
Extent=recvGlobal.decodeBuffer[1]+recvGlobal.decodeBuffer[2];
for (i = 3; i < recvGlobal.decodeLength; i++) {
Extent+=(interval= recvGlobal.decodeBuffer[i]);
if (i % 2) {
LowMark=min(LowMark, interval); HiMark=max(HiMark, interval);
Serial.print(i/2-1,DEC); Serial.print(F(":m"));
}
else {
if(interval>0)LowSpace=min(LowSpace, interval); HiSpace=max (HiSpace, interval);
Serial.print(F(" s"));
}
Serial.print(interval, DEC);
int j=i-1;
if ((j % 2)==1)Serial.print(F("\t"));
if ((j % 4)==1)Serial.print(F("\t "));
if ((j % 8)==1)Serial.println();
if ((j % 32)==1)Serial.println();
}
Serial.println();
Serial.print(F("Extent=")); Serial.println(Extent,DEC);
Serial.print(F("Mark min:")); Serial.print(LowMark,DEC);Serial.print(F("\t max:")); Serial.println(HiMark,DEC);
Serial.print(F("Space min:")); Serial.print(LowSpace,DEC);Serial.print(F("\t max:")); Serial.println(HiSpace,DEC);
Serial.println();
}
/* We use a generic routine because most protocols have the same basic structure.
* Previous versions of this method would handle protocols with variable marks
* or variable spaces. However we have discovered that only Sony protocol uses
* variable marks so we have stripped out that portion of the code. This changes
* the number of necessary parameters. We no longer need markOne and markZero
* because they are both the same which we will pass in markData. Note this new
* version will handle up to 48 bits putting the most significant 16 bits in
* "this.address" in the least significant 32 bits in "this.data". We could have
* allowed for 64 bit but we have not seen generic protocols that large.
*/
bool IRdecodeBase::decodeGeneric(uint8_t expectedLength,
uint16_t headMark, uint16_t headSpace, uint16_t markData,
uint16_t spaceOne, uint16_t spaceZero) {
resetDecoder();//This used to be in the receiver getResults.
// If "expectedLenght" or "headMark" or "headSpace" are zero or if "ignoreHeader"
// is true then don't perform these tests. This is because some protocols need
// to do their own custom header work.
uint64_t data = 0;
bufIndex_t Max=recvGlobal.decodeLength-1;
if (expectedLength) {
if (recvGlobal.decodeLength != expectedLength) return RAW_COUNT_ERROR;
}
if(!ignoreHeader) {
if (headMark) {
if (!MATCH(recvGlobal.decodeBuffer[1],headMark)) return HEADER_MARK_ERROR(headMark);
}
}
if (headSpace) {
if (!MATCH(recvGlobal.decodeBuffer[2],headSpace)) return HEADER_SPACE_ERROR(headSpace);
}
offset=3;//skip initial gap plus two header items
while (offset < Max) {
if (!MATCH (recvGlobal.decodeBuffer[offset],markData)) return DATA_MARK_ERROR(markData);
offset++;
if (MATCH(recvGlobal.decodeBuffer[offset],spaceOne)) {
data = (data << 1) | 1;
}
else if (MATCH (recvGlobal.decodeBuffer[offset],spaceZero)) {
data <<= 1;
}
else return DATA_SPACE_ERROR(spaceZero);
offset++;
}
bits = (offset - 1) / 2 -1;//didn't encode stop bit
// Success
value = (uint32_t)data; //low order 32 bits
address = (uint16_t) (data>>32); //high order 16 bits
return true;
}
/*
* These MATCH methods used to be macros but we saved nearly
* 800 bytes of program space by making them actual methods.
*/
bool IRdecodeBase::MATCH(int16_t val,int16_t expected){
#ifdef IRLIB_USE_PERCENT
return (val >= (uint16_t)(expected*(1.0-PERCENT_TOLERANCE/100.0)))
&& (val <= (uint16_t)(expected*(1.0+PERCENT_TOLERANCE/100.0)));
#else
return ABS_MATCH(val,expected,DEFAULT_ABS_TOLERANCE);
#endif
}
bool IRdecodeBase::ABS_MATCH(int16_t val,int16_t expected,int16_t tolerance){
return (val >= (expected-tolerance)) && (val <= (expected+tolerance));
}
/*
* The RC5 and RC6 and similar protocols used phase encoding and leave a
* routine to extract zeros and ones. This routine gets one undecoded
* level at a time from the raw buffer. personally The RC5/6 decoding
* is easier if the data is broken into time intervals.
* E.g. if the buffer has MARK for 2 time intervals and SPACE for 1,
* successive calls to getRClevel will return MARK, MARK, SPACE.
* The variables "offset" and "used" are updated to keep track of the
* current position. The variable "t1" is the time interval for a single
* bit in microseconds. Returns ERROR if the measured time interval is
* not a multiple of "t1".
*/
IRdecodeRC::RCLevel IRdecodeRC::getRClevel(uint8_t *used, const uint16_t t1) {
if (offset >= recvGlobal.decodeLength) {
// After end of recorded buffer, assume SPACE.
return SPACE;
}
uint16_t width = recvGlobal.decodeBuffer[offset];
IRdecodeRC::RCLevel val;
if ((offset) % 2) val=MARK; else val=SPACE;
uint8_t avail;
if (MATCH(width, t1)) {
avail = 1;
}
else if (MATCH(width, 2*t1)) {
avail = 2;
}
else if (MATCH(width, 3*t1)) {
avail = 3;
} else {
if((ignoreHeader) && (offset==1) && (width<t1)){
avail =1;
} else {
return ERROR;
}
}
(*used)++;
if (*used >= avail) {
*used = 0;
(offset)++;
}
return val;
}
#endif //!defined(__NRF52)

104
arduino-cli/libraries/Adafruit_Circuit_Playground/utility/IRLibDecodeBase.h Normal file
View File

@@ -0,0 +1,104 @@
/* IRLibDecodeBase.h
* Part of IRLib Library for Arduino receiving, decoding, and sending
* infrared signals. See COPYRIGHT.txt and LICENSE.txt for more information.
*/
/*
* This module contains the base classes for decoding. You will not create instances
* of these classes, rather you will use them as base classes in creating derived
* protocol specific decoders.
*/
#ifndef IRLIBDECODEBASE_H
#define IRLIBDECODEBASE_H
#include "IRLibGlobals.h"
#include "IRLibProtocols.h"
// Base class for decoding raw results
class IRdecodeBase {
public:
IRdecodeBase(void);
uint8_t protocolNum; // NEC, SONY, RC5, UNKNOWN etc.
uint32_t value; // Decoded value
uint16_t address; // Additional data for protocols using more than 32 bits
uint8_t bits; // Number of bits in decoded value
bool ignoreHeader; // Relaxed header detection allows AGC to settle
bool decodeGeneric(uint8_t expectedLength, uint16_t headMark, uint16_t headSpace,
uint16_t markData, uint16_t spaceOne, uint16_t spaceZero);
void dumpResults(bool verbose=true);//full dump of all timing values
bool MATCH(int16_t val,int16_t expected);
bool ABS_MATCH(int16_t val,int16_t expected,int16_t tolerance);
protected:
virtual void resetDecoder(void); // Initializes the decoder
bufIndex_t offset; // Index into decodeBuffer used various places
};
// Base class used by RC5 and RC6 protocols
class IRdecodeRC: public virtual IRdecodeBase {
public:
enum RCLevel {MARK, SPACE, ERROR};//used by decoders for RC5/RC6
RCLevel getRClevel(uint8_t *used, const uint16_t t1);
protected:
uint8_t nBits;
uint8_t used;
uint32_t data;
};
/* The remainder of this file a variety of default values and macros which are
* used internally. They used to be in a separate file IRLibMatch.h but it's easier
* to include them here. You need not worry about them unless you are creating
* your own decoding routines. See the documentation how to implement new protocols
* for a more detailed explanation of these definitions and routines.
*/
/*
* Originally all timing comparisons for decoding were based on a percent of the
* target value. However when target values are relatively large, the percent tolerance
* is too much. In some instances an absolute tolerance is needed. In order to maintain
* backward compatibility, the default will be to continue to use percent. If you wish
* to default to an absolute tolerance, you should comment out the line below.
*/
#define IRLIB_USE_PERCENT
/*
* These are some miscellaneous definitions that are needed by the decoding routines.
* You need not include this file unless you are creating custom decode routines
* which will require these macros and definitions. Even if you include it, you probably
* don't need to be intimately familiar with the internal details.
*/
#define TOPBIT 0x80000000
#define PERCENT_TOLERANCE 25 // percent tolerance in measurements
#define DEFAULT_ABS_TOLERANCE 75 //absolute tolerance in microseconds
/* If you insert #define IRLIB_TRACE in your sketch before including this file,
* various debugging routines will be enabled in the dumpResults() method.
*/
#ifdef IRLIB_TRACE
void IRLIB_ATTEMPT_MESSAGE(const __FlashStringHelper * s) {Serial.print(F("Attempting ")); Serial.print(s); Serial.println(F(" decode:"));};
void IRLIB_TRACE_MESSAGE(const __FlashStringHelper * s) {Serial.print(F("Executing ")); Serial.println(s);};
uint8_t IRLIB_REJECTION_MESSAGE(const __FlashStringHelper * s) { Serial.print(F(" Protocol failed because ")); Serial.print(s); Serial.println(F(" wrong.")); return false;};
uint8_t IRLIB_DATA_ERROR_MESSAGE(const __FlashStringHelper * s, uint8_t index, uint16_t value, uint16_t expected) {
IRLIB_REJECTION_MESSAGE(s); Serial.print(F("Error occurred with decodeBuffer[")); Serial.print(index,DEC); Serial.print(F("]=")); Serial.print(value,DEC);
Serial.print(F(" expected:")); Serial.println(expected,DEC); return false;
};
#define RAW_COUNT_ERROR IRLIB_REJECTION_MESSAGE(F("number of raw samples"));
#define HEADER_MARK_ERROR(expected) IRLIB_DATA_ERROR_MESSAGE(F("header mark"),1,recvGlobal.decodeBuffer[1],expected);
#define HEADER_SPACE_ERROR(expected) IRLIB_DATA_ERROR_MESSAGE(F("header space"),2,recvGlobal.decodeBuffer[2],expected);
#define DATA_MARK_ERROR(expected) IRLIB_DATA_ERROR_MESSAGE(F("data mark"),offset,recvGlobal.decodeBuffer[offset],expected);
#define DATA_SPACE_ERROR(expected) IRLIB_DATA_ERROR_MESSAGE(F("data space"),offset,recvGlobal.decodeBuffer[offset],expected);
#define TRAILER_BIT_ERROR(expected) IRLIB_DATA_ERROR_MESSAGE(F("RC6 trailer bit length"),offset,recvGlobal.decodeBuffer[offset],expected);
#define BIT_COUNT_ERROR IRLIB_REJECTION_MESSAGE(F("invalid number of bits"));
#else
#define IRLIB_ATTEMPT_MESSAGE(s)
#define IRLIB_TRACE_MESSAGE(s)
#define IRLIB_REJECTION_MESSAGE(s) false
#define IRLIB_DATA_ERROR_MESSAGE(s,i,v,e) false
#define RAW_COUNT_ERROR false
#define HEADER_MARK_ERROR(expected) false
#define HEADER_SPACE_ERROR(expected) false
#define DATA_MARK_ERROR(expected) false
#define DATA_SPACE_ERROR(expected) false
#define TRAILER_BIT_ERROR(expected) false
#define BIT_COUNT_ERROR false
#endif
#endif //IRLIBDECODEBASE_H

130
arduino-cli/libraries/Adafruit_Circuit_Playground/utility/IRLibGlobals.h Normal file
View File

@@ -0,0 +1,130 @@
/* IRLibGlobals.h
* Part of IRLib Library for Arduino receiving, decoding, and sending
* infrared signals. See COPYRIGHT.txt and LICENSE.txt for more information.
*
* This file replaces the previous IRLibRData.h file. It contains definition of global
* items which are used by both the receiver and decoding classes. They have to be
* declared global in scope because they are accessed by the ISR and you cannot pass
* parameters nor objects to an ISR routine.
*
* In general, applications would not include this file. Unless you are creating your own
* customized receiver class apart from the provided IRrcev, IRrcevPCI, or IRrcevLoop
* classes, you can ignore the contents of this file.
* The RECV_BUF_LENGTH is the only item you would ever modify unless you are completely
* rewriting how the system works in general.
*/
#ifndef IRLibGlobals_h
#define IRLibGlobals_h
#include <Arduino.h>
/* Timing data is stored in a buffer by the receiver object. It is an array of
* uint16_t that should be at least 100 entries as defined by this default below.
* However some IR sequences will require longer buffers especially those used for
* air conditioner controls. In general we recommend you keep this value below 255
* so that the index into the array can remain 8 bits. This library can handle larger
* arrays however it will make your code longer in addition to taking more RAM.
*/
#define RECV_BUF_LENGTH 100
#if (RECV_BUF_LENGTH > 255)
typedef uint16_t bufIndex_t;
#else
typedef uint8_t bufIndex_t;
#endif
// Receiver states. This previously was enum but changed it to uint8_t
// to guarantee it was a single atomic 8-bit value.
#define STATE_UNKNOWN 0
#define STATE_READY_TO_BEGIN 1
#define STATE_TIMING_MARK 2
#define STATE_TIMING_SPACE 3
#define STATE_FINISHED 4
#define STATE_RUNNING 5
typedef uint8_t currentState_t;
/* The structure contains information used by the ISR routines. Because we cannot
* pass parameters to an ISR, it must be global. Values which can be changed by
* the ISR but are accessed outside the ISR must be volatile.
*/
typedef struct {
//These next 4 fields are initialized by the receiver class and unlikely to change once
//they have been initialized. Only change them on the fly at your own peril.
uint8_t recvPin; // pin number or interrupt number for receiver
bool enableAutoResume; //ISR can copy data to decodeBuffer and restart by itself
uint16_t frameTimeout; //Maximum length of a SPACE before we decide the frame has ended
//Used by IRrecv only
uint16_t frameTimeoutTicks;// = frameTimeout/USEC_PER_TICKS
bool enableBlinkLED;
//These fields are both read and written inside and outside ISRs. Must be volatile.
volatile bool decoderWantsData; //tells ISR previous decode is finished. Buffer available.
volatile bool newDataAvailable; //ISR flag informs getResults that data is available.
volatile bool didAutoResume; //ISR tells getResults we already copied, just do math.
//The buffers are filled with timing values by the ISRs. The recvLength is the number of
//entries when the frame is complete. See the note at the end of this file about buffers.
volatile uint16_t recvBuffer[RECV_BUF_LENGTH];
// volatile uint16_t* recvBuffer;
volatile bufIndex_t recvLength;
//These next two fields are how the receiver communicates with the decoder. Previously
//this was accomplished by passing to the receiver a pointer to the decoder in getResults.
//However with auto resume we now may need to communicate before getResults is called.
//The decoderBuffer pointer is maintained by the decoder. It points to where the
//decoder wants the data put by the receiver. It will point to either recvGlobal.recvBuffer
//or an external buffer provided by the user via useExtnBuf. The decodeLength
//is set by the receiver telling the decoder the data length.
volatile uint16_t* decodeBuffer;
volatile bufIndex_t decodeLength;
//This field accumulates the elapsed time of a MARK or SPACE. IRrecv uses it only inside
//the ISR however IRrecvPCI accesses it outside the ISR. Therefore it is volatile
//and because it is multi-byte it will need atomic guards when accessed outside the ISR.
volatile uint32_t timer; // state timer, counts 50uS ticks.(and other uses)
//Used by both IRrecv and IRrecvPCI.
volatile currentState_t currentState; // state machine Legal values defined above.
}
recvGlobal_t;
extern recvGlobal_t recvGlobal; //declared in IRLibRecvBase.cpp
/**** NOTE CONCERNING BUFFER NAMES AND VOLATILITY
* In versions of IRLib prior to 2.0 we had the capability to declare an external
* buffer so that the receiver could resume receiving while the decoding was taking place.
* However it was up to the decoder to notice that the data had been received via a call to
* getResults() and it had to tell the receiver to resume. Starting with version 2.0
* it is now possible that the receiver can automatically copy the data to the external
* buffer and auto resume. Rather than using names like rawbuf1 and rawbuf2 we have come
* up with a new naming system. Also irparams wasn't the most descriptive name
* ever conceived. Here is our new naming system which we hope is slightly less confusing.
*
* First irparams was a structure that contained global variables used by the receiver ISR.
* They should not be part of the receiver class because you can't pass parameters
* to an ISR. We think recvGlobal is a better name.
*
* Previously the ISR did not need access to any external buffer so it only needed one
* buffer and one length variable. If there was an external buffer, only the decoder
* needed to access it. Now the receiver and ISR needs access to that external buffer
* in order to implement auto resume. Therefore the extra buffer needs to be linked
* to recvGlobal as well. The receiver puts the data in recvGlobal.recvBuffer and it's
* length is in recvGlobal.recvLength. It is for the receiver's internal use.
* Additionally we have "decodeBuffer" and "decodeLength" which
* are defined as where the decoder wants the receiver to put its data. The decoder
* decides where decodeBuffer points. The receiver puts the data at that address
* and has no idea where it points. The receiver puts the length in decodeLength.
* It is the receiver's responsibility to copy the data from recvBuffer to decodeBuffer.
* The math is always done in getResults however deciding when to do the copying is
* a bit more complicated. If we are doing auto resume, we do a bufcpy to copy as
* quickly as possible and defer the math until the actual poll to getResults.
* The getResults needs to know whether it should copy or just do the math in place.
* If you determine that by the flag didAutoResume.
*
* Now we tackle the volatile issue of "volatile". Aptly named because it starts flame wars.
* In general the rule is, if data is to be accessed inside and outside an ISR you need to
* add the volatile qualifier to its definition. This ensures that the compiler does not
* optimize the code in such a way that a bad copy of a variable might be used. It forces
* the compiler to fetch the data every time he uses it and not to store it in a register.
* We are going to presume that our ISRs never interrupt themselves. I believe the volatile
* qualifier may not be necessary because the decoder is only accessing the data once the
* receiver is finished working with it. The only items that really need to be volatile
* are some of the flags. However making the buffer volatile does not seem to measurably
* slowdown the decoding process (I ran some tests). So as part of "good programming
* practices we are marking the buffers and lengths as volatile just in case. We need not
* use atomic blocks to access the buffer except in very rare cases.
*/
#define DEBUG_VALUE(l, v) Serial.print(l); Serial.print(":"); Serial.println(v,DEC);
#endif

36
arduino-cli/libraries/Adafruit_Circuit_Playground/utility/IRLibHardware.cpp Normal file
View File

@@ -0,0 +1,36 @@
/* IRLibHardware.cpp
* Part of IRLib Library for Arduino receiving, decoding, and sending
* infrared signals. See COPYRIGHT.txt and LICENSE.txt for more information.
*
* We need a way for the sending object to communicate with the receiving object.
* Sending an IR signal can disable further receiving because the timer needed for the 50us
* interrupts is used to modulate the frequency of the PWM output signal. We need a flag
* for the send object to inform you receive object that this occurred.
*
* Some applications do sending only and would only require you to include IRLibSendBase.h
* while others only do receiving/decoding and would include IRLibRecvBase.h but not
* IRLibSendBase.h. The only include file that is used by both sending and receiving is
* the IRLibHardware.h which was formerly called IRLibTimer.h. Therefore we put the flag
* in this newly created IRLibHardware.cpp module. That way a send only can put the flag
* here whether or not there is a receiver. Similarly the receiver can check the flag
* whether or not there is a sender.
*
* The below is a global flag IRLib_didIROut that gets set true with every call to enableIROut.
* Then any call to IRrecv::enableIRIn checks this to see if it needs to restart the ISR.
* Regardless IRrecv::enableIRIn will always reset it it false for the next time.
* Note as always if you try to send while in the middle of receiving, the partially received
* data is lost. If the application wishes to create a system where the sending waits until
* the receiver is idle, the programmer can implement such a system themselves and deal with
* the consequences.
*
* The bottom line is the application no longer needs to figure out if it needs to
* call enableIRIn or the "resume" method. There is no more "resume". You always do
* enableIRIn after every decode and the system handles it.
*/
#if !defined(ARDUINO_NRF52840_CIRCUITPLAY)
#include "IRLibHardware.h"
uint8_t IRLib_didIROut=false;
#endif

376
arduino-cli/libraries/Adafruit_Circuit_Playground/utility/IRLibHardware.h Normal file
View File

@@ -0,0 +1,376 @@
/* IRLibHardware.h
* Part of IRLib Library for Arduino receiving, decoding, and sending
* infrared signals. See COPYRIGHT.txt and LICENSE.txt for more information.
*
* This file was formally called IRLibTimer.h but we have renamed it because it more
* accurately reflects the fact that it contains all of the hardware specific defines.
* It contains mostly definitions for 8-bit AVR processors. More advanced processors such as
* SAMD21 definitions will now be defined in a separate processor specific header file.
* NOTE: IRLibHardware.cpp is not related to hardware. See the comments in that file
* to explain why it was created and what purpose it serves.
*/
/* This file has been significantly reconfigured for version 1.5 and greater. It now
* allows you use a different timer for input versus output. This also allows you to
* use no timers whatsoever by using the IRrecvPCI or IRrecvLoop for input and
* bit-bang routines for output. Note the various "Teensy" sections have not been tested.
*/
#ifndef IRLibHardware_h
#define IRLibHardware_h
#include "Arduino.h"
//This is a default for AVRs. SAMD21 will override it.
#define IR_CLEAR_INTERRUPT {} //clear interrupt flag
// defines for setting and clearing register bits
#ifndef cbi
#define cbi(sfr, bit) (_SFR_BYTE(sfr) &= ~_BV(bit))
#endif
#ifndef sbi
#define sbi(sfr, bit) (_SFR_BYTE(sfr) |= _BV(bit))
#endif
/* In this section we attempt to detect your hardware type and give you the choice of
* various hardware timers to change the PWM frequency for output. In each hardware
* section below you should un-comment only one of the choices. The defines also
* specify the output pin number. DO NOT change the pin number unless you're using
* non-standard hardware that would require you to do so. If you wish to use the
* bit-bang PWM output, you will specify that AFTER this section as an override.
*/
/* Arduino Mega */
#if defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)
//#define IR_SEND_TIMER1 11
#define IR_SEND_TIMER2 9
//#define IR_SEND_TIMER3 5
//#define IR_SEND_TIMER4 6
//#define IR_SEND_TIMER5 46
/* Teensy 1.0 */
#elif defined(__AVR_AT90USB162__)
#define IR_SEND_TIMER1 17
/* Teensy 2.0 versus Leonardo These boards use the same chip but the
* pinouts are different.*/
#elif defined(__AVR_ATmega32U4__)
#ifdef CORE_TEENSY
// it's Teensy 2.0
//#define IR_SEND_TIMER1 14
//#define IR_SEND_TIMER3 9
#define IR_SEND_TIMER4_HS 10
#else
/* it's probably Leonardo */
#define IR_SEND_TIMER1 9
//#define IR_SEND_TIMER3 5
//#define IR_SEND_TIMER4_HS 13
#endif
/* Teensy++ 1.0 & 2.0 */
#elif defined(__AVR_AT90USB646__) || defined(__AVR_AT90USB1286__)
//#define IR_SEND_TIMER1 25
#define IR_SEND_TIMER2 1
//#define IR_SEND_TIMER3 16
/* Sanguino */
#elif defined(__AVR_ATmega644P__) || defined(__AVR_ATmega644__)
//#define IR_SEND_TIMER1 13
#define IR_SEND_TIMER2 14
/* Arduino Zero, M0, M0 Pro, Feather M0 etc. */
#elif defined (__SAMD21G18A__)
// All of the settings can be found in IRLibSAMD21.h
#include "IRLibSAMD21.h"
/* Pinoccio Scout */
#elif defined(__AVR_ATmega256RFR2__)
#define IR_SEND_TIMER3 3
/* Arduino Duemilanove, Diecimila, LilyPad, Mini, Fio, etc */
#else
//#define IR_SEND_TIMER1 9
#define IR_SEND_TIMER2 3
#endif //end of setting IR_SEND_TIMER based on hardware detection
/* If you want to use bit-bang PWM output, you should un-comment the line below.
* The definition must include the pin number for bit-bang output. This could be any
* available digital output pin. It need not be a designated PWM pin.
* NOTE: By un-commenting this line, you are forcing the library to ignore
* hardware detection and timer specifications above. The bit-bang frequency
* code is not as accurate as using a hardware timer but it is more flexible and
* less hardware platform dependent.
*/
//#define IR_SEND_BIT_BANG 3 //Be sure to set this pin number if you un-comment
/* This is a fudge factor that adjusts bit-bang timing. Feel free to experiment
* for best results.*/
#define IR_BIT_BANG_OVERHEAD 10
/* We are going to presume that you want to use the same hardware timer to control
* the 50 microsecond interrupt used by the IRrecv receiver class as was specified
* above in the hardware detection section for sending. Even if you specified bit-bang
* for sending, the definitions above have selected a default sending timer for you based
* on hardware detection. If that is correct, then do nothing below. However if you do
* wish to specify an IR_RECV_TIMER different than the IR_SEND_TIMER selected by the code
* above, then you should un-comment the IR_RECV_TIMER_OVERRIDE and also un-comment one
* and only one of the following IR_RECV_TIMERx lines below that.
* NOTE: You are responsible for ensuring that the timer you are specifying is
* available on your hardware. You should only choose timers which are shown as available
* for your hardware platform as shown in the defines in the IR_SEND_TIMER section above.
* NOTE: This discussion does not apply to SAMD 21 processors.
*/
//#define IR_RECV_TIMER_OVERRIDE
//#define IR_RECV_TIMER1
//#define IR_RECV_TIMER2
//#define IR_RECV_TIMER3
//#define IR_RECV_TIMER4
//#define IR_RECV_TIMER4_HS
//#define IR_RECV_TIMER5
// Miscellaneous defines needed for computations below
#ifdef F_CPU
#define SYSCLOCK F_CPU // main Arduino clock
#else
#define SYSCLOCK 16000000 // main Arduino clock
#endif
/* Everything below this point is a computation based on user settings above.
* In all likelihood you would never need to modify anything below this point
* unless you are adding some completely new feature or seriously modifying
* the behavior of existing features. In other words don't try this at home.
*/
#if !defined(IR_RECV_TIMER_OVERRIDE)
#if defined(IR_SEND_TIMER1)
#define IR_RECV_TIMER1
#elif defined(IR_SEND_TIMER2)
#define IR_RECV_TIMER2
#elif defined(IR_SEND_TIMER3)
#define IR_RECV_TIMER3
#elif defined(IR_SEND_TIMER4)
#define IR_RECV_TIMER4
#elif defined(IR_SEND_TIMER4_HS)
#define IR_RECV_TIMER4_HS
#elif defined(IR_SEND_TIMER5)
#define IR_RECV_TIMER5
#elif defined(__SAMD21G18A__)//handle this one a little differently
#define IR_RECV_TC3
#else
#error "Unable to set IR_RECV_TIMER"
#endif
#endif
#if defined(IR_SEND_BIT_BANG) //defines for bit-bang output
#define IR_SEND_PWM_PIN IR_SEND_BIT_BANG
#define IR_SEND_PWM_START unsigned int jmax=time/iLength;\
for(unsigned int j=0;j<jmax;j++) {\
digitalWrite(IR_SEND_BIT_BANG, HIGH); delayMicroseconds(onTime);\
digitalWrite(IR_SEND_BIT_BANG, LOW); delayMicroseconds(offTime);}
#define IR_SEND_MARK_TIME(time)
#define IR_SEND_PWM_STOP
#define IR_SEND_CONFIG_KHZ(val) float Length=1000.0/(float)khz;\
iLength=int(Length+0.5); onTime=int(Length/3.0); \
offTime=iLength-onTime-IR_BIT_BANG_OVERHEAD-(val<40);
#elif defined(IR_SEND_TIMER1) // defines for timer1 (16 bits)
#define IR_SEND_PWM_START (TCCR1A |= _BV(COM1A1))
#define IR_SEND_MARK_TIME(time) IRLibDelayUSecs(time)
#define IR_SEND_PWM_STOP (TCCR1A &= ~(_BV(COM1A1)))
#define IR_SEND_CONFIG_KHZ(val) ({ \
const uint16_t pwmval = SYSCLOCK / 2000 / (val); \
TCCR1A = _BV(WGM11); TCCR1B = _BV(WGM13) | _BV(CS10); \
ICR1 = pwmval; OCR1A = pwmval / 3; })
#if defined(CORE_OC1A_PIN)
#define IR_SEND_PWM_PIN CORE_OC1A_PIN /* Teensy */
#else
#define IR_SEND_PWM_PIN IR_SEND_TIMER1
#endif
#elif defined(IR_SEND_TIMER2) // defines for timer2 (8 bits)
#define IR_SEND_PWM_START (TCCR2A |= _BV(COM2B1))
#define IR_SEND_MARK_TIME(time) IRLibDelayUSecs(time)
#define IR_SEND_PWM_STOP (TCCR2A &= ~(_BV(COM2B1)))
#define IR_SEND_CONFIG_KHZ(val) ({ \
const uint8_t pwmval = SYSCLOCK / 2000 / (val); \
TCCR2A = _BV(WGM20); TCCR2B = _BV(WGM22) | _BV(CS20); \
OCR2A = pwmval; OCR2B = pwmval / 3; })
#if defined(CORE_OC2B_PIN)
#define IR_SEND_PWM_PIN CORE_OC2B_PIN /* Teensy */
#else
#define IR_SEND_PWM_PIN IR_SEND_TIMER2
#endif
#elif defined(IR_SEND_TIMER3) // defines for timer3 (16 bits)
#define IR_SEND_PWM_START (TCCR3A |= _BV(COM3A1))
#define IR_SEND_MARK_TIME(time) IRLibDelayUSecs(time)
#define IR_SEND_PWM_STOP (TCCR3A &= ~(_BV(COM3A1)))
#define IR_SEND_CONFIG_KHZ(val) ({ \
const uint16_t pwmval = SYSCLOCK / 2000 / (val); \
TCCR3A = _BV(WGM31); TCCR3B = _BV(WGM33) | _BV(CS30); \
ICR3 = pwmval; OCR3A = pwmval / 3; })
#if defined(CORE_OC3A_PIN)
#define IR_SEND_PWM_PIN CORE_OC3A_PIN /* Teensy */
#else
#define IR_SEND_PWM_PIN IR_SEND_TIMER3
#endif
#elif defined(IR_SEND_TIMER4_HS) // defines for timer4 (10 bits, high speed option)
#define IR_SEND_PWM_START (TCCR4A |= _BV(COM4A1))
#define IR_SEND_MARK_TIME(time) IRLibDelayUSecs(time)
#define IR_SEND_PWM_STOP (TCCR4A &= ~(_BV(COM4A1)))
#define IR_SEND_CONFIG_KHZ(val) ({ \
const uint16_t pwmval = SYSCLOCK / 2000 / (val); \
TCCR4A = (1<<PWM4A); TCCR4B = _BV(CS40); \
TCCR4C = 0; TCCR4D = (1<<WGM40); \
TCCR4E = 0; TC4H = pwmval >> 8; \
OCR4C = pwmval; TC4H = (pwmval / 3) >> 8; OCR4A = (pwmval / 3) & 255; })
#if defined(CORE_OC4A_PIN)
#define IR_SEND_PWM_PIN CORE_OC4A_PIN /* Teensy */
#else
#define IR_SEND_PWM_PIN IR_SEND_TIMER4_HS
#endif
#elif defined(IR_SEND_TIMER4) // defines for timer4 (16 bits)
#define IR_SEND_PWM_START (TCCR4A |= _BV(COM4A1))
#define IR_SEND_MARK_TIME(time) IRLibDelayUSecs(time)
#define IR_SEND_PWM_STOP (TCCR4A &= ~(_BV(COM4A1)))
#define IR_SEND_CONFIG_KHZ(val) ({ \
const uint16_t pwmval = SYSCLOCK / 2000 / (val); \
TCCR4A = _BV(WGM41); TCCR4B = _BV(WGM43) | _BV(CS40); \
ICR4 = pwmval; OCR4A = pwmval / 3; })
#if defined(CORE_OC4A_PIN)
#define IR_SEND_PWM_PIN CORE_OC4A_PIN
#else
#define IR_SEND_PWM_PIN IR_SEND_TIMER4
#endif
#elif defined(IR_SEND_TIMER5) // defines for timer5 (16 bits)
#define IR_SEND_PWM_START (TCCR5A |= _BV(COM5A1))
#define IR_SEND_MARK_TIME(time) IRLibDelayUSecs(time)
#define IR_SEND_PWM_STOP (TCCR5A &= ~(_BV(COM5A1)))
#define IR_SEND_CONFIG_KHZ(val) ({ \
const uint16_t pwmval = SYSCLOCK / 2000 / (val); \
TCCR5A = _BV(WGM51); TCCR5B = _BV(WGM53) | _BV(CS50); \
ICR5 = pwmval; OCR5A = pwmval / 3; })
#if defined(CORE_OC5A_PIN)
#define IR_SEND_PWM_PIN CORE_OC5A_PIN
#else
#define IR_SEND_PWM_PIN IR_SEND_TIMER5
#endif
#elif defined(IRLibSAMD21_h) // Used for SAMD 21
/* All of these definitions have been moved to IRLibSAMD21.h
#define IR_SEND_PWM_START
#define IR_SEND_MARK_TIME(time)
#define IR_SEND_PWM_STOP
#define IR_SEND_PWM_PIN
#define IR_SEND_CONFIG_KHZ(val)
*/
#else // unknown timer
#error "Internal code configuration error, no known IR_SEND_TIMER# defined\n"
#endif
/* This section sets up the 50 microsecond interval timer used by the
* IRrecv receiver class. The various timers have already been selected
* earlier in this file. Theoretically you could change the 50 but it has not been tested.
*/
#define USEC_PER_TICK 50 // microseconds per clock interrupt tick
#if defined(IR_RECV_TIMER1) // defines for timer1 (16 bits)
#define IR_RECV_ENABLE_INTR (TIMSK1 = _BV(OCIE1A))
#define IR_RECV_DISABLE_INTR (TIMSK1 = 0)
#define IR_RECV_INTR_NAME ISR(TIMER1_COMPA_vect,ISR_NOBLOCK)
#define IR_RECV_CONFIG_TICKS() ({ \
TCCR1A = 0; TCCR1B = _BV(WGM12) | _BV(CS10); \
OCR1A = SYSCLOCK * USEC_PER_TICK / 1000000; TCNT1 = 0; })
#elif defined(IR_RECV_TIMER2) // defines for timer2 (8 bits)
#define IR_RECV_ENABLE_INTR (TIMSK2 = _BV(OCIE2A))
#define IR_RECV_DISABLE_INTR (TIMSK2 = 0)
#define IR_RECV_INTR_NAME ISR(TIMER2_COMPA_vect,ISR_NOBLOCK)
#define IR_RECV_COUNT_TOP (SYSCLOCK * USEC_PER_TICK / 1000000)
#if (IR_RECV_COUNT_TOP < 256)
#define IR_RECV_CONFIG_TICKS() ({ \
TCCR2A = _BV(WGM21); TCCR2B = _BV(CS20); \
OCR2A = IR_RECV_COUNT_TOP; TCNT2 = 0; })
#else
#define IR_RECV_CONFIG_TICKS() ({ \
TCCR2A = _BV(WGM21); TCCR2B = _BV(CS21); \
OCR2A = IR_RECV_COUNT_TOP / 8; TCNT2 = 0; })
#endif
#elif defined(IR_RECV_TIMER3) // defines for timer3 (16 bits)
#define IR_RECV_ENABLE_INTR (TIMSK3 = _BV(OCIE3A))
#define IR_RECV_DISABLE_INTR (TIMSK3 = 0)
#define IR_RECV_INTR_NAME ISR(TIMER3_COMPA_vect,ISR_NOBLOCK)
#define IR_RECV_CONFIG_TICKS() ({ \
TCCR3A = 0; TCCR3B = _BV(WGM32) | _BV(CS30); \
OCR3A = SYSCLOCK * USEC_PER_TICK / 1000000; TCNT3 = 0; })
#elif defined(IR_RECV_TIMER4_HS) // defines for timer4 (10 bits, high speed option)
#define IR_RECV_ENABLE_INTR (TIMSK4 = _BV(TOIE4))
#define IR_RECV_DISABLE_INTR (TIMSK4 = 0)
#define IR_RECV_INTR_NAME ISR(TIMER4_OVF_vect,ISR_NOBLOCK)
#define IR_RECV_CONFIG_TICKS() ({ \
TCCR4A = 0; TCCR4B = _BV(CS40); \
TCCR4C = 0; TCCR4D = 0; TCCR4E = 0; \
TC4H = (SYSCLOCK * USEC_PER_TICK / 1000000) >> 8; \
OCR4C = (SYSCLOCK * USEC_PER_TICK / 1000000) & 255; \
TC4H = 0; TCNT4 = 0; })
#elif defined(IR_RECV_TIMER4) // defines for timer4 (16 bits)
#define IR_RECV_ENABLE_INTR (TIMSK4 = _BV(OCIE4A))
#define IR_RECV_DISABLE_INTR (TIMSK4 = 0)
#define IR_RECV_INTR_NAME ISR(TIMER4_COMPA_vect,ISR_NOBLOCK)
#define IR_RECV_CONFIG_TICKS() ({ \
TCCR4A = 0; TCCR4B = _BV(WGM42) | _BV(CS40); \
OCR4A = SYSCLOCK * USEC_PER_TICK / 1000000; TCNT4 = 0; })
#elif defined(IR_RECV_TIMER5) // defines for timer5 (16 bits)
#define IR_RECV_ENABLE_INTR (TIMSK5 = _BV(OCIE5A))
#define IR_RECV_DISABLE_INTR (TIMSK5 = 0)
#define IR_RECV_INTR_NAME ISR(TIMER5_COMPA_vect,ISR_NOBLOCK)
#define IR_RECV_CONFIG_TICKS() ({ \
TCCR5A = 0; TCCR5B = _BV(WGM52) | _BV(CS50); \
OCR5A = SYSCLOCK * USEC_PER_TICK / 1000000; TCNT5 = 0; })
#elif defined(IRLibSAMD21_h) //for SAMD 21
/* All of these definitions have been moved to IRLibSAMD21.h
#define IR_RECV_ENABLE_INTR
#define IR_RECV_DISABLE_INTR
#define IR_RECV_INTR_NAME
#define IR_RECV_CONFIG_TICKS()
*/
#else // unknown timer
#error "Internal code configuration error, no known IR_RECV_TIMER# defined\n"
#endif
//Cannot use blinking LED on 13 if that's the output pin.
#if (IR_SEND_PWM_PIN==13)
#define BLINKLED -1
#define BLINKLED_ON()
#define BLINKLED_OFF()
#endif
// defines for blinking the LED
#ifndef BLINKLED
#if defined(CORE_LED0_PIN)
#define BLINKLED CORE_LED0_PIN
#define BLINKLED_ON() (digitalWrite(CORE_LED0_PIN, HIGH))
#define BLINKLED_OFF() (digitalWrite(CORE_LED0_PIN, LOW))
#elif defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)
#define BLINKLED 13
#define BLINKLED_ON() (PORTB |= B10000000)
#define BLINKLED_OFF() (PORTB &= B01111111)
#elif defined(__AVR_ATmega644P__) || defined(__AVR_ATmega644__)
#define BLINKLED 0
#define BLINKLED_ON() (PORTD |= B00000001)
#define BLINKLED_OFF() (PORTD &= B11111110)
#elif defined(__AVR_ATmega32u4__) || defined(__AVR_ATmega328__)
#define BLINKLED 13
#define BLINKLED_ON() (PORTB |= B00100000)
#define BLINKLED_OFF() (PORTB &= B11011111)
#else
#define BLINKLED 13
#define BLINKLED_ON() (digitalWrite(13, HIGH))
#define BLINKLED_OFF() (digitalWrite(13, LOW))
#endif
#endif
extern uint8_t IRLib_didIROut;//See the explanation in IRLibHardware.cpp
#endif //IRLibHardware_h

30
arduino-cli/libraries/Adafruit_Circuit_Playground/utility/IRLibProtocols.cpp Normal file
View File

@@ -0,0 +1,30 @@
/* IRLibProtocols.cpp
* Part of IRLib Library for Arduino receiving, decoding, and sending
* infrared signals. See COPYRIGHT.txt and LICENSE.txt for more information.
*/
/*
* This module enumerates the various supported protocols and defines a program memory
* string used by the dump routines or your sketches to display the name of a protocol.
* It is used by both Send and Decode sections of the code but not Receive.
*/
#if !defined(ARDUINO_NRF52840_CIRCUITPLAY)
#include "IRLibProtocols.h"
/*
* Returns a pointer to a flash stored string that is the name of the protocol received.
*/
const __FlashStringHelper *Pnames(uint8_t type) {
if(type>89) return F("Unsup");
if(type>LAST_PROTOCOL) type=UNKNOWN;
// You can add additional strings before the entry for hash code.
const __FlashStringHelper *Names[LAST_PROTOCOL+1]={
F("Unknown"),F("NEC"),F("Sony"),F("RC5"),F("RC6"),F("Panasonic Old"),F("JVC"),
F("NECx"),F("Samsung36"),F("G.I.Cable"),F("DirecTV"),F("rcmm"),F("CYKM")
//,F("Additional_13")//expand or edit these
};
return Names[type];
};
#endif

44
arduino-cli/libraries/Adafruit_Circuit_Playground/utility/IRLibProtocols.h Normal file
View File

@@ -0,0 +1,44 @@
/* IRLibProtocols.h
* Part of IRLib Library for Arduino receiving, decoding, and sending
* infrared signals. See COPYRIGHT.txt and LICENSE.txt for more information.
*/
/*
* This module enumerates the various supported protocols and defines a program memory
* string used by the dump routines or your sketches to display the name of a protocol.
* It is used by both Send and Decode sections of the code but not Receive.
*/
#ifndef IRLIBPROTOCOLS_H
#define IRLIBPROTOCOLS_H
#include <Arduino.h>
#define UNKNOWN 0
#define NEC 1
#define SONY 2
#define RC5 3
#define RC6 4
#define PANASONIC_OLD 5
#define JVC 6
#define NECX 7
#define SAMSUNG36 8
#define GICABLE 9
#define DIRECTV 10
#define RCMM 11
#define CYKM 12
//#define ADDITIONAL_13 13 //add additional protocols here
//#define ADDITIONAL_14 14
#define LAST_PROTOCOL 12 //Be sure to update this when adding protocols
/*
* Returns a pointer to a flash stored string that is the name of the protocol received.
*/
const __FlashStringHelper *Pnames(uint8_t Type);
/*
* Miscellaneous values used by both Send and Decode modules
*/
#define TOPBIT 0x80000000
// Decoded value for NEC and others when a repeat code is received or to be sent
#define REPEAT_CODE 0xffffffff
#endif //IRLIBPROTOCOLS_H

216
arduino-cli/libraries/Adafruit_Circuit_Playground/utility/IRLibRecvBase.cpp Normal file
View File

@@ -0,0 +1,216 @@
/* IRrecvBase.cpp
* Part of IRLib Library for Arduino receiving, decoding, and sending
* infrared signals. See COPYRIGHT.txt and LICENSE.txt for more information.
*
* This module contains the base class classes for receiving IR signals. You will not create
* instances of this class, rather it is used as a base class for the 3 different
* receiver classes. These are the original IRrecv which uses a 50us timer interrupt.
* The IRrecvPCI version that uses pin change interrupts and IRrecvLoop which uses no timers
* or interrupts. Each of these has its own .h and .cpp file.
*
* The IRrecvLoop files are in this folder. However the other two receivers in their own
* separate libraries. That is because their interrupt service routines can conflict
* with other ISRs. The ISRs conflict would occur even if you did not create an instance
* of their receiver classes. Similarly the frequency detection receiver which also uses
* interrupts is also in a separate folder IRLibFreq.
*/
#if !defined(ARDUINO_NRF52840_CIRCUITPLAY)
#include "IRLibRecvBase.h"
#include "IRLibHardware.h"
/* This structure contains all of the global variables used by the ISRs to communicate
* with the receiver and decoder objects. You cannot pass parameters to an ISR so
* these values must be global. The fields are defined in IRLibRecvBase.h
*/
recvGlobal_t recvGlobal;
// The base constructor receives the pin number
IRrecvBase::IRrecvBase(uint8_t recvPin) {
recvGlobal.recvPin = recvPin;
init();
}
// Initialization common to all three receiver classes
void IRrecvBase::init(void) {
//These first two lines would normally be done by the decoder
//however in rare circumstances there is no decoder.
recvGlobal.decoderWantsData=false; //turned on by enableIRIn.
recvGlobal.decodeBuffer=recvGlobal.recvBuffer;//default buffer
recvGlobal.enableAutoResume=false;
recvGlobal.frameTimeout=DEFAULT_FRAME_TIMEOUT;
recvGlobal.frameTimeoutTicks=recvGlobal.frameTimeout/USEC_PER_TICK;
markExcess=DEFAULT_MARK_EXCESS;
recvGlobal.newDataAvailable=false;
recvGlobal.enableBlinkLED=false;
recvGlobal.currentState=STATE_FINISHED;//i.e. Not running.
}
// Turn on or off a blinking LED which indicates signal received. Usually pin 13.
void blink13(bool enableBlinkLED){
#if (BLINKLED>0)
pinMode(BLINKLED,OUTPUT);
recvGlobal.enableBlinkLED=enableBlinkLED;
#endif
}
/* Any receiver class must implement a getResults method that will return true when
* a complete frame of data has been received. When your getResults determines that
* the frame is complete, it must guarantee that there will be no further changes to
* the data in the buffer or the length value. It can do that by either disabling
* interrupts or putting the ISR in a state that ensures it will not
* change those values. Then it must then call IRrecvBase::getResults. This base method
* will then will perform some math on the values and copy them to the decodeBuffer.
* Some receivers provide results in recvBuffer measured in ticks of some number of
* microseconds while others return results in actual microseconds. If you use ticks then
* you should pass a multiplier value in timePerTicks.
* NOTE: Only call the base method if newDataAvailable is true.
*/
bool IRrecvBase::getResults(const uint16_t timePerTick) {
//Conceptually the loop below copies data from the receiver buffer to the decode buffer
//while performing some math. In some instances, the source and destination are the same.
//The decoder has already set up decodeBuffer to point to the proper destination.
//Here we need to figure out the source. If didAutoResume is true then the ISR has already
//copied the data to decodeBuffer so it is both source and destination. In all
//other circumstances the source is always recvGlobal.recvBuffer.
recvGlobal.newDataAvailable=false;
volatile uint16_t *Source;
//DEBUG_VALUE("recvGlobal.didAutoResume",recvGlobal.didAutoResume);
if(recvGlobal.didAutoResume) {
Source=recvGlobal.decodeBuffer;
recvGlobal.didAutoResume=false;
} else {
Source=recvGlobal.recvBuffer;
recvGlobal.decodeLength=recvGlobal.recvLength;//if auto resumed, was already copied
}
//If the receiver counts time intervals rather than actual microseconds we will multiply
//the data by timePerTick. It also adjusts the data by adding or subtracting the
//markExcess value. See the documentation on markExcess for details.
for(uint8_t i=0; i<recvGlobal.decodeLength; i++) {
recvGlobal.decodeBuffer[i]=Source[i]*timePerTick + ( (i % 2)? -markExcess:markExcess);
}
//Now that the decoder has its data it doesn't want any more until it tells you.
//It will do so by calling enableIRIn.
recvGlobal.decoderWantsData=false;
return true;
}
/* The user calls enableIRIn each time it is ready to receive data. Previously
* this was only used to initialize the receiver once and subsequent calls were made
* to a method called "resume". However it was confusing because you had to call
* enableIRIn after a send because any sending would disable IRIn. It's simpler just to
* always use enableIRIn even though parts of it are slightly redundant.
* The interrupt driven receivers call this before enabling interrupts.
* See the comments on IRrecv::enableIRIn() in IRLibRecv.cpp regarding auto resume.
*/
void IRrecvBase::enableIRIn(void) {
//some IR receiver datesheets recommend pull-up resistors
pinMode(recvGlobal.recvPin, INPUT_PULLUP);
recvGlobal.recvLength = 0;
recvGlobal.currentState = STATE_READY_TO_BEGIN;
IRLib_didIROut=false;//We reinitialized so reset until somebody does more output.
}
/* Even when not receiving data or waiting to receive data, the ISR may remain active
* but remains in a do-nothing state. If the user wants to truly shut down the ISR
* they can call this method. The derived method should disable the ISR and then call
* this base method to the turn everything off.
*/
void IRrecvBase::disableIRIn(void) {
recvGlobal.decoderWantsData=false;
recvGlobal.didAutoResume=false;
recvGlobal.currentState=STATE_FINISHED;//i.e. Not running.
}
/*
* Normally recvGlobal.decodeBuffer points to recvGlobal.recvBuffer and therefore
* decoding uses the same buffer as receiving. However you may want to resume
* receiving while still decoding. To do so must specify a separate buffer for decoding.
* You will declare the buffer as "uint16_t myBuffer[RECV_BUF_LENGHT];" in your sketch
* then pass its address using the method below. Then IRrecvBase::getResults() will copy
* timing values from its buffer to yours. The receiver will then automatically resume.
* The receiver will not overwrite your buffer unless you have called enableIRIn()
* to tell it that you have finished your decoding. In other words auto resume will only
* occur once until you again call enableIRIn().
*/
void IRrecvBase::enableAutoResume(uint16_t *P){
recvGlobal.decodeBuffer=(volatile uint16_t*)P;
recvGlobal.enableAutoResume=true;
};
// This had to be a method so that IRrecv::setFrameTimeout can compute
// frameTimeoutTicks.
void IRrecvBase::setFrameTimeout(uint16_t frameTimeout) {
recvGlobal.frameTimeout=frameTimeout;
}
/*********************
*
* The remaining functions below are not part of any class or object. They are global
* so they can be called by the ISRs or for other reasons are not really tied to any
* class or object.
*
*********************/
/*
* This function is called by both the 50us and PCI ISR in one of two circumstances:
* 1) The SPACE was long enough that we are sure the frame is over and ready to process.
* 2) The buffer overflowed we have to quit. The parameter is for debugging purposes only.
*/
void IRLib_IRrecvComplete(uint8_t Reason) {
(void)Reason;
// Here we are finished. Let the world know there is new data available.
recvGlobal.newDataAvailable=true;
recvGlobal.currentState=STATE_FINISHED;//this essentially pauses the receiver ISR
//Now we need to see if we want to auto resume. We can only do that if it is enabled and
//if the user is finished using the buffer from the previous capture and wants more data.
//DEBUG_VALUE ("Reason completed", Reason)
if (recvGlobal.enableAutoResume && recvGlobal.decoderWantsData) {
//Here we do the actual auto resume. We will copy the data using memcpy because it
//should be very quick. Any calculations will be handled by the getResults method but
//not here.
memcpy((void *)recvGlobal.decodeBuffer, (const void*)recvGlobal.recvBuffer,recvGlobal.recvLength*sizeof(uint16_t));
recvGlobal.decodeLength=recvGlobal.recvLength;
// We have just copied the data to the decoder so it's not going to want more until
// it tells us that it is ready for more.
recvGlobal.decoderWantsData=false;
// Tell getResults that we auto resumed therefore the data has been copied but
// still needs the math done.
recvGlobal.didAutoResume=true;
// Now we need to reset the index to the beginning and restart the state machine.
recvGlobal.recvLength=0;
//While we were doing the copy, the 50 us interrupt continued but the state machine
//was paused in the STATE_FINISHED. Now we actually turn it back on till you get to
//actually receive data.
recvGlobal.currentState= STATE_READY_TO_BEGIN;
}
}
/* If your hardware is set up to do both output and input but your particular sketch
* doesn't do any output, this method will ensure that your output pin is low
* and doesn't turn on your IR LED or any output circuit.
*/
void IRLib_NoOutput (void) {
#if defined(IR_SEND_PWM_PIN)
pinMode(IR_SEND_PWM_PIN, OUTPUT);
digitalWrite(IR_SEND_PWM_PIN, LOW); // When not sending PWM, we want it low
#endif
}
/* Do the actual blinking off and on of the indicator LED. Called by the various
* receiver ISRs
*/
void IRLib_doBlink(void) {
if (recvGlobal.enableBlinkLED) {
if(recvGlobal.recvLength & 1) {
BLINKLED_ON(); // turn pin 13 LED on
}
else {
BLINKLED_OFF(); // turn pin 13 LED off
}
}
}
#endif //!defined(__NRF52__)

84
arduino-cli/libraries/Adafruit_Circuit_Playground/utility/IRLibRecvBase.h Normal file
View File

@@ -0,0 +1,84 @@
/* IRLibRecvBase.h
* Part of IRLib Library for Arduino receiving, decoding, and sending
* infrared signals. See COPYRIGHT.txt and LICENSE.txt for more information.
*
* This module contains the base class classes for receiving IR signals. You will not create
* instances of this class, rather it is used as a base class for the 3 different
* receiver classes. These are the original IRrecv which uses a 50us timer interrupt.
* The IRrecvPCI version that uses pin change interrupts and IRrecvLoop which uses no timers
* or interrupts. Each of these has its own .h and .cpp file.
*
* The IRrecvLoop files are in this folder. However the other two receivers in their own
* separate libraries. That is because their interrupt service routines can conflict
* with other ISRs. The ISRs conflict would occur even if you did not create an instance
* of their receiver classes. Similarly the frequency detection receiver which also uses
* interrupts is also in a separate folder IRLibFreq.
*/
#ifndef IRLibRecvBase_h
#define IRLibRecvBase_h
#include "IRLibGlobals.h"
/* Below are default values for initializing various receiver parameters.
* Each of these can be set using methods or variables in the base class
* however these are the defaults if you do not specifically set them.
*/
#define DEFAULT_BLINK_PIN LED_BUILTIN //NOTE: LED_BUILTIN is an Arduino constant
#define DEFAULT_BLINK_ENABLED false
#define DEFAULT_MARK_EXCESS 50
#define DEFAULT_FRAME_TIMEOUT 7800 //maximum length of SPACE Sbefore we assume frame ended
//DEFAULT_TIMEOUT should be 1.25*the_largest_space_any_valid_IR_protocol_might_have.
//In IRremote library ir_Dish.cpp space they use DISH_RPT_SPACE 6200 while referenced says
//about 6000. If we take 6200*1.25= 7750 rounded up we will use 7800. Previous IRLib
//value was 10000 was probably too large. Thanks to Gabriel Staples for this note.
/* Base receiver class. Do not create instance. Only used as base for other
* receiver classes. See documentation for description of each method or variable.
*/
class IRrecvBase {
public:
IRrecvBase(void) {};
IRrecvBase(uint8_t recvPin);
bool getResults(const uint16_t timePerTicks=1);
virtual void enableIRIn(void);
virtual void disableIRIn(void);
void enableAutoResume(uint16_t *P);
void setFrameTimeout(uint16_t frameTimeout);
void blink13(bool enableBlinkLED);
uint16_t markExcess;
protected:
void init(void);
};
/* The global functions below are not methods of any class because they either
* do not directly relate to the classes or they must be global functions
* so that they can appear inside and ISR. You cannot pass variables to ISR's
* or you could not pass any object or methods to it. These functions have been
* renamed to emphasize the fact that they are part of this library.
*/
/* This function does the actual blinking of an indicator LED. Must be global
* so it can be used by ISRs
*/
void IRLib_doBlink(void);
/* Some users create custom boards for input and output of IR signals and those boards are
* connected to their Arduino even in the case when the sketch only does input. It is
* theoretically possible that when running an “input only” sketch that the output pin
* could initialize high and your output LED would be on all the time. LED driver circuits
* are sometimes designed to overdrive the LED because it is used only intermittently. If
* it were to be accidentally left on continuously, it could burn out your circuit. If you
* want to ensure that this does not happen you can call the function below.
* NOTE: This used to be a method of the base receiver class but it really doesn't have
* anything to do with receiving so we renamed it and made it a standalone function.
*/
void IRLib_NoOutput(void);
/* This function is called by both the 50us and PCI ISR in one of two circumstances:
* 1) The SPACE was long enough that we are sure the frame is over and ready to process.
* 2) The buffer overflowed we have to quit. The parameter is for debugging purposes only.
*/
void IRLib_IRrecvComplete(uint8_t Reason);
#endif //IRLibRecvBase_h

130
arduino-cli/libraries/Adafruit_Circuit_Playground/utility/IRLibRecvPCI.cpp Normal file
View File

@@ -0,0 +1,130 @@
/* IRrecvPCI.cpp
* Part of IRLib Library for Arduino receiving, decoding, and sending
* infrared signals. See COPYRIGHT.txt and LICENSE.txt for more information.
*
* This module implements the IRrecvPCI receiver class which uses pin change interrupts to
* poll the input pin. This class gives more accurate results than the 50us timer based
* IRrecv but it has other limitations. It uses the Arduino "attachInterrupt()" function
* which can conflict with other libraries. Also unless you use an external buffer and
* enable auto resume this receiver occasionally fails to receive the second of 2 quickly
* sent frames. If you do not have sufficient RAM for a second buffer you should consider
* using the other two available receiver classes.
*
* This receiver is based in part on Arduino firmware for use with AnalysIR IR signal analysis
* software for Windows PCs. Many thanks to the people at http://analysir.com for their
* assistance in developing this section of code.
*/
#include "IRLibRecvPCI.h"
#include "IRLibHardware.h" //needed for IRLib_didIROut
void IRrecvPCI_Handler();//prototype for interrupt handler
/* Note that the constructor is passed the interrupt number rather than the pin number.
* WARNING: These interrupt numbers which are passed to “attachInterrupt()” are not
* necessarily identical to the interrupt numbers in the datasheet of the processor chip
* you are using. Rather it is a numbering system to the “attachInterrupt()” Arduino
* function. For more information on attachInterrupt see
* http://arduino.cc/en/Reference/AttachInterrupt
*/
IRrecvPCI::IRrecvPCI(uint8_t pin) {
init();
intrNum=digitalPinToInterrupt(pin);
recvGlobal.recvPin=pin;
}
/* Initializes receiving and attaches the pin change interrupt handler. Call this to
* initialize it again to resume receiving after completing the decoding. Previous versions
* of IRLib had a "resume" method that you should use this in either initializing or resuming.
*/
void IRrecvPCI::enableIRIn(void) {
//See comments on IRrecv::enableIRIn in "IRLibRecv.cpp" for explanation of this logic
if(recvGlobal.newDataAvailable)
return;
recvGlobal.decoderWantsData=true;//otherwise he wouldn't have called
if( (recvGlobal.currentState==STATE_FINISHED) || IRLib_didIROut ) {
IRrecvBase::enableIRIn();
recvGlobal.timer=micros();
attachInterrupt(intrNum, IRrecvPCI_Handler, CHANGE);
}
};
/* Even when not sampling inputs and recording pulse timing, the ISR remains active
* continues to interrupt every 50us however it remains in a do-nothing state. If
* the user wants to truly shut down the ISR they can call this method.
*/
void IRrecvPCI::disableIRIn(void) {
detachInterrupt(intrNum);
IRrecvBase::disableIRIn();
}
/* Returns true if a frame of data is available in the buffer. Most of the
* handling is done by the base method. Because the ISR only is active when the pin
* is changing, it may not recognize the long gap at the end of the frame so we need to
* test to see if we had a long gap. Because the ISR is active, we need to ensure
* that it doesn't change any variables while we are in the middle of accessing them.
* Unfortunately the ATOMIC_BLOCK macro that we used to use is not supported for
* SAMD 21 platforms so we have to use "noInterrupts();" and "interrupts();"
* This is only necessary for multibyte variables.
*/
bool IRrecvPCI::getResults(void) {
if(recvGlobal.newDataAvailable) {
IRrecvBase::getResults();
return true;
}
//ISR hasn't detected end of frame so if running we will take a peek
if(recvGlobal.currentState==STATE_RUNNING) {
//Only check for timeout if it is a SPACE
if(digitalRead(recvGlobal.recvPin)) {//pin high means SPACE
uint32_t changeTime; //time of the last change
noInterrupts (); //Ensure atomic access of volatile variable
changeTime=recvGlobal.timer;
interrupts(); //restore interrupts
if( (micros()-changeTime) > recvGlobal.frameTimeout) {
IRLib_IRrecvComplete(3);
IRrecvBase::getResults();
return true;
}
}
}
return false;
};
/* This is the interrupt handler used by this class. It is called every time the input
* pin changes from high to low or from low to high. The initial state of the state machine
* is STATE_READY_TO_BEGIN. It waits until it sees a MARK before it switches to
* STATE_RUNNING. Each subsequent interrupt it computes the time since the previous
* interrupt. If it notices a SPACE is especially long then it calls IRLib_IRrecvComplete
* which sets the proper flags to say that we had received data and implements
* auto resume if enabled. The state STATE_FINISHED means that interrupts are continuing
* however the receiver isn't ready for more data.
*/
void IRrecvPCI_Handler(){
uint32_t volatile changeTime=micros();
uint32_t deltaTime=changeTime-recvGlobal.timer;
switch(recvGlobal.currentState) {
case STATE_FINISHED: return;
case STATE_RUNNING:
IRLib_doBlink();
if( !(recvGlobal.recvLength & 1) ){
if (deltaTime>recvGlobal.frameTimeout) {
IRLib_IRrecvComplete(1);//all finished, reset and possibly do auto resume
return;//don't record final space
}
}
break;
case STATE_READY_TO_BEGIN:
if(digitalRead(recvGlobal.recvPin)) {//pin high means SPACE
return;//don't start until we get a MARK
} else {
recvGlobal.currentState=STATE_RUNNING;
}
break;
};
recvGlobal.recvBuffer[recvGlobal.recvLength]=deltaTime;
recvGlobal.timer=changeTime;
if(++recvGlobal.recvLength>=RECV_BUF_LENGTH) {//buffer overflows so we quit
IRLib_IRrecvComplete(2);
}
}

35
arduino-cli/libraries/Adafruit_Circuit_Playground/utility/IRLibRecvPCI.h Normal file
View File

@@ -0,0 +1,35 @@
/* IRLibRecvPCI.h
* Part of IRLib Library for Arduino receiving, decoding, and sending
* infrared signals. See COPYRIGHT.txt and LICENSE.txt for more information.
*
* You should include this header in your sketch if you're using the IRLibRecvPCI
* receiver class which uses pin change interrupts to poll the input pin.
* This version gives more accurate results than the 50us timer based IRrecv but it has
* other limitations. It uses the Arduino "attachInterrupt()" function which can conflict
* with other libraries. Also unless you use an external buffer and enable auto resume
* this receiver occasionally fails to receive the second of 2 quickly sent frames.
* If you do not have sufficient RAM for a second buffer you should consider using the
* other two available receiver classes.
* Applications that do sending only SHOULD NOT include this header.
*
* This receiver is based in part on Arduino firmware for use with AnalysIR IR signal analysis
* software for Windows PCs. Many thanks to the people at http://analysir.com for their
* assistance in developing this section of code.
*/
#ifndef IRLibRecvPCI_h
#define IRLibRecvPCI_h
#include "IRLibRecvBase.h"
class IRrecvPCI: public IRrecvBase {
public:
IRrecvPCI(void){}; //Use only when receiver object is part of larger object.
// Still must initialize using constructor below.
IRrecvPCI(uint8_t pin);
void enableIRIn(void); //call to initialize or resume receiving
bool getResults(void); //returns true if new frame of data has been received
void disableIRIn(void); //ISR runs continuously once started. Use this if you want to stop.
private:
uint8_t intrNum;
};
#endif //IRLibRecvPCI_h

70
arduino-cli/libraries/Adafruit_Circuit_Playground/utility/IRLibSAMD21.cpp Normal file
View File

@@ -0,0 +1,70 @@
/* IRLibSAMD21.h
* Part of IRLib Library for Arduino receiving, decoding, and sending
* infrared signals. See COPYRIGHT.txt and LICENSE.txt for more information.
*
* This type of content is normally stored in IRLibHardware.h but we have
* moved at her because the SAMD21 support is significantly different than the
* AVR 8-bit hardware support. Separating it out into a separate file
* will make it easier to include comments and to maintain the code.
*/
/* See IRLibSAMD21.h for details about this implementation.
*/
#if defined (__SAMD21G18A__)
#include "IRLibHardware.h"
//Save some typing
#define IR_APD g_APinDescription[IR_SEND_PWM_PIN]
void initializeSAMD21PWM(uint16_t khz) {
// Enable the port multiplexer for the PWM channel on pin
PORT->Group[IR_APD.ulPort].PINCFG[IR_APD.ulPin].bit.PMUXEN = 1;
// Connect the TCC timer to the port outputs - port pins are paired odd PMUXO and even PMUXE
// F & E peripherals specify the timers: TCC0, TCC1 and TCC2
PORT->Group[IR_APD.ulPort].PMUX[IR_APD.ulPin >> 1].reg |= IR_MUX_EF;
// Feed GCLK0 to TCC0 and TCC1
REG_GCLK_CLKCTRL = GCLK_CLKCTRL_CLKEN | // Enable GCLK0 to TCC0 and TCC1
GCLK_CLKCTRL_GEN_GCLK0 | // Select GCLK0
GCLK_CLKCTRL_ID_TCC0_TCC1; // Feed GCLK0 to TCC0 and TCC1
syncGCLK; // Wait for synchronization
// Normal (single slope) PWM operation: timers countinuously count up to PER
// register value and then is reset to 0
IR_TCCx->WAVE.reg |= TCC_WAVE_WAVEGEN_NPWM; // Setup single slope PWM on TCCx
while (IR_TCCx->SYNCBUSY.bit.WAVE); // Wait for synchronization
// Each timer counts up to a maximum or TOP value set by the PER register,
// this determines the frequency of the PWM operation.
uint32_t cc = F_CPU/(khz*1000) - 1;
IR_TCCx->PER.reg = cc; // Set the frequency of the PWM on IR_TCCx
while(IR_TCCx->SYNCBUSY.bit.PER);
// The CCx register value corresponds to the pulsewidth in microseconds (us)
IR_TCCx->CC[(IR_CCn & 0x03)].reg = cc/3; // Set the duty cycle of the PWM on TCC0 to 33%
while(IR_TCCx->SYNCBUSY.bit.IR_CCx);
// Enable IR_TCCx timer but do not turn on PWM yet. Will turn it on later.
IR_TCCx->CTRLA.reg |= TCC_CTRLA_PRESCALER_DIV1; // Divide GCLK0 by 1
while (IR_TCCx->SYNCBUSY.bit.ENABLE);
IR_TCCx->CTRLA.reg &= ~TCC_CTRLA_ENABLE; //initially off will turn on later
while (IR_TCCx->SYNCBUSY.bit.ENABLE);
}
/*
* Setup the 50 microsecond timer hardware interrupt for the IRrecv class.
*/
void initializeSAMD21timerInterrupt(void) {
GCLK->CLKCTRL.reg = (uint16_t)(GCLK_CLKCTRL_CLKEN |
GCLK_CLKCTRL_GEN_GCLK0 |
GCLK_CLKCTRL_ID(IR_GCM));
syncGCLK;
IR_TCx->COUNT16.CTRLA.reg &= ~TC_CTRLA_ENABLE;
syncTC;
IR_TCx->COUNT16.CTRLA.reg = TC_CTRLA_SWRST;
while (IR_TCx->COUNT16.CTRLA.bit.SWRST);
IR_TCx->COUNT16.CTRLA.reg |= TC_CTRLA_MODE_COUNT16;
IR_TCx->COUNT16.CTRLA.reg |= TC_CTRLA_WAVEGEN_MFRQ;
IR_TCx->COUNT16.CC[0].reg = F_CPU/(1000000/USEC_PER_TICK) - 1;
syncTC;
}
#endif

240
arduino-cli/libraries/Adafruit_Circuit_Playground/utility/IRLibSAMD21.h Normal file
View File

@@ -0,0 +1,240 @@
/* IRLibSAMD21.h
* Part of IRLib Library for Arduino receiving, decoding, and sending
* infrared signals. See COPYRIGHT.txt and LICENSE.txt for more information.
*
* This type of content is normally stored in IRLibHardware.h but we have
* moved at her because the SAMD21 support is significantly different than the
* AVR 8-bit hardware support. Separating it out into a separate file
* will make it easier to include comments and to maintain the code.
*/
/* This file provides hardware support for the SAMD21G18A processor or as we
* will refer to it simply as SAMD 21. This processor is used in the Arduino Zero,
* Arduino M0, Arduino M0 Pro, and the Adafruit Feather M0 series boards as well as
* the upcoming Adafruit Circuit Playground Express.
* Most of the code has been adapted from messages on the Arduino.cc support forum
* and from the code at:
* https://github.com/manitou48/ZERO/tree/master/IRtest
* Receiving is supported through all three receiver classes. As you would expect
* the IRrecvLoop class can be used with any available input pin. The IRrecvPCI and
* IRfrequency classes can be used on any pin that supports "attachInterrupt()".
* Specifically that means everything except pin 4 on the Arduino Zero. And everything
* except pin 2 on the boards from Arduino.org such as the Arduino M0, M0 Pro, and
* Zero Pro. For details on supported pins see these links:
* https://www.arduino.cc/en/Reference/AttachInterrupt
* http://www.arduino.org/learning/reference/AttachInterrupt
* Note that although we support Arduino.org hardware, you should only use the
* Arduino.cc IDE for compiling your sketches.
* Both sending and receiving use GCLK0 even though GCLK0-GCLK3 are generally reserved
* the Arduino infrastructure. However we are using the default 48 MHz clock source
* and a divisor of "1" so we aren't changing any of the GCLK0 set up. It's therefore
* safe to use.
* The IRrecv receiver class using a 50 microsecond timer interrupt is also supported.
* It defaults to using hardware timer TC3 however TC4 and TC5 can also be used in case
* of conflicts with other libraries. The IRrecv and IRrecvLoop classes should be able to use
* any available input pin. Note that all of our example sketches used pin 2 for
* receiver and pin 3 for frequency measurement. However pin 2 is not available for PCI
* interrupts on the Arduino.org platforms and neither 2 nor 3 are available on the
* Adafruit Feather M0 platforms. We are recommending using 5 and 6 for receiving and
* frequency measurement respectively.
* For sending, you can use any pin that supports PWM on your particular
* platform. On Arduino Zero that means pins 3, 4, 5, 6, 8, 9, 10, 11, 12, or 13.
* Additionally Arduino M0 Pro adds pins 2 and 7 to that list. In all cases the default
* output pin is 9. The code automatically selects TCC0 or TCC1 based on pin number
* as needed. It has been tested at frequencies of 36, 38, 39, 40 and 57 which
* are the frequencies of our supported protocols.
* As of this release the code has been tested on Arduino Zero, Arduino M0 Pro, and
* Adafruit Feather M0 BLE version.
*/
#ifndef IRLibSAMD21_h
#define IRLibSAMD21_h
/*
* This section contains user changeable values. You can probably stick with the defaults
* but if there are hardware conflicts with other libraries, you can change these values.
*/
//Choose PWM output pin number from among the following
//Un-comment only one of these.
//#define IR_SEND_PWM_PIN 2
//#define IR_SEND_PWM_PIN 3
//#define IR_SEND_PWM_PIN 4
//#define IR_SEND_PWM_PIN 5
//#define IR_SEND_PWM_PIN 6
//#define IR_SEND_PWM_PIN 7
//#define IR_SEND_PWM_PIN 8
//#define IR_SEND_PWM_PIN 9
//#define IR_SEND_PWM_PIN 10
//#define IR_SEND_PWM_PIN 11
#define IR_SEND_PWM_PIN 12
//#define IR_SEND_PWM_PIN 13
//Override default for Adafruit Circuit Playground Express
#ifdef ARDUINO_SAMD_CIRCUITPLAYGROUND_EXPRESS
#define IR_SEND_PWM_PIN 25
#endif
//Choose which timer counter to use for the 50 microsecond interrupt
//Un-comment only one of these.
#define IR_TCn 3
//#define IR_TCn 4
//#define IR_TCn 5
/*
* Everything below this point should not be changed. It computes needed defines
* based on the user set values above.
*/
// Saves us a lot of typing when synchronizing
#define syncTC while (IR_TCx->COUNT16.STATUS.bit.SYNCBUSY)
#define syncGCLK while (GCLK->STATUS.bit.SYNCBUSY)
#if defined(ARDUINO_SAMD_FEATHER_M0)
#if ( (IR_SEND_PWM_PIN<5) || (IR_SEND_PWM_PIN==7) || (IR_SEND_PWM_PIN==8) )
#error "Pin unsupported on Adafruit Feather M0"
#endif
#endif
//Pins 8 and 9 use TCC1 and all others use TCC0
#if ( (IR_SEND_PWM_PIN==8) || (IR_SEND_PWM_PIN==9) )
#define IR_TCCx TCC1
#else
#define IR_TCCx TCC0
#endif
//Although there are 8 WO there are only 4 CC
#define CC4 CC0
#define CC5 CC1
#define CC6 CC2
#define CC7 CC3
//Set other values based on pin number
#if (IR_SEND_PWM_PIN==2)
//NOTE: Arduino M0 Pro only
#if defined(ARDUINO_SAM_ZERO)
//PA08 E:TCC0-WO[0] F:TCC1-WO[2]
#define IR_MUX_EF PORT_PMUX_PMUXE_E
#define IR_CCx CC0
#define IR_CCn 0
#else
#error "Pin 2 only available on Arduino M0 Pro"
#endif
#elif (IR_SEND_PWM_PIN==3)
//PA09 E:TCC0-WO[1] F:TCC1-WO[3]
#define IR_MUX_EF PORT_PMUX_PMUXO_E
#define IR_CCx CC1
#define IR_CCn 1
#elif (IR_SEND_PWM_PIN==4)
//Arduino M0 Pro swaps pins 2 and 4
#if(ARDUINO_SAM_ZERO)
//Arduino M0 Pro
//PA09 E:TC3-WO[0] F:TCC0-WO[4]
#define IR_MUX_EF PORT_PMUX_PMUXE_F
#define IR_CCx CC4
#define IR_CCn 4
#else
//Arduino Zero
//PA08 E:TCC0-WO[0] F:TCC1-WO[2]
#define IR_MUX_EF PORT_PMUX_PMUXE_E
#define IR_CCx CC0
#define IR_CCn 0
#endif
#elif (IR_SEND_PWM_PIN==5)
//PA15 E:TC3-WO[1] F:TCC0-WO[5]
#define IR_MUX_EF PORT_PMUX_PMUXO_F
#define IR_CCx CC5
#define IR_CCn 5
#elif (IR_SEND_PWM_PIN==6)
//PA20 E:TC7-WO[0] F:TCC0-WO[6]
#define IR_MUX_EF PORT_PMUX_PMUXE_F
#define IR_CCx CC6
#define IR_CCn 6
#elif (IR_SEND_PWM_PIN==7)
//NOTE: Arduino M0 Pro only
#if defined(ARDUINO_SAM_ZERO)
//PA08 E:TC7-WO[1] F:TCC0-WO[7]
#define IR_MUX_EF PORT_PMUX_PMUXO_F
#define IR_CCx CC7
#define IR_CCn 7
#else
#error "Pin 7 only available on Arduino M0 Pro"
#endif
#elif (IR_SEND_PWM_PIN==8)
//PA06 E:TCC1-WO[0] F:--
#define IR_MUX_EF PORT_PMUX_PMUXE_E
#define IR_CCx CC0
#define IR_CCn 0
#elif (IR_SEND_PWM_PIN==9)
//PA07 E:TCC1-WO[1] F:--
#define IR_MUX_EF PORT_PMUX_PMUXO_E
#define IR_CCx CC1
#define IR_CCn 1
#elif (IR_SEND_PWM_PIN==10)
//PA18 E:TC3-WO[0] F:TCC0-WO[2]
#define IR_MUX_EF PORT_PMUX_PMUXE_F
#define IR_CCx CC2
#define IR_CCn 2
#elif (IR_SEND_PWM_PIN==11)
//PA16 E:TCC2-WO[0] F:TCC0-WO[6]
#define IR_MUX_EF PORT_PMUX_PMUXE_F
#define IR_CCx CC6
#define IR_CCn 6
#elif (IR_SEND_PWM_PIN==12)
//PA19 E:TC3-WO[1] F:TCC0-WO[3]
#define IR_MUX_EF PORT_PMUX_PMUXO_F
#define IR_CCx CC3
#define IR_CCn 3
#elif (IR_SEND_PWM_PIN==13)
//PA17 E:TCC2-WO[1] F:TCC0-WO[7]
#define IR_MUX_EF PORT_PMUX_PMUXO_F
#define IR_CCx CC7
#define IR_CCn 7
#elif (IR_SEND_PWM_PIN==25)//Adafruit Circuit Playground Express only
//PA23 E:TC4-WO[1] F:TCC0-WO[5]
#define IR_MUX_EF PORT_PMUX_PMUXO_F
#define IR_CCx CC5
#define IR_CCn 5
#else
#error "Invalid SAMD21 PWM pin"
#endif
// Turns PWM on and off after already set up
#define IR_SEND_PWM_START {IR_TCCx->CTRLA.reg |= TCC_CTRLA_ENABLE;\
while (IR_TCCx->SYNCBUSY.bit.ENABLE);}
#define IR_SEND_MARK_TIME(time) IRLibDelayUSecs(time)
#define IR_SEND_PWM_STOP {IR_TCCx->CTRLA.reg &= ~TCC_CTRLA_ENABLE;\
while (IR_TCCx->SYNCBUSY.bit.ENABLE);}
#define IR_SEND_CONFIG_KHZ(val) initializeSAMD21PWM(val);
/* These are the definitions for setting up the 50 microsecond
* timer interrupt for the IRrecv class.
*/
#if (IR_TCn==3)
#define IR_TCx TC3
#define IR_GCM GCM_TCC2_TC3
#define IR_RECV_INTR_NAME void TC3_Handler()
#define IR_IRQ TC3_IRQn
#elif (IR_TCn==4)
#define IR_TCx TC4
#define IR_GCM GCM_TC4_TC5
#define IR_RECV_INTR_NAME void TC4_Handler()
#define IR_IRQ TC4_IRQn
#elif (IR_TCn==5)
#define IR_TCx TC5
#define IR_GCM GCM_TC4_TC5
#define IR_RECV_INTR_NAME void TC5_Handler()
#define IR_IRQ TC5_IRQn
#else
#error "Invalid IR_TCn value"
#endif
#define IR_RECV_ENABLE_INTR ({NVIC_EnableIRQ(IR_IRQ);\
IR_TCx->COUNT16.INTENSET.reg = TC_INTENSET_OVF;\
IR_TCx->COUNT16.CTRLA.reg |= TC_CTRLA_ENABLE; syncTC;})
#define IR_RECV_DISABLE_INTR IR_TCx->COUNT16.INTENCLR.reg = TC_INTENCLR_OVF;
#define IR_RECV_CONFIG_TICKS() initializeSAMD21timerInterrupt()
//Clear interrupt
#define IR_CLEAR_INTERRUPT IR_TCx->COUNT16.INTFLAG.bit.MC0 = 1;
//prototypes
void initializeSAMD21PWM(uint16_t khz);
void initializeSAMD21timerInterrupt(void);
#endif //IRLibSAMD21_h

110
arduino-cli/libraries/Adafruit_Circuit_Playground/utility/IRLibSendBase.cpp Normal file
View File

@@ -0,0 +1,110 @@
/* IRLibSendBase.cpp
* Part of IRLib Library for Arduino receiving, decoding, and sending
* infrared signals. See COPYRIGHT.txt and LICENSE.txt for more information.
*/
/*
* This module contains the base classes for sending. You will not create instances
* of these classes, rather you will use them as base classes in creating derived
* protocol specific decoders. Each protocol specific send class begins
* by calling enableIROut(uint8_t kHz) to set the carrier frequency.
* It then calls mark(int usec) and space(inc usec) to transmit marks and
* spaces of varying length of microseconds in the manner which the protocol defines.
*/
#if !defined(ARDUINO_NRF52840_CIRCUITPLAY)
#include "IRLibSendBase.h"
#include "IRLibHardware.h"
/*
* Most of the protocols have a header consisting of a mark/space of a particular length followed by
* a series of variable length mark/space signals. Depending on the protocol they very the lengths of the
* mark or the space to indicate a data bit of "0" or "1". Most also end with a stop bit of "1".
* The basic structure of the sending and decoding these protocols led to lots of redundant code.
* Therefore I have implemented generic sending and decoding routines. You just need to pass a bunch of customized
* parameters and it does the work. This reduces compiled code size with only minor speed degradation.
* You may be able to implement new protocols by simply passing the proper values to these generic routines.
* The decoding routines do not encode stop bits. So you have to tell this routine whether or not to send one.
* Some protocols have a fixed amount of space between frames while others require that the entire frame
* be a particularly length despite the fact that the data transmission time may be veritable. Pass this
* frame length of time the parameter maxExtent. It's default value is zero.
*/
void IRsendBase::sendGeneric(uint32_t data, uint8_t numBits, uint16_t headMark, uint16_t headSpace,
uint16_t markOne, uint16_t markZero, uint16_t spaceOne, uint16_t spaceZero,
uint8_t kHz, bool useStop, uint32_t maxExtent) {
extent=0;
data = data << (32 - numBits);
enableIROut(kHz);
//Some protocols do not send a header when sending repeat codes. So we pass a zero value to indicate skipping this.
if(headMark) mark(headMark);
if(headSpace) space(headSpace);
for (uint8_t i = 0; i <numBits; i++) {
if (data & TOPBIT) {
mark(markOne); space(spaceOne);
}
else {
mark(markZero); space(spaceZero);
}
data <<= 1;
}
if(useStop) mark(markOne); //stop bit of "1"
if(maxExtent) {
#ifdef IRLIB_TRACE
Serial.print("maxExtent="); Serial.println(maxExtent);
Serial.print("extent="); Serial.println(extent);
Serial.print("Difference="); Serial.println(maxExtent-extent);
#endif
space(maxExtent-extent);
}
else space(spaceOne);
};
void IRsendBase::enableIROut(uint8_t khz) {
//NOTE: the comments on this routine accompanied the original early version of IRremote library
//which only used TIMER2. The parameters defined in IRLibTimer.h may or may not work this way.
// Enables IR output. The khz value controls the modulation frequency in kilohertz.
// The IR output will be on pin 3 (OC2B).
// This routine is designed for 36-40KHz; if you use it for other values, it's up to you
// to make sure it gives reasonable results. (Watch out for overflow / underflow / rounding.)
// TIMER2 is used in phase-correct PWM mode, with OCR2A controlling the frequency and OCR2B
// controlling the duty cycle.
// There is no prescaling, so the output frequency is 16MHz / (2 * OCR2A)
// To turn the output on and off, we leave the PWM running, but connect and disconnect the output pin.
// A few hours staring at the ATmega documentation and this will all make sense.
// See my Secrets of Arduino PWM at http://www.righto.com/2009/07/secrets-of-arduino-pwm.html for details.
// Disable the Timer2 Interrupt (which is used for receiving IR)
IRLib_didIROut=true; //Tell the receiver we probably trashed his timer settings
IR_RECV_DISABLE_INTR; //Timer2 Overflow Interrupt
pinMode(IR_SEND_PWM_PIN, OUTPUT);
digitalWrite(IR_SEND_PWM_PIN, LOW); // When not sending PWM, we want it low
IR_SEND_CONFIG_KHZ(khz);
}
IRsendBase::IRsendBase () {
pinMode(IR_SEND_PWM_PIN, OUTPUT);
digitalWrite(IR_SEND_PWM_PIN, LOW); // When not sending PWM, we want it low
}
//The Arduino built in function delayMicroseconds has limits we wish to exceed
//Therefore we have created this alternative
void IRLibDelayUSecs(uint16_t time) {
if(time){if(time>16000) {delayMicroseconds(time % 1000); delay(time/1000); } else delayMicroseconds(time);};
}
void IRsendBase::mark(uint16_t time) {
IR_SEND_PWM_START;
IR_SEND_MARK_TIME(time);
extent+=time;
}
void IRsendBase::space(uint16_t time) {
IR_SEND_PWM_STOP;
IRLibDelayUSecs(time);
extent+=time;
}
#endif //!defined(__NRF52__)

33
arduino-cli/libraries/Adafruit_Circuit_Playground/utility/IRLibSendBase.h Normal file
View File

@@ -0,0 +1,33 @@
/* IRLibSendBase.h
* Part of IRLib Library for Arduino receiving, decoding, and sending
* infrared signals. See COPYRIGHT.txt and LICENSE.txt for more information.
*/
/*
* This module contains the base classes for sending. You will not create instances
* of these classes, rather you will use them as base classes in creating derived
* protocol specific decoders. Each protocol specific send class begins
* by calling enableIROut(uint8_t kHz) to set the carrier frequency.
* It then calls mark(int usec) and space(inc usec) to transmit marks and
* spaces of varying length of microseconds in the manner which the protocol defines.
*/
#ifndef IRLIBSENDBASE_H
#define IRLIBSENDBASE_H
#include "IRLibProtocols.h"
class IRsendBase {
public:
IRsendBase();
void sendGeneric(uint32_t data, uint8_t numBits, uint16_t headMark, uint16_t headSpace,
uint16_t markOne, uint16_t markZero, uint16_t spaceOne, uint16_t spaceZero,
uint8_t kHz, bool stopBits, uint32_t maxExtent=0);
protected:
void enableIROut(uint8_t khz);
void mark(uint16_t usec);
void space(uint16_t usec);
uint32_t extent;
uint8_t onTime,offTime,iLength;//used by bit-bang output.
};
#endif //IRLIBSENDBASE_H

54
arduino-cli/libraries/Adafruit_Circuit_Playground/utility/IRLib_COPYRIGHT.txt Normal file
View File

@@ -0,0 +1,54 @@
Copyright information for IRLib – an Arduino library for
infrared encoding and decoding
IRLib2 is a collection of libraries which we will collectively referred
to as the PACKAGE. The PACKAGE consists of all files in the IRLib2,
IRLibFreq, IRLibRecv, IRLibRecvPCI, and IRLibProtocols folders.
The PACKAGE is Copyright (c) 2014-2017 by Chris Young
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
(at your option) 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.
These files will be maintained at https://github.com/cyborg5/IRLib2
Documentation and other support info at http://tech.cyborg5.com/irlib
This is an updated version of my original IRLib which is still available at
https://github.com/cyborg5/IRLib which will not be updated after this
PACKAGE has its first stable non-beta release.
Both libraries are derived from the original source code in a library called
IRemote by Ken Shirriff which was covered by GNU LESSER GENERAL PUBLIC
LICENSE version 2.1. This package is covered by the GNU GENERAL PUBLIC
LICENSE 3.0. See LICENSE.txt for a copy of that license or visit
https://www.gnu.org/licenses/
As I understand these licenses it is permissible to upgrade the license
this way. Additionally this license change was made with the approval of
Mr. Shirriff in an email conversation I had with him. In accord with his
wishes and out of respect for his work, his original copyright message is
shown below.
/*
* IRremote
* Version 0.1 July, 2009
* Copyright 2009 Ken Shirriff
* For details, see http://www.righto.com/2009/08/multi-protocol-infrared-remote-library.html http://www.righto.com/
*
* Interrupt code based on NECIRrcv by Joe Knapp
* http://www.arduino.cc/cgi-bin/yabb2/YaBB.pl?num=1210243556
* Also influenced by http://zovirl.com/2008/11/12/building-a-universal-remote-with-an-arduino/
*/
We also acknowledge and thank the developers of the AnalysIR program. AnalysIR is a Windows-based application which allows you to graphically analyze IR input signals through an Arduino, Raspberry Pi or other microcontrollers systems. The frequency analysis and other PCI based versions of the program are based upon and inspired by their work. We value their input into the development of that portion of the code. You can find more about their software at http://analysir.com
We also knowledge and thank programmer Gabriel Staples contributed bug fixes and an earlier version of the auto resume feature. Although much of his code was rewritten it could not have been possible without his contributions.
Other major contributors will be acknowledged in this file in the future.

84
arduino-cli/libraries/Adafruit_Circuit_Playground/utility/IRLib_HashRaw.h Normal file
View File

@@ -0,0 +1,84 @@
/* IRLib_P00_HashRaw.h
* Part of IRLib Library for Arduino receiving, decoding, and sending
* infrared signals. See COPYRIGHT.txt and LICENSE.txt for more information.
*/
/*
* If you have a protocol which is unsupported by this library, you can still receive
* and transmit the data. You can store the raw data values in a buffer and retransmit the
* data exactly as you received it. Of course it takes a lot of memory to store such data
* so it is inefficient but it is better than nothing.
* If all you need to do is detect a unique value for an unsupported protocol and you do
* not need to resend the data, you can use the hash code decoder. It looks at the
* array of raw timing values and create a 32 bit value based on the data. It is
* highly likely to be unique however you cannot reverse engineer the process.
* You cannot re-create the original data stream for 32 bit hash code.
* This module also implements the raw send method. You have to have the original
* timing values.
*/
#ifndef IRLIB_HASHRAW_H
#define IRLIB_HASHRAW_H
#define IR_SEND_RAW case 0: IRsendRaw::send((uint16_t*)data,data2,khz); break;
#define IR_DECODE_HASH if(IRdecodeHash::decode()) return true;
#ifdef IRLIB_HAVE_COMBO
#define PV_IR_DECODE_HASH ,public virtual IRdecodeHash
#define PV_IR_SEND_RAW ,public virtual IRsendRaw
#else
#define PV_IR_DECODE_HASH public virtual IRdecodeHash
#define PV_IR_SEND_RAW public virtual IRsendRaw
#endif
#ifdef IRLIBSENDBASE_H
/* The first parameter to the "IRendRaw" method is a pointer to the first element of an
* array of uint16_t values. These values are the raw timing values in microseconds. Note
* it is possible to simply pass "(uint16_t*) &My_Decoder.decodeBuffer[1]" if you have just
* received a code and wish to echo it. You have to point to the index "1" because index "0"
* of that buffer contains the gap between successive frames data and it should be ignored.
* If the frequency to be used in transmission is not specified, it defaults to 38kHz.
*/
class IRsendRaw: public virtual IRsendBase {
public:
void send(uint16_t *buf, uint8_t len, uint8_t khz) {
enableIROut(khz);
for (uint8_t i = 0; i < len; i++) {
if (i & 1) {
space(buf[i]);
}
else {
mark(buf[i]);
}
}
space(0); // Just to be sure
}
};
#endif //IRLIBSENDBASE_H
#ifdef IRLIBDECODEBASE_H
/* This Hash decoder is based on IRhashcode Copyright 2010 Ken Shirriff
* For details see http://www.righto.com/2010/01/using-arbitrary-remotes-with-arduino.html
* Use FNV hash algorithm: http://isthe.com/chongo/tech/comp/fnv/#FNV-param
* Converts the raw code values into a 32-bit hash code.
* Hopefully this code is unique for each button.
*/
#define FNV_PRIME_32 16777619
#define FNV_BASIS_32 2166136261
// Compare two tick values, return 0 if v1 is lower, 1 if equal, and 2 if v2 is higher
#define TICKS_COMPARE(v1,v2) ( (v2< v1*0.8)?0:( (v1< v2*0.8)?2:1) )
class IRdecodeHash: public virtual IRdecodeBase {
public:
bool decode(void) {
value = FNV_BASIS_32;
for (int i = 1; i+2 < recvGlobal.decodeLength; i++) {
value = (value * FNV_PRIME_32) ^ TICKS_COMPARE(recvGlobal.decodeBuffer[i], recvGlobal.decodeBuffer[i+2]);
}
protocolNum = UNKNOWN;
bits= (recvGlobal.decodeLength-3)/2;//Estimated number of bits of unknown protocol
//Note that value is always 32 bit hash code.
return true;
}
};
#endif //IRLIBDECODEBASE_H
#define IRLIB_HAVE_COMBO
#endif //IRLIB_HASHRAW_H

80
arduino-cli/libraries/Adafruit_Circuit_Playground/utility/IRLib_P01_NEC.h Normal file
View File

@@ -0,0 +1,80 @@
/* IRLib_P01_NEC.h
* Part of IRLib Library for Arduino receiving, decoding, and sending
* infrared signals. See COPYRIGHT.txt and LICENSE.txt for more information.
*/
/*
* NEC is an extremely common protocol. There are two variations NEC1 and NEC2.
* They differ only in the way in which they handle repeat codes. If you hold a button
* using NEC1 it does not repeat the same sequence. Rather it sends a special sequence
* consisting of the usual header mark, a half-size header space, a normal mark.
* When IRLib receives one of these special repeat sequences, it returns the
* value REPEAT_CODE which is defined in IRLibProtocols.h as the value 0xffffffff. If you
* send REPEAT_CODE, the send routine will create a special sequence for you.
* NOTE that the timing for this special did sequence is nearly identical to a ditto
* used by the G.I.Cable protocol and IRLib generally not distinguish between the two.
* The header timing for G.I. Cable ditto is 8820,1960 and for NEC is 9024,2256
* If you are using both protocols and you receive an NEC ditto immediately after
* receiving a G.I.Cable then you should presume it is a G.I.Cable and vice versa.
* Whether it is a normal code or a repeat code the entire frame has a 108ms extent.
* The IRP notation for these protocols are:
* NEC1: {38k,564}<1,-1|1,-3>(16,-8,D:8,S:8,F:8,~F:8,1,^108,(16,-4,1,^108)*)
* NEC2: {38k,564}<1,-1|1,-3>(16,-8,D:8,S:8,F:8,~F:8,1,^108)+
* Other protocols use the same timing and 32 bits of data but they interpret the data fields
* differently. These include Apple and TiVo. Also Pioneer protocol is identical to NEC2
* however uses 40k rather than 38k modulation. Pioneer sometimes requires a 2 frame
* sequence of different data for a single pushbutton function. The optional 2nd
* parameter to the "send" method allows you to change the frequency from the default 38.
*/
#ifndef IRLIB_PROTOCOL_01_H
#define IRLIB_PROTOCOL_01_H
#define IR_SEND_PROTOCOL_01 case 1: if(data2==0)data2=38;IRsendNEC::send(data,data2); break;
#define IR_DECODE_PROTOCOL_01 if(IRdecodeNEC::decode()) return true;
#ifdef IRLIB_HAVE_COMBO
#define PV_IR_DECODE_PROTOCOL_01 ,public virtual IRdecodeNEC
#define PV_IR_SEND_PROTOCOL_01 ,public virtual IRsendNEC
#else
#define PV_IR_DECODE_PROTOCOL_01 public virtual IRdecodeNEC
#define PV_IR_SEND_PROTOCOL_01 public virtual IRsendNEC
#endif
#ifdef IRLIBSENDBASE_H
class IRsendNEC: public virtual IRsendBase {
public:
void send(uint32_t data, uint8_t kHz=38) {
if (data==REPEAT_CODE) {
enableIROut(kHz);
mark (564* 16); space(564*4); mark(564);space(572);delay(97);//actually 97572us
} else {
sendGeneric(data,32, 564*16, 564*8, 564, 564, 564*3, 564, kHz, true,108000);
}
};
};
#endif //IRLIBSENDBASE_H
#ifdef IRLIBDECODEBASE_H
class IRdecodeNEC: public virtual IRdecodeBase {
public:
bool decode(void) {
resetDecoder();//This used to be in the receiver getResults.
IRLIB_ATTEMPT_MESSAGE(F("NEC repeat"));
// Check for repeat
if (recvGlobal.decodeLength == 4 && MATCH(recvGlobal.decodeBuffer[1],564*16) && MATCH(recvGlobal.decodeBuffer[2],564*4)
&& MATCH(recvGlobal.decodeBuffer[3],564)) {
bits = 0;
value = REPEAT_CODE;
protocolNum = NEC;
return true;
}
IRLIB_ATTEMPT_MESSAGE(F("NEC"));
if(!decodeGeneric(68, 564*16, 564*8, 564, 564*3, 564)) return false;
protocolNum = NEC;
return true;
}
};
#endif //IRLIBDECODEBASE_H
#define IRLIB_HAVE_COMBO
#endif //IRLIB_PROTOCOL_01_H

72
arduino-cli/libraries/Adafruit_Circuit_Playground/utility/IRLib_P02_Sony.h Normal file
View File

@@ -0,0 +1,72 @@
/* IRLib_P02_Sony.h
* Part of IRLib Library for Arduino receiving, decoding, and sending
* infrared signals. See COPYRIGHT.txt and LICENSE.txt for more information.
*/
/*
* Sony is backwards from most protocols. It uses a variable length mark and a fixed length
* space rather than a fixed mark and a variable space. Our generic send will still work
* however we need a custom decoding routine because it's difficult to get the generic
* decoder to handle a variable length mark without cluttering up the code to much.
* According to the protocol you must send Sony commands at least three times so we
* automatically do it here. Sony can be 8, 12, 15, or 20 bits in length.
* The 8 bit version uses a shorter trailing space at the end. The signal is modulated
* at 40 kHz however most 38 kHz receivers are broad enough to receive it.
*/
#ifndef IRLIB_PROTOCOL_02_H
#define IRLIB_PROTOCOL_02_H
#define IR_SEND_PROTOCOL_02 case 2: IRsendSony::send(data,data2); break;
#define IR_DECODE_PROTOCOL_02 if(IRdecodeSony::decode()) return true;
#ifdef IRLIB_HAVE_COMBO
#define PV_IR_DECODE_PROTOCOL_02 ,public virtual IRdecodeSony
#define PV_IR_SEND_PROTOCOL_02 ,public virtual IRsendSony
#else
#define PV_IR_DECODE_PROTOCOL_02 public virtual IRdecodeSony
#define PV_IR_SEND_PROTOCOL_02 public virtual IRsendSony
#endif
#ifdef IRLIBSENDBASE_H
class IRsendSony: public virtual IRsendBase {
public:
void send(uint32_t data, uint8_t nbits) {
for(uint8_t i=0; i<3;i++){
sendGeneric(data,nbits, 600*4, 600, 600*2, 600, 600, 600, 40, false,45000);
}
}
};
#endif //IRLIBSENDBASE_H
#ifdef IRLIBDECODEBASE_H
class IRdecodeSony: public virtual IRdecodeBase {
public:
virtual bool decode(void) {
IRLIB_ATTEMPT_MESSAGE(F("Sony"));
resetDecoder();//This used to be in the receiver getResults.
if(recvGlobal.decodeLength!=2*8+2 && recvGlobal.decodeLength!=2*12+2 && recvGlobal.decodeLength!=2*15+2
&& recvGlobal.decodeLength!=2*20+2) return RAW_COUNT_ERROR;
if(!ignoreHeader) {
if (!MATCH(recvGlobal.decodeBuffer[1],600*4)) return HEADER_MARK_ERROR(600*4);
}
offset=2;//skip initial gap plus header Mark.
while (offset < recvGlobal.decodeLength) {
if (!MATCH(recvGlobal.decodeBuffer[offset],600)) return DATA_SPACE_ERROR(600);
offset++;
if (MATCH(recvGlobal.decodeBuffer[offset],600*2)) {
value = (value << 1) | 1;
}
else if (MATCH(recvGlobal.decodeBuffer[offset],600)) {
value <<= 1;
}
else return DATA_MARK_ERROR(600);
offset++;
}
bits = (offset - 1) / 2;
protocolNum = SONY;
return true;
}
};
#endif //IRLIBDECODEBASE_H
#define IRLIB_HAVE_COMBO
#endif //IRLIB_PROTOCOL_02_H

108
arduino-cli/libraries/Adafruit_Circuit_Playground/utility/IRLib_P03_RC5.h Normal file
View File

@@ -0,0 +1,108 @@
/* IRLib_P03_RC5.h
* Part of IRLib Library for Arduino receiving, decoding, and sending
* infrared signals. See COPYRIGHT.txt and LICENSE.txt for more information.
*/
/*
* The RC5 protocol was invented by Phillips but is used by wide variety of manufacturers.
* It uses a phase encoding of data bits. A space/mark pair indicates "1"
* and a mark/space indicates a "0". It begins with a single "1" bit which is not encoded
* in the data. The second highest order data bit is a toggle bit that indicates individual
* keypresses. You must toggle this bit yourself when sending data. The protocol uses 36 kHz
* modulation however 38 kHz receivers can typically receive the codes okay.
* There are three supported varieties as follows:
* RC5 13 bits, 36 kHz (default, most common variety.
* RC5-F7 14 bits, 36 kHz
* RC5-F7-57 14 bits, 57 kHz
* There's also a 19 bit variety called RC5x that is not supported here but may be a separate
* module eventually.
*/
#ifndef IRLIB_PROTOCOL_03_H
#define IRLIB_PROTOCOL_03_H
#define IR_SEND_PROTOCOL_03 case 03: if(khz==38)khz=36; IRsendRC5::send(data,data2,khz); break;
#define IR_DECODE_PROTOCOL_03 if(IRdecodeRC5::decode()) return true;
#ifdef IRLIB_HAVE_COMBO
#define PV_IR_DECODE_PROTOCOL_03 ,public virtual IRdecodeRC5
#define PV_IR_SEND_PROTOCOL_03 ,public virtual IRsendRC5
#else
#define PV_IR_DECODE_PROTOCOL_03 public virtual IRdecodeRC5
#define PV_IR_SEND_PROTOCOL_03 public virtual IRsendRC5
#endif
#define RC5_T1 889
#ifdef IRLIBSENDBASE_H
class IRsendRC5: public virtual IRsendBase {
public:
void send(uint32_t data, uint8_t nBits=13, uint8_t kHz=36) {
if(nBits==0)nBits=13;
if(kHz==0)kHz=36;
enableIROut(kHz);
data = data << (32 - nBits);
extent=0;
mark(RC5_T1); // First start bit
//Note: Original IRremote library incorrectly assumed second bit was
//always a "1". Bit patterns from this decoder are not backward compatible
//with patterns produced by the original library. Uncomment the following two
//lines to maintain backward compatibility.
//space(RC5_T1); // Second start bit
//mark(RC5_T1); // Second start bit
for (uint8_t i = 0; i < nBits; i++) {
if (data & TOPBIT) {
space(RC5_T1); mark(RC5_T1);// 1 is space, then mark
} else {
mark(RC5_T1); space(RC5_T1);// 0 is mark, then space
}
data <<= 1;
}
space(114000-extent); // Turn off at end
}
};
#endif //IRLIBSENDBASE_H
#ifdef IRLIBDECODEBASE_H
/* Note this decoder is a derived class from the IRdecodeRC base class
* rather than IRdecodeBase. The base class defines the method "getRClevel"
* which is common to both RC5 and RC6 protocols. It facilitates the decoding
* of phase encoded data.
*/
class IRdecodeRC5: public virtual IRdecodeRC {
public:
virtual bool decode(void) {
IRLIB_ATTEMPT_MESSAGE(F("RC5"));
resetDecoder();//This used to be in the receiver getResults.
if (recvGlobal.decodeLength < 13) return RAW_COUNT_ERROR;
offset = 1; // Skip gap space
data = 0;
used = 0;
// Get start bits
if (getRClevel(&used, RC5_T1) != MARK) return HEADER_MARK_ERROR(RC5_T1);
//Note: Original IRremote library incorrectly assumed second bit was always
// a "1". Bit patterns from this decoder are not backward compatible with
// patterns produced by original library. Uncomment the following two lines
// to maintain backward compatibility.
//if (getRClevel(&used, RC5_T1) != SPACE) return HEADER_SPACE_ERROR(RC5_T1);
//if (getRClevel(&used, RC5_T1) != MARK) return HEADER_MARK_ERROR(RC5_T1);
for (nBits = 0; offset < recvGlobal.decodeLength; nBits++) {
RCLevel levelA = getRClevel(&used, RC5_T1);
RCLevel levelB = getRClevel(&used, RC5_T1);
if (levelA == SPACE && levelB == MARK) {
data = (data << 1) | 1; // 1 bit
} else if (levelA == MARK && levelB == SPACE) {
data <<= 1; // zero bit
} else return DATA_MARK_ERROR(RC5_T1);
}
// Success
bits = nBits;
value = data;
protocolNum = RC5;
return true;
}
};
#endif //IRLIBDECODEBASE_H
#define IRLIB_HAVE_COMBO
#endif //IRLIB_PROTOCOL_03_H

144
arduino-cli/libraries/Adafruit_Circuit_Playground/utility/IRLib_P04_RC6.h Normal file
View File

@@ -0,0 +1,144 @@
/* IRLib_P04_RC6.h
* Part of IRLib Library for Arduino receiving, decoding, and sending
* infrared signals. See COPYRIGHT.txt and LICENSE.txt for more information.
*/
/*
* The RC6 protocol was invented by Phillips but is used by wide variety of manufacturers.
* Like the Phillips RC5 protocol it uses phased coding however the phase is backwards
* from RC5. With RC6 a space/mark pair indicates "0" and a mark/space indicates a "1".
* in the data. The protocol uses 36 kHz modulation however 38 kHz receivers can typically
* receive the codes okay.
* The protocol consists of a header followed by a "1" bit which is always on and we do not
* encode. This is followed by a 3 bit OEM code that is usually 0 or 6. This is followed by
* special trailer bit whose time is twice that of normal. It all but the 32-bit version,
* the trailer bit also serves as a toggle bit. The toggle bit changes if the button was
* pressed and released however remains the same if the button was held. You must toggle
* this bit yourself when sending data and account for it when interpreting decoded values.
* Next are the actual data bits. Varieties include 16, 20, 24, and 32 bit versions.
* Because we encode the 3 OEM bits and the toggle bit, our actual bit lengths are 20, 24,
* and 28 for the first three varieties. The 32-bit variety is different because it uses
* OEM bits of 011 followed by a 0 in what is traditionally the toggle bit.
* Because the 32-bit version is invariant in these first 4 bits, we do not encode them
* and presume they are always "0110". The 32-bit version uses the highest order of the
* data bits as a toggle bit. At this time the 16-bit version always uses OEM = 0 and
* other known varieties always use OEM = 6 but we will only make that presumption for the
* 32-bit version. Encoding the OEM bits allows for other OEM values to be used without
* modifying the library. If we ever encounter a 32-bit version with an OEM other than 6
* it will require a special modified encoder and decoder.
* Here is a description of known varieties:
* RC6-0-16: Original version by Phillips. 16 bits, we encode 20, toggle is 0x00010000
* RC6-6-20: Used by some Sky and Sky+ remotes. 20 bits, we encode 24, toggle is 0x00100000
* RC6-6-24: Also known as "Replay" protocol. 24 bits, we encode 28, toggle is 0x01000000
* RC6-6-32: Also known as "MCE" protocol. 32 bits, we encode 32, toggle is 0x00008000
*/
#ifndef IRLIB_PROTOCOL_04_H
#define IRLIB_PROTOCOL_04_H
#define IR_SEND_PROTOCOL_04 case 04: IRsendRC6::send(data,data2); break;
#define IR_DECODE_PROTOCOL_04 if(IRdecodeRC6::decode()) return true;
#ifdef IRLIB_HAVE_COMBO
#define PV_IR_DECODE_PROTOCOL_04 ,public virtual IRdecodeRC6
#define PV_IR_SEND_PROTOCOL_04 ,public virtual IRsendRC6
#else
#define PV_IR_DECODE_PROTOCOL_04 public virtual IRdecodeRC6
#define PV_IR_SEND_PROTOCOL_04 public virtual IRsendRC6
#endif
#define RC6_HDR_MARK 2666
#define RC6_HDR_SPACE 889
#define RC6_T1 444
#ifdef IRLIBSENDBASE_H
class IRsendRC6: public virtual IRsendBase {
public:
void send(uint32_t data, uint8_t nBits=16) {
if (nBits==0) nBits=16;
enableIROut(36);
uint64_t bigData = data;
if (nBits==32) {
bigData+=0xc00000000ull;//add OEM value
nBits=36;
};
bigData=bigData << (64 - nBits);
extent=0;
mark(RC6_HDR_MARK); space(RC6_HDR_SPACE);
mark(RC6_T1); space(RC6_T1);// start bit "1"
uint16_t t;
for (uint8_t i = 0; i < nBits; i++) {
if (i == 3) {
t = 2 * RC6_T1; // double-wide trailer bit
} else {
t = RC6_T1;
}
if (bigData & 0x8000000000000000ull) {
mark(t); space(t);//"1" is a Mark/space
} else {
space(t); mark(t);//"0" is a space/Mark
}
bigData <<= 1;
}
space(107000-extent); // Turn off at end
}
};
#endif //IRLIBSENDBASE_H
#ifdef IRLIBDECODEBASE_H
/* Note this decoder is a derived class from the IRdecodeRC base
* class rather than IRdecodeBase. The base class defines the
* method "getRClevel" which is common to both RC5 and RC6 protocols.
* It facilitates the decoding of phase encoded data.
*/
class IRdecodeRC6: public virtual IRdecodeRC {
public:
virtual bool decode(void) {
IRLIB_ATTEMPT_MESSAGE(F("RC6"));
resetDecoder();//This used to be in the receiver getResults.
//Legal lengths range from 24 through 76 we went one bigger just in case.
if( (recvGlobal.decodeLength < 23) || (recvGlobal.decodeLength > 77) )return RAW_COUNT_ERROR;
// Initial mark
if (!ignoreHeader) {
if (!MATCH(recvGlobal.decodeBuffer[1], RC6_HDR_MARK)) return HEADER_MARK_ERROR(RC6_HDR_MARK);
}
if (!MATCH(recvGlobal.decodeBuffer[2], RC6_HDR_SPACE)) return HEADER_SPACE_ERROR(RC6_HDR_SPACE);
offset=3;//Skip gap and header
data = 0;
used = 0;
// Get start bit (1)
if (getRClevel(&used, RC6_T1) != MARK) return DATA_MARK_ERROR(RC6_T1);
if (getRClevel(&used, RC6_T1) != SPACE) return DATA_SPACE_ERROR(RC6_T1);
for (nBits = 0; offset < recvGlobal.decodeLength; nBits++) {
RCLevel levelA, levelB; // Next two levels
levelA = getRClevel(&used, RC6_T1);
if (nBits == 3) {
// T bit is double wide; make sure second half matches
if (levelA != getRClevel(&used, RC6_T1)) return TRAILER_BIT_ERROR(RC6_T1);
}
levelB = getRClevel(&used, RC6_T1);
if (nBits == 3) {
// T bit is double wide; make sure second half matches
if (levelB != getRClevel(&used, RC6_T1)) return TRAILER_BIT_ERROR(RC6_T1);
}
if (levelA == MARK && levelB == SPACE) { // reversed compared to RC5
data = (data << 1) | 1; // 1 bit
} else if (levelA == SPACE && levelB == MARK) {
data <<= 1; // zero bit
} else {
return DATA_MARK_ERROR(RC6_T1);
}
}
// Success
if (nBits==36) {
nBits=32;//OEM & trailer bits are discarded on 32-bit version
} else {
//if ( (nBits!=20) || (nBits!=24) || (nBits!=28) ) return BIT_COUNT_ERROR;
}
bits = nBits;
value = data;
protocolNum = RC6;
return true;
}
};
#endif //IRLIBDECODEBASE_H
#define IRLIB_HAVE_COMBO
#endif //IRLIB_PROTOCOL_04_H

58
arduino-cli/libraries/Adafruit_Circuit_Playground/utility/IRLib_P05_Panasonic_Old.h Normal file
View File

@@ -0,0 +1,58 @@
/* IRLib_P05_Panasonic_Old.h
* Part of IRLib Library for Arduino receiving, decoding, and sending
* infrared signals. See COPYRIGHT.txt and LICENSE.txt for more information.
*/
/*
* This protocol #5 named "Panasonic_Old" is a 57 kHz protocol with 22 bits
* of data. The second 11 bits are the bitwise logical complement of the first 11 bits.
* The protocol is used by many cable boxes and DVR's made by Scientific Atlantic and
* Cisco. They are common for Bright House and Time Warner cable systems.
*/
#ifndef IRLIB_PROTOCOL_05_H
#define IRLIB_PROTOCOL_05_H
#define IR_SEND_PROTOCOL_05 case 5: IRsendPanasonic_Old::send(data); break;
#define IR_DECODE_PROTOCOL_05 if(IRdecodePanasonic_Old::decode()) return true;
#ifdef IRLIB_HAVE_COMBO
#define PV_IR_DECODE_PROTOCOL_05 ,public virtual IRdecodePanasonic_Old
#define PV_IR_SEND_PROTOCOL_05 ,public virtual IRsendPanasonic_Old
#else
#define PV_IR_DECODE_PROTOCOL_05 public virtual IRdecodePanasonic_Old
#define PV_IR_SEND_PROTOCOL_05 public virtual IRsendPanasonic_Old
#endif
#ifdef IRLIBSENDBASE_H
class IRsendPanasonic_Old: public virtual IRsendBase {
public:
void send(uint32_t data) {
sendGeneric(data,22, 833*4, 833*4, 833, 833, 833*3, 833,57, true);
};
};
#endif //IRLIBSENDBASE_H
#ifdef IRLIBDECODEBASE_H
class IRdecodePanasonic_Old: public virtual IRdecodeBase {
public:
virtual bool decode(void) {
IRLIB_ATTEMPT_MESSAGE(F("Panasonic_Old"));
if(!decodeGeneric(48,833*4,833*4,833,833*3,833)) return false;
// The protocol spec says that the first 11 bits described the device and function.
// The next 11 bits are the same thing only it is the logical Bitwise complement.
// Many protocols have such check features in their definition but our code typically
// doesn't perform these checks. For example NEC's least significant 8 bits are the
// complement of the next more significant 8 bits. While it's probably not necessary
// to error check this, you can un-comment the next 4 lines of code to do this extra
// checking.
// long S1= (value & 0x0007ff); // 00 0000 0000 0111 1111 1111
// long S2= (value & 0x3ff800)>> 11; // 11 1111 1111 1000 0000 0000
// S2= (~S2) & 0x0007ff;
// if (S1!=S2) return IRLIB_REJECTION_MESSAGE(F("inverted bit redundancy"));
protocolNum = PANASONIC_OLD;
return true;
};
};
#endif //IRLIBDECODEBASE_H
#define IRLIB_HAVE_COMBO
#endif //IRLIB_PROTOCOL_05_H

Some files were not shown because too many files have changed in this diff Show More