alvinlollo/Studuino
1
0
Fork 0
Code Issues 2 Actions Projects 1 Releases Activity

initial commit

Browse Source
This commit is contained in:
alvinlollo
2026-09-25 10:48:51 +10:00
commit b90beea8ae
1020 changed files with 131665 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
libraries/Adafruit_BusIO/Adafruit_BusIO_Register.cpp
+384
View File
@@ -0,0 +1,384 @@
#include <Adafruit_BusIO_Register.h>
#if !defined(SPI_INTERFACES_COUNT) || \
(defined(SPI_INTERFACES_COUNT) && (SPI_INTERFACES_COUNT > 0))
/*!
* @brief Create a register we access over an I2C Device (which defines the
* bus and address)
* @param i2cdevice The I2CDevice to use for underlying I2C access
* @param reg_addr The address pointer value for the I2C/SMBus register, can
* be 8 or 16 bits
* @param width The width of the register data itself, defaults to 1 byte
* @param byteorder The byte order of the register (used when width is > 1),
* defaults to LSBFIRST
* @param address_width The width of the register address itself, defaults
* to 1 byte
*/
Adafruit_BusIO_Register::Adafruit_BusIO_Register(Adafruit_I2CDevice *i2cdevice,
uint16_t reg_addr,
uint8_t width,
uint8_t byteorder,
uint8_t address_width) {
_i2cdevice = i2cdevice;
_spidevice = nullptr;
_addrwidth = address_width;
_address = reg_addr;
_byteorder = byteorder;
_width = width;
}
/*!
* @brief Create a register we access over an SPI Device (which defines the
* bus and CS pin)
* @param spidevice The SPIDevice to use for underlying SPI access
* @param reg_addr The address pointer value for the SPI register, can
* be 8 or 16 bits
* @param type The method we use to read/write data to SPI (which is not
* as well defined as I2C)
* @param width The width of the register data itself, defaults to 1 byte
* @param byteorder The byte order of the register (used when width is > 1),
* defaults to LSBFIRST
* @param address_width The width of the register address itself, defaults
* to 1 byte
*/
Adafruit_BusIO_Register::Adafruit_BusIO_Register(Adafruit_SPIDevice *spidevice,
uint16_t reg_addr,
Adafruit_BusIO_SPIRegType type,
uint8_t width,
uint8_t byteorder,
uint8_t address_width) {
_spidevice = spidevice;
_spiregtype = type;
_i2cdevice = nullptr;
_addrwidth = address_width;
_address = reg_addr;
_byteorder = byteorder;
_width = width;
}
/*!
* @brief Create a register we access over an I2C or SPI Device. This is a
* handy function because we can pass in nullptr for the unused interface,
* allowing libraries to mass-define all the registers
* @param i2cdevice The I2CDevice to use for underlying I2C access, if
* nullptr we use SPI
* @param spidevice The SPIDevice to use for underlying SPI access, if
* nullptr we use I2C
* @param reg_addr The address pointer value for the I2C/SMBus/SPI register,
* can be 8 or 16 bits
* @param type The method we use to read/write data to SPI (which is not
* as well defined as I2C)
* @param width The width of the register data itself, defaults to 1 byte
* @param byteorder The byte order of the register (used when width is > 1),
* defaults to LSBFIRST
* @param address_width The width of the register address itself, defaults
* to 1 byte
*/
Adafruit_BusIO_Register::Adafruit_BusIO_Register(
Adafruit_I2CDevice *i2cdevice, Adafruit_SPIDevice *spidevice,
Adafruit_BusIO_SPIRegType type, uint16_t reg_addr, uint8_t width,
uint8_t byteorder, uint8_t address_width) {
_spidevice = spidevice;
_i2cdevice = i2cdevice;
_spiregtype = type;
_addrwidth = address_width;
_address = reg_addr;
_byteorder = byteorder;
_width = width;
}
/*!
* @brief Create a register we access over a GenericDevice
* @param genericdevice Generic device to use
* @param reg_addr Register address we will read/write
* @param width Width of the register in bytes (1-4)
* @param byteorder Byte order of register data (LSBFIRST or MSBFIRST)
* @param address_width Width of the register address in bytes (1 or 2)
*/
Adafruit_BusIO_Register::Adafruit_BusIO_Register(
Adafruit_GenericDevice *genericdevice, uint16_t reg_addr, uint8_t width,
uint8_t byteorder, uint8_t address_width) {
_i2cdevice = nullptr;
_spidevice = nullptr;
_genericdevice = genericdevice;
_addrwidth = address_width;
_address = reg_addr;
_byteorder = byteorder;
_width = width;
}
/*!
* @brief Write a buffer of data to the register location
* @param buffer Pointer to data to write
* @param len Number of bytes to write
* @return True on successful write (only really useful for I2C as SPI is
* uncheckable)
*/
bool Adafruit_BusIO_Register::write(uint8_t *buffer, uint8_t len) {
uint8_t addrbuffer[2] = {(uint8_t)(_address & 0xFF),
(uint8_t)(_address >> 8)};
if (_i2cdevice) {
return _i2cdevice->write(buffer, len, true, addrbuffer, _addrwidth);
}
if (_spidevice) {
if (_spiregtype == ADDRESSED_OPCODE_BIT0_LOW_TO_WRITE) {
// very special case!
// pass the special opcode address which we set as the high byte of the
// regaddr
addrbuffer[0] =
(uint8_t)(_address >> 8) & ~0x01; // set bottom bit low to write
// the 'actual' reg addr is the second byte then
addrbuffer[1] = (uint8_t)(_address & 0xFF);
// the address appears to be a byte longer
return _spidevice->write(buffer, len, addrbuffer, _addrwidth + 1);
}
if (_spiregtype == ADDRBIT8_HIGH_TOREAD) {
addrbuffer[0] &= ~0x80;
}
if (_spiregtype == ADDRBIT8_HIGH_TOWRITE) {
addrbuffer[0] |= 0x80;
}
if (_spiregtype == AD8_HIGH_TOREAD_AD7_HIGH_TOINC) {
addrbuffer[0] &= ~0x80;
addrbuffer[0] |= 0x40;
}
return _spidevice->write(buffer, len, addrbuffer, _addrwidth);
}
if (_genericdevice) {
return _genericdevice->writeRegister(addrbuffer, _addrwidth, buffer, len);
}
return false;
}
/*!
* @brief Write up to 4 bytes of data to the register location
* @param value Data to write
* @param numbytes How many bytes from 'value' to write
* @return True on successful write (only really useful for I2C as SPI is
* uncheckable)
*/
bool Adafruit_BusIO_Register::write(uint32_t value, uint8_t numbytes) {
if (numbytes == 0) {
numbytes = _width;
}
if (numbytes > 4) {
return false;
}
// store a copy
_cached = value;
for (int i = 0; i < numbytes; i++) {
if (_byteorder == LSBFIRST) {
_buffer[i] = value & 0xFF;
} else {
_buffer[numbytes - i - 1] = value & 0xFF;
}
value >>= 8;
}
return write(_buffer, numbytes);
}
/*!
* @brief Read data from the register location. This does not do any error
* checking!
* @return Returns 0xFFFFFFFF on failure, value otherwise
*/
uint32_t Adafruit_BusIO_Register::read(void) {
if (!read(_buffer, _width)) {
return -1;
}
uint32_t value = 0;
for (int i = 0; i < _width; i++) {
value <<= 8;
if (_byteorder == LSBFIRST) {
value |= _buffer[_width - i - 1];
} else {
value |= _buffer[i];
}
}
return value;
}
/*!
* @brief Read cached data from last time we wrote to this register
* @return Returns 0xFFFFFFFF on failure, value otherwise
*/
uint32_t Adafruit_BusIO_Register::readCached(void) { return _cached; }
/*!
@brief Read a number of bytes from a register into a buffer
@param buffer Buffer to read data into
@param len Number of bytes to read into the buffer
@return true on successful read, otherwise false
*/
bool Adafruit_BusIO_Register::read(uint8_t *buffer, uint8_t len) {
uint8_t addrbuffer[2] = {(uint8_t)(_address & 0xFF),
(uint8_t)(_address >> 8)};
if (_i2cdevice) {
return _i2cdevice->write_then_read(addrbuffer, _addrwidth, buffer, len);
}
if (_spidevice) {
if (_spiregtype == ADDRESSED_OPCODE_BIT0_LOW_TO_WRITE) {
// very special case!
// pass the special opcode address which we set as the high byte of the
// regaddr
addrbuffer[0] =
(uint8_t)(_address >> 8) | 0x01; // set bottom bit high to read
// the 'actual' reg addr is the second byte then
addrbuffer[1] = (uint8_t)(_address & 0xFF);
// the address appears to be a byte longer
return _spidevice->write_then_read(addrbuffer, _addrwidth + 1, buffer,
len);
}
if (_spiregtype == ADDRBIT8_HIGH_TOREAD) {
addrbuffer[0] |= 0x80;
}
if (_spiregtype == ADDRBIT8_HIGH_TOWRITE) {
addrbuffer[0] &= ~0x80;
}
if (_spiregtype == AD8_HIGH_TOREAD_AD7_HIGH_TOINC) {
addrbuffer[0] |= 0x80 | 0x40;
}
return _spidevice->write_then_read(addrbuffer, _addrwidth, buffer, len);
}
if (_genericdevice) {
return _genericdevice->readRegister(addrbuffer, _addrwidth, buffer, len);
}
return false;
}
/*!
* @brief Read 2 bytes of data from the register location
* @param value Pointer to uint16_t variable to read into
* @return True on successful write (only really useful for I2C as SPI is
* uncheckable)
*/
bool Adafruit_BusIO_Register::read(uint16_t *value) {
if (!read(_buffer, 2)) {
return false;
}
if (_byteorder == LSBFIRST) {
*value = _buffer[1];
*value <<= 8;
*value |= _buffer[0];
} else {
*value = _buffer[0];
*value <<= 8;
*value |= _buffer[1];
}
return true;
}
/*!
* @brief Read 1 byte of data from the register location
* @param value Pointer to uint8_t variable to read into
* @return True on successful write (only really useful for I2C as SPI is
* uncheckable)
*/
bool Adafruit_BusIO_Register::read(uint8_t *value) {
if (!read(_buffer, 1)) {
return false;
}
*value = _buffer[0];
return true;
}
/*!
* @brief Pretty printer for this register
* @param s The Stream to print to, defaults to &Serial
*/
void Adafruit_BusIO_Register::print(Stream *s) {
uint32_t val = read();
s->print("0x");
s->print(val, HEX);
}
/*!
* @brief Pretty printer for this register
* @param s The Stream to print to, defaults to &Serial
*/
void Adafruit_BusIO_Register::println(Stream *s) {
print(s);
s->println();
}
/*!
* @brief Create a slice of the register that we can address without
* touching other bits
* @param reg The Adafruit_BusIO_Register which defines the bus/register
* @param bits The number of bits wide we are slicing
* @param shift The number of bits that our bit-slice is shifted from LSB
*/
Adafruit_BusIO_RegisterBits::Adafruit_BusIO_RegisterBits(
Adafruit_BusIO_Register *reg, uint8_t bits, uint8_t shift) {
_register = reg;
_bits = bits;
_shift = shift;
}
/*!
* @brief Read 4 bytes of data from the register
* @return data The 4 bytes to read
*/
uint32_t Adafruit_BusIO_RegisterBits::read(void) {
uint32_t val = _register->read();
val >>= _shift;
return val & ((1 << (_bits)) - 1);
}
/*!
* @brief Write 4 bytes of data to the register
* @param data The 4 bytes to write
* @return True on successful write (only really useful for I2C as SPI is
* uncheckable)
*/
bool Adafruit_BusIO_RegisterBits::write(uint32_t data) {
uint32_t val = _register->read();
// mask off the data before writing
uint32_t mask = (1 << (_bits)) - 1;
data &= mask;
mask <<= _shift;
val &= ~mask; // remove the current data at that spot
val |= data << _shift; // and add in the new data
return _register->write(val, _register->width());
}
/*!
* @brief The width of the register data, helpful for doing calculations
* @returns The data width used when initializing the register
*/
uint8_t Adafruit_BusIO_Register::width(void) { return _width; }
/*!
* @brief Set the default width of data
* @param width the default width of data read from register
*/
void Adafruit_BusIO_Register::setWidth(uint8_t width) { _width = width; }
/*!
* @brief Set register address
* @param address the address from register
*/
void Adafruit_BusIO_Register::setAddress(uint16_t address) {
_address = address;
}
/*!
* @brief Set the width of register address
* @param address_width the width for register address
*/
void Adafruit_BusIO_Register::setAddressWidth(uint16_t address_width) {
_addrwidth = address_width;
}
#endif // SPI exists
libraries/Adafruit_BusIO/Adafruit_BusIO_Register.h
+117
View File
@@ -0,0 +1,117 @@
#ifndef Adafruit_BusIO_Register_h
#define Adafruit_BusIO_Register_h
#include <Arduino.h>
#if !defined(SPI_INTERFACES_COUNT) || \
(defined(SPI_INTERFACES_COUNT) && (SPI_INTERFACES_COUNT > 0))
#include <Adafruit_GenericDevice.h>
#include <Adafruit_I2CDevice.h>
#include <Adafruit_SPIDevice.h>
typedef enum _Adafruit_BusIO_SPIRegType {
ADDRBIT8_HIGH_TOREAD = 0,
/*!<
* ADDRBIT8_HIGH_TOREAD
* When reading a register you must actually send the value 0x80 + register
* address to the device. e.g. To read the register 0x0B the register value
* 0x8B is sent and to write 0x0B is sent.
*/
AD8_HIGH_TOREAD_AD7_HIGH_TOINC = 1,
/*!<
* ADDRBIT8_HIGH_TOWRITE
* When writing to a register you must actually send the value 0x80 +
* the register address to the device. e.g. To write to the register 0x19 the
* register value 0x99 is sent and to read 0x19 is sent.
*/
ADDRBIT8_HIGH_TOWRITE = 2,
/*!<
* ADDRESSED_OPCODE_LOWBIT_TO_WRITE
* Used by the MCP23S series, we send 0x40 |'rd with the opcode
* Then set the lowest bit to write
*/
ADDRESSED_OPCODE_BIT0_LOW_TO_WRITE = 3,
} Adafruit_BusIO_SPIRegType;
/*!
* @brief The class which defines a device register (a location to read/write
* data from)
*/
class Adafruit_BusIO_Register {
public:
Adafruit_BusIO_Register(Adafruit_I2CDevice *i2cdevice, uint16_t reg_addr,
uint8_t width = 1, uint8_t byteorder = LSBFIRST,
uint8_t address_width = 1);
Adafruit_BusIO_Register(Adafruit_SPIDevice *spidevice, uint16_t reg_addr,
Adafruit_BusIO_SPIRegType type, uint8_t width = 1,
uint8_t byteorder = LSBFIRST,
uint8_t address_width = 1);
Adafruit_BusIO_Register(Adafruit_I2CDevice *i2cdevice,
Adafruit_SPIDevice *spidevice,
Adafruit_BusIO_SPIRegType type, uint16_t reg_addr,
uint8_t width = 1, uint8_t byteorder = LSBFIRST,
uint8_t address_width = 1);
Adafruit_BusIO_Register(Adafruit_GenericDevice *genericdevice,
uint16_t reg_addr, uint8_t width = 1,
uint8_t byteorder = LSBFIRST,
uint8_t address_width = 1);
bool read(uint8_t *buffer, uint8_t len);
bool read(uint8_t *value);
bool read(uint16_t *value);
uint32_t read(void);
uint32_t readCached(void);
bool write(uint8_t *buffer, uint8_t len);
bool write(uint32_t value, uint8_t numbytes = 0);
uint8_t width(void);
void setWidth(uint8_t width);
void setAddress(uint16_t address);
void setAddressWidth(uint16_t address_width);
#if !defined(NO_GLOBAL_INSTANCES) && !defined(NO_GLOBAL_SERIAL)
void print(Stream *s = &Serial);
void println(Stream *s = &Serial);
#else
void print(Stream *s);
void println(Stream *s);
#endif
private:
Adafruit_I2CDevice *_i2cdevice;
Adafruit_SPIDevice *_spidevice;
Adafruit_GenericDevice *_genericdevice;
Adafruit_BusIO_SPIRegType _spiregtype;
uint16_t _address;
uint8_t _width, _addrwidth, _byteorder;
uint8_t _buffer[4]; // we won't support anything larger than uint32 for
// non-buffered read
uint32_t _cached = 0;
};
/*!
* @brief The class which defines a slice of bits from within a device register
* (a location to read/write data from)
*/
class Adafruit_BusIO_RegisterBits {
public:
Adafruit_BusIO_RegisterBits(Adafruit_BusIO_Register *reg, uint8_t bits,
uint8_t shift);
bool write(uint32_t value);
uint32_t read(void);
private:
Adafruit_BusIO_Register *_register;
uint8_t _bits, _shift;
};
#endif // SPI exists
#endif // BusIO_Register_h
libraries/Adafruit_BusIO/Adafruit_GenericDevice.cpp
+90
View File
@@ -0,0 +1,90 @@
/*
Written with help by Claude!
https://claude.ai/chat/335f50b1-3dd8-435e-9139-57ec7ca26a3c (at this time
chats are not shareable :(
*/
#include "Adafruit_GenericDevice.h"
/*!
* @brief Create a Generic device with the provided read/write functions
* @param obj Pointer to object instance
* @param read_func Function pointer for reading raw data
* @param write_func Function pointer for writing raw data
* @param readreg_func Function pointer for reading registers (optional)
* @param writereg_func Function pointer for writing registers (optional) */
Adafruit_GenericDevice::Adafruit_GenericDevice(
void *obj, busio_genericdevice_read_t read_func,
busio_genericdevice_write_t write_func,
busio_genericdevice_readreg_t readreg_func,
busio_genericdevice_writereg_t writereg_func) {
_obj = obj;
_read_func = read_func;
_write_func = write_func;
_readreg_func = readreg_func;
_writereg_func = writereg_func;
_begun = false;
}
/*! @brief Simple begin function (doesn't do much at this time)
@return true always
*/
bool Adafruit_GenericDevice::begin(void) {
_begun = true;
return true;
}
/*!
@brief Marks the GenericDevice as no longer in use.
@note: Since this is a GenericDevice, if you are using this with a Serial
object, this does NOT disable serial communication or release the RX/TX pins.
That must be done manually by calling Serial.end().
*/
void Adafruit_GenericDevice::end(void) { _begun = false; }
/*! @brief Write a buffer of data
@param buffer Pointer to buffer of data to write
@param len Number of bytes to write
@return true if write was successful, otherwise false */
bool Adafruit_GenericDevice::write(const uint8_t *buffer, size_t len) {
if (!_begun)
return false;
return _write_func(_obj, buffer, len);
}
/*! @brief Read data into a buffer
@param buffer Pointer to buffer to read data into
@param len Number of bytes to read
@return true if read was successful, otherwise false */
bool Adafruit_GenericDevice::read(uint8_t *buffer, size_t len) {
if (!_begun)
return false;
return _read_func(_obj, buffer, len);
}
/*! @brief Read from a register location
@param addr_buf Buffer containing register address
@param addrsiz Size of register address in bytes
@param buf Buffer to store read data
@param bufsiz Size of data to read in bytes
@return true if read was successful, otherwise false */
bool Adafruit_GenericDevice::readRegister(uint8_t *addr_buf, uint8_t addrsiz,
uint8_t *buf, uint16_t bufsiz) {
if (!_begun || !_readreg_func)
return false;
return _readreg_func(_obj, addr_buf, addrsiz, buf, bufsiz);
}
/*! @brief Write to a register location
@param addr_buf Buffer containing register address
@param addrsiz Size of register address in bytes
@param buf Buffer containing data to write
@param bufsiz Size of data to write in bytes
@return true if write was successful, otherwise false */
bool Adafruit_GenericDevice::writeRegister(uint8_t *addr_buf, uint8_t addrsiz,
const uint8_t *buf,
uint16_t bufsiz) {
if (!_begun || !_writereg_func)
return false;
return _writereg_func(_obj, addr_buf, addrsiz, buf, bufsiz);
}
libraries/Adafruit_BusIO/Adafruit_GenericDevice.h
+56
View File
@@ -0,0 +1,56 @@
#ifndef ADAFRUIT_GENERICDEVICE_H
#define ADAFRUIT_GENERICDEVICE_H
#include <Arduino.h>
typedef bool (*busio_genericdevice_read_t)(void *obj, uint8_t *buffer,
size_t len);
typedef bool (*busio_genericdevice_write_t)(void *obj, const uint8_t *buffer,
size_t len);
typedef bool (*busio_genericdevice_readreg_t)(void *obj, uint8_t *addr_buf,
uint8_t addrsiz, uint8_t *data,
uint16_t datalen);
typedef bool (*busio_genericdevice_writereg_t)(void *obj, uint8_t *addr_buf,
uint8_t addrsiz,
const uint8_t *data,
uint16_t datalen);
/*!
* @brief Class for communicating with a device via generic read/write functions
*/
class Adafruit_GenericDevice {
public:
Adafruit_GenericDevice(
void *obj, busio_genericdevice_read_t read_func,
busio_genericdevice_write_t write_func,
busio_genericdevice_readreg_t readreg_func = nullptr,
busio_genericdevice_writereg_t writereg_func = nullptr);
bool begin(void);
void end(void);
bool read(uint8_t *buffer, size_t len);
bool write(const uint8_t *buffer, size_t len);
bool readRegister(uint8_t *addr_buf, uint8_t addrsiz, uint8_t *buf,
uint16_t bufsiz);
bool writeRegister(uint8_t *addr_buf, uint8_t addrsiz, const uint8_t *buf,
uint16_t bufsiz);
protected:
/*! @brief Function pointer for reading raw data from the device */
busio_genericdevice_read_t _read_func;
/*! @brief Function pointer for writing raw data to the device */
busio_genericdevice_write_t _write_func;
/*! @brief Function pointer for reading a 'register' from the device */
busio_genericdevice_readreg_t _readreg_func;
/*! @brief Function pointer for writing a 'register' to the device */
busio_genericdevice_writereg_t _writereg_func;
bool _begun; ///< whether we have initialized yet (in case the function needs
///< to do something)
private:
void *_obj; ///< Pointer to object instance
};
#endif // ADAFRUIT_GENERICDEVICE_H
libraries/Adafruit_BusIO/Adafruit_I2CDevice.cpp
+320
View File
@@ -0,0 +1,320 @@
#include "Adafruit_I2CDevice.h"
// #define DEBUG_SERIAL Serial
/*!
* @brief Create an I2C device at a given address
* @param addr The 7-bit I2C address for the device
* @param theWire The I2C bus to use, defaults to &Wire
*/
Adafruit_I2CDevice::Adafruit_I2CDevice(uint8_t addr, TwoWire *theWire) {
_addr = addr;
_wire = theWire;
_begun = false;
#ifdef ARDUINO_ARCH_SAMD
_maxBufferSize = 250; // as defined in Wire.h's RingBuffer
#elif defined(ESP32)
_maxBufferSize = I2C_BUFFER_LENGTH;
#else
_maxBufferSize = 32;
#endif
}
/*!
* @brief Initializes and does basic address detection
* @param addr_detect Whether we should attempt to detect the I2C address
* with a scan. 99% of sensors/devices don't mind, but once in a while they
* don't respond well to a scan!
* @return True if I2C initialized and a device with the addr found
*/
bool Adafruit_I2CDevice::begin(bool addr_detect) {
_wire->begin();
_begun = true;
if (addr_detect) {
return detected();
}
return true;
}
/*!
* @brief De-initialize device, turn off the Wire interface
*/
void Adafruit_I2CDevice::end(void) {
// Not all port implement Wire::end(), such as
// - ESP8266
// - AVR core without WIRE_HAS_END
// - ESP32: end() is implemented since 2.0.1 which is latest at the moment.
// Temporarily disable for now to give time for user to update.
#if !(defined(ESP8266) || \
(defined(ARDUINO_ARCH_AVR) && !defined(WIRE_HAS_END)) || \
defined(ARDUINO_ARCH_ESP32))
_wire->end();
_begun = false;
#endif
}
/*!
* @brief Scans I2C for the address - note will give a false-positive
* if there's no pullups on I2C
* @return True if I2C initialized and a device with the addr found
*/
bool Adafruit_I2CDevice::detected(void) {
// Init I2C if not done yet
if (!_begun && !begin()) {
return false;
}
// A basic scanner, see if it ACK's
_wire->beginTransmission(_addr);
#ifdef DEBUG_SERIAL
DEBUG_SERIAL.print(F("Address 0x"));
DEBUG_SERIAL.print(_addr, HEX);
#endif
#ifdef ARDUINO_ARCH_MBED
_wire->write(0); // forces a write request instead of a read
#endif
if (_wire->endTransmission() == 0) {
#ifdef DEBUG_SERIAL
DEBUG_SERIAL.println(F(" Detected"));
#endif
return true;
}
#ifdef DEBUG_SERIAL
DEBUG_SERIAL.println(F(" Not detected"));
#endif
return false;
}
/*!
* @brief Write a buffer or two to the I2C device. Cannot be more than
* maxBufferSize() bytes.
* @param buffer Pointer to buffer of data to write. This is const to
* ensure the content of this buffer doesn't change.
* @param len Number of bytes from buffer to write
* @param prefix_buffer Pointer to optional array of data to write before
* buffer. Cannot be more than maxBufferSize() bytes. This is const to
* ensure the content of this buffer doesn't change.
* @param prefix_len Number of bytes from prefix buffer to write
* @param stop Whether to send an I2C STOP signal on write
* @return True if write was successful, otherwise false.
*/
bool Adafruit_I2CDevice::write(const uint8_t *buffer, size_t len, bool stop,
const uint8_t *prefix_buffer,
size_t prefix_len) {
if ((len + prefix_len) > maxBufferSize()) {
// currently not guaranteed to work if more than 32 bytes!
// we will need to find out if some platforms have larger
// I2C buffer sizes :/
#ifdef DEBUG_SERIAL
DEBUG_SERIAL.println(F("\tI2CDevice could not write such a large buffer"));
#endif
return false;
}
_wire->beginTransmission(_addr);
// Write the prefix data (usually an address)
if ((prefix_len != 0) && (prefix_buffer != nullptr)) {
if (_wire->write(prefix_buffer, prefix_len) != prefix_len) {
#ifdef DEBUG_SERIAL
DEBUG_SERIAL.println(F("\tI2CDevice failed to write"));
#endif
return false;
}
}
// Write the data itself
if (_wire->write(buffer, len) != len) {
#ifdef DEBUG_SERIAL
DEBUG_SERIAL.println(F("\tI2CDevice failed to write"));
#endif
return false;
}
#ifdef DEBUG_SERIAL
DEBUG_SERIAL.print(F("\tI2CWRITE @ 0x"));
DEBUG_SERIAL.print(_addr, HEX);
DEBUG_SERIAL.print(F(" :: "));
if ((prefix_len != 0) && (prefix_buffer != nullptr)) {
for (uint16_t i = 0; i < prefix_len; i++) {
DEBUG_SERIAL.print(F("0x"));
DEBUG_SERIAL.print(prefix_buffer[i], HEX);
DEBUG_SERIAL.print(F(", "));
}
}
for (uint16_t i = 0; i < len; i++) {
DEBUG_SERIAL.print(F("0x"));
DEBUG_SERIAL.print(buffer[i], HEX);
DEBUG_SERIAL.print(F(", "));
if (i % 32 == 31) {
DEBUG_SERIAL.println();
}
}
if (stop) {
DEBUG_SERIAL.print("\tSTOP");
}
#endif
if (_wire->endTransmission(stop) == 0) {
#ifdef DEBUG_SERIAL
DEBUG_SERIAL.println();
// DEBUG_SERIAL.println("Sent!");
#endif
return true;
} else {
#ifdef DEBUG_SERIAL
DEBUG_SERIAL.println("\tFailed to send!");
#endif
return false;
}
}
/*!
* @brief Read from I2C into a buffer from the I2C device.
* Cannot be more than maxBufferSize() bytes.
* @param buffer Pointer to buffer of data to read into
* @param len Number of bytes from buffer to read.
* @param stop Whether to send an I2C STOP signal on read
* @return True if read was successful, otherwise false.
*/
bool Adafruit_I2CDevice::read(uint8_t *buffer, size_t len, bool stop) {
size_t pos = 0;
while (pos < len) {
size_t read_len =
((len - pos) > maxBufferSize()) ? maxBufferSize() : (len - pos);
bool read_stop = (pos < (len - read_len)) ? false : stop;
if (!_read(buffer + pos, read_len, read_stop))
return false;
pos += read_len;
}
return true;
}
bool Adafruit_I2CDevice::_read(uint8_t *buffer, size_t len, bool stop) {
#if defined(TinyWireM_h)
size_t recv = _wire->requestFrom((uint8_t)_addr, (uint8_t)len);
#elif defined(ARDUINO_ARCH_MEGAAVR)
size_t recv = _wire->requestFrom(_addr, len, stop);
#else
size_t recv = _wire->requestFrom((uint8_t)_addr, (uint8_t)len, (uint8_t)stop);
#endif
if (recv != len) {
// Not enough data available to fulfill our obligation!
#ifdef DEBUG_SERIAL
DEBUG_SERIAL.print(F("\tI2CDevice did not receive enough data: "));
DEBUG_SERIAL.println(recv);
#endif
return false;
}
for (uint16_t i = 0; i < len; i++) {
buffer[i] = _wire->read();
}
#ifdef DEBUG_SERIAL
DEBUG_SERIAL.print(F("\tI2CREAD @ 0x"));
DEBUG_SERIAL.print(_addr, HEX);
DEBUG_SERIAL.print(F(" :: "));
for (uint16_t i = 0; i < len; i++) {
DEBUG_SERIAL.print(F("0x"));
DEBUG_SERIAL.print(buffer[i], HEX);
DEBUG_SERIAL.print(F(", "));
if (len % 32 == 31) {
DEBUG_SERIAL.println();
}
}
DEBUG_SERIAL.println();
#endif
return true;
}
/*!
* @brief Write some data, then read some data from I2C into another buffer.
* Cannot be more than maxBufferSize() bytes. The buffers can point to
* same/overlapping locations.
* @param write_buffer Pointer to buffer of data to write from
* @param write_len Number of bytes from buffer to write.
* @param read_buffer Pointer to buffer of data to read into.
* @param read_len Number of bytes from buffer to read.
* @param stop Whether to send an I2C STOP signal between the write and read
* @return True if write & read was successful, otherwise false.
*/
bool Adafruit_I2CDevice::write_then_read(const uint8_t *write_buffer,
size_t write_len, uint8_t *read_buffer,
size_t read_len, bool stop) {
if (!write(write_buffer, write_len, stop)) {
return false;
}
return read(read_buffer, read_len);
}
/*!
* @brief Returns the 7-bit address of this device
* @return The 7-bit address of this device
*/
uint8_t Adafruit_I2CDevice::address(void) { return _addr; }
/*!
* @brief Change the I2C clock speed to desired (relies on
* underlying Wire support!
* @param desiredclk The desired I2C SCL frequency
* @return True if this platform supports changing I2C speed.
* Not necessarily that the speed was achieved!
*/
bool Adafruit_I2CDevice::setSpeed(uint32_t desiredclk) {
#if defined(__AVR_ATmega328__) || \
defined(__AVR_ATmega328P__) // fix arduino core set clock
// calculate TWBR correctly
if ((F_CPU / 18) < desiredclk) {
#ifdef DEBUG_SERIAL
Serial.println(F("I2C.setSpeed too high."));
#endif
return false;
}
uint32_t atwbr = ((F_CPU / desiredclk) - 16) / 2;
if (atwbr > 16320) {
#ifdef DEBUG_SERIAL
Serial.println(F("I2C.setSpeed too low."));
#endif
return false;
}
if (atwbr <= 255) {
atwbr /= 1;
TWSR = 0x0;
} else if (atwbr <= 1020) {
atwbr /= 4;
TWSR = 0x1;
} else if (atwbr <= 4080) {
atwbr /= 16;
TWSR = 0x2;
} else { // if (atwbr <= 16320)
atwbr /= 64;
TWSR = 0x3;
}
TWBR = atwbr;
#ifdef DEBUG_SERIAL
Serial.print(F("TWSR prescaler = "));
Serial.println(pow(4, TWSR));
Serial.print(F("TWBR = "));
Serial.println(atwbr);
#endif
return true;
#elif (ARDUINO >= 157) && !defined(ARDUINO_STM32_FEATHER) && \
!defined(TinyWireM_h)
_wire->setClock(desiredclk);
return true;
#else
(void)desiredclk;
return false;
#endif
}
libraries/Adafruit_BusIO/Adafruit_I2CDevice.h
+36
View File
@@ -0,0 +1,36 @@
#ifndef Adafruit_I2CDevice_h
#define Adafruit_I2CDevice_h
#include <Arduino.h>
#include <Wire.h>
///< The class which defines how we will talk to this device over I2C
class Adafruit_I2CDevice {
public:
Adafruit_I2CDevice(uint8_t addr, TwoWire *theWire = &Wire);
uint8_t address(void);
bool begin(bool addr_detect = true);
void end(void);
bool detected(void);
bool read(uint8_t *buffer, size_t len, bool stop = true);
bool write(const uint8_t *buffer, size_t len, bool stop = true,
const uint8_t *prefix_buffer = nullptr, size_t prefix_len = 0);
bool write_then_read(const uint8_t *write_buffer, size_t write_len,
uint8_t *read_buffer, size_t read_len,
bool stop = false);
bool setSpeed(uint32_t desiredclk);
/*! @brief How many bytes we can read in a transaction
* @return The size of the Wire receive/transmit buffer */
size_t maxBufferSize() { return _maxBufferSize; }
private:
uint8_t _addr;
TwoWire *_wire;
bool _begun;
size_t _maxBufferSize;
bool _read(uint8_t *buffer, size_t len, bool stop);
};
#endif // Adafruit_I2CDevice_h
libraries/Adafruit_BusIO/Adafruit_I2CRegister.h
+10
View File
@@ -0,0 +1,10 @@
#ifndef _ADAFRUIT_I2C_REGISTER_H_
#define _ADAFRUIT_I2C_REGISTER_H_
#include <Adafruit_BusIO_Register.h>
#include <Arduino.h>
typedef Adafruit_BusIO_Register Adafruit_I2CRegister;
typedef Adafruit_BusIO_RegisterBits Adafruit_I2CRegisterBits;
#endif
libraries/Adafruit_BusIO/Adafruit_SPIDevice.cpp
+512
View File
@@ -0,0 +1,512 @@
#include "Adafruit_SPIDevice.h"
// #define DEBUG_SERIAL Serial
#ifdef BUSIO_USE_FAST_PINIO
#define BUSIO_SET_CLOCK_LOW() (*clkPort = *clkPort & ~clkPinMask)
#define BUSIO_SET_CLOCK_HIGH() (*clkPort = *clkPort | clkPinMask)
#define BUSIO_READ_MISO() (*misoPort & misoPinMask)
#define BUSIO_WRITE_MOSI(value) \
do { \
if (value) \
*mosiPort = *mosiPort | mosiPinMask; \
else \
*mosiPort = *mosiPort & ~mosiPinMask; \
} while (0)
#else
#define BUSIO_SET_CLOCK_LOW() digitalWrite(_sck, LOW)
#define BUSIO_SET_CLOCK_HIGH() digitalWrite(_sck, HIGH)
#define BUSIO_READ_MISO() digitalRead(_miso)
#define BUSIO_WRITE_MOSI(value) digitalWrite(_mosi, value)
#endif
/*!
* @brief Create an SPI device with the given CS pin and settings
* @param cspin The arduino pin number to use for chip select
* @param freq The SPI clock frequency to use, defaults to 1MHz
* @param dataOrder The SPI data order to use for bits within each byte,
* defaults to SPI_BITORDER_MSBFIRST
* @param dataMode The SPI mode to use, defaults to SPI_MODE0
* @param theSPI The SPI bus to use, defaults to &theSPI
*/
Adafruit_SPIDevice::Adafruit_SPIDevice(int8_t cspin, uint32_t freq,
BusIOBitOrder dataOrder,
uint8_t dataMode, SPIClass *theSPI) {
#ifdef BUSIO_HAS_HW_SPI
_cs = cspin;
_sck = _mosi = _miso = -1;
_spi = theSPI;
_begun = false;
_spiSetting = new SPISettings(freq, dataOrder, dataMode);
_freq = freq;
_dataOrder = dataOrder;
_dataMode = dataMode;
#else
// unused, but needed to suppress compiler warns
(void)cspin;
(void)freq;
(void)dataOrder;
(void)dataMode;
(void)theSPI;
#endif
}
/*!
* @brief Create an SPI device with the given CS pin and settings
* @param cspin The arduino pin number to use for chip select
* @param sckpin The arduino pin number to use for SCK
* @param misopin The arduino pin number to use for MISO, set to -1 if not
* used
* @param mosipin The arduino pin number to use for MOSI, set to -1 if not
* used
* @param freq The SPI clock frequency to use, defaults to 1MHz
* @param dataOrder The SPI data order to use for bits within each byte,
* defaults to SPI_BITORDER_MSBFIRST
* @param dataMode The SPI mode to use, defaults to SPI_MODE0
*/
Adafruit_SPIDevice::Adafruit_SPIDevice(int8_t cspin, int8_t sckpin,
int8_t misopin, int8_t mosipin,
uint32_t freq, BusIOBitOrder dataOrder,
uint8_t dataMode) {
_cs = cspin;
_sck = sckpin;
_miso = misopin;
_mosi = mosipin;
#ifdef BUSIO_USE_FAST_PINIO
csPort = (BusIO_PortReg *)portOutputRegister(digitalPinToPort(cspin));
csPinMask = digitalPinToBitMask(cspin);
if (mosipin != -1) {
mosiPort = (BusIO_PortReg *)portOutputRegister(digitalPinToPort(mosipin));
mosiPinMask = digitalPinToBitMask(mosipin);
}
if (misopin != -1) {
misoPort = (BusIO_PortReg *)portInputRegister(digitalPinToPort(misopin));
misoPinMask = digitalPinToBitMask(misopin);
}
clkPort = (BusIO_PortReg *)portOutputRegister(digitalPinToPort(sckpin));
clkPinMask = digitalPinToBitMask(sckpin);
#endif
_freq = freq;
_dataOrder = dataOrder;
_dataMode = dataMode;
_begun = false;
}
/*!
* @brief Release memory allocated in constructors
*/
Adafruit_SPIDevice::~Adafruit_SPIDevice() {
if (_spiSetting)
delete _spiSetting;
}
/*!
* @brief Initializes SPI bus and sets CS pin high
* @return Always returns true because there's no way to test success of SPI
* init
*/
bool Adafruit_SPIDevice::begin(void) {
if (_cs != -1) {
pinMode(_cs, OUTPUT);
digitalWrite(_cs, HIGH);
}
if (_spi) { // hardware SPI
#ifdef BUSIO_HAS_HW_SPI
_spi->begin();
#endif
} else {
pinMode(_sck, OUTPUT);
if ((_dataMode == SPI_MODE0) || (_dataMode == SPI_MODE1)) {
// idle low on mode 0 and 1
digitalWrite(_sck, LOW);
} else {
// idle high on mode 2 or 3
digitalWrite(_sck, HIGH);
}
if (_mosi != -1) {
pinMode(_mosi, OUTPUT);
digitalWrite(_mosi, HIGH);
}
if (_miso != -1) {
pinMode(_miso, INPUT);
}
}
_begun = true;
return true;
}
/*!
* @brief Transfer (send/receive) a buffer over hard/soft SPI, without
* transaction management
* @param buffer The buffer to send and receive at the same time
* @param len The number of bytes to transfer
*/
void Adafruit_SPIDevice::transfer(uint8_t *buffer, size_t len) {
//
// HARDWARE SPI
//
if (_spi) {
#ifdef BUSIO_HAS_HW_SPI
#if defined(SPARK)
_spi->transfer(buffer, buffer, len, nullptr);
#elif defined(STM32)
for (size_t i = 0; i < len; i++) {
_spi->transfer(buffer[i]);
}
#else
_spi->transfer(buffer, len);
#endif
return;
#endif
}
//
// SOFTWARE SPI
//
uint8_t startbit;
if (_dataOrder == SPI_BITORDER_LSBFIRST) {
startbit = 0x1;
} else {
startbit = 0x80;
}
bool towrite, lastmosi = !(buffer[0] & startbit);
uint8_t bitdelay_us = (1000000 / _freq) / 2;
for (size_t i = 0; i < len; i++) {
uint8_t reply = 0;
uint8_t send = buffer[i];
/*
Serial.print("\tSending software SPI byte 0x");
Serial.print(send, HEX);
Serial.print(" -> 0x");
*/
// Serial.print(send, HEX);
for (uint8_t b = startbit; b != 0;
b = (_dataOrder == SPI_BITORDER_LSBFIRST) ? b << 1 : b >> 1) {
if (bitdelay_us) {
delayMicroseconds(bitdelay_us);
}
if (_dataMode == SPI_MODE0 || _dataMode == SPI_MODE2) {
towrite = send & b;
if ((_mosi != -1) && (lastmosi != towrite)) {
BUSIO_WRITE_MOSI(towrite);
lastmosi = towrite;
}
BUSIO_SET_CLOCK_HIGH();
if (bitdelay_us) {
delayMicroseconds(bitdelay_us);
}
if (_miso != -1) {
if (BUSIO_READ_MISO())
reply |= b;
}
BUSIO_SET_CLOCK_LOW();
} else if (_dataMode == SPI_MODE3) {
if (_mosi != -1) { // transmit on falling edge
BUSIO_WRITE_MOSI(send & b);
}
BUSIO_SET_CLOCK_LOW();
if (bitdelay_us) {
delayMicroseconds(bitdelay_us);
}
BUSIO_SET_CLOCK_HIGH();
if (bitdelay_us) {
delayMicroseconds(bitdelay_us);
}
if (_miso != -1) { // read on rising edge
if (BUSIO_READ_MISO()) {
reply |= b;
}
}
} else { // || _dataMode == SPI_MODE1)
BUSIO_SET_CLOCK_HIGH();
if (bitdelay_us) {
delayMicroseconds(bitdelay_us);
}
if (_mosi != -1) {
BUSIO_WRITE_MOSI(send & b);
}
BUSIO_SET_CLOCK_LOW();
if (_miso != -1) {
if (BUSIO_READ_MISO()) {
reply |= b;
}
}
}
}
if (_miso != -1) {
buffer[i] = reply;
}
}
return;
}
/*!
* @brief Transfer (send/receive) one byte over hard/soft SPI, without
* transaction management
* @param send The byte to send
* @return The byte received while transmitting
*/
uint8_t Adafruit_SPIDevice::transfer(uint8_t send) {
uint8_t data = send;
transfer(&data, 1);
return data;
}
/*!
* @brief Manually begin a transaction (calls beginTransaction if hardware
* SPI)
*/
void Adafruit_SPIDevice::beginTransaction(void) {
if (_spi) {
#ifdef BUSIO_HAS_HW_SPI
_spi->beginTransaction(*_spiSetting);
#endif
}
}
/*!
* @brief Manually end a transaction (calls endTransaction if hardware SPI)
*/
void Adafruit_SPIDevice::endTransaction(void) {
if (_spi) {
#ifdef BUSIO_HAS_HW_SPI
_spi->endTransaction();
#endif
}
}
/*!
* @brief Assert/Deassert the CS pin if it is defined
* @param value The state the CS is set to
*/
void Adafruit_SPIDevice::setChipSelect(int value) {
if (_cs != -1) {
digitalWrite(_cs, value);
}
}
/*!
* @brief Write a buffer or two to the SPI device, with transaction
* management.
* @brief Manually begin a transaction (calls beginTransaction if hardware
* SPI) with asserting the CS pin
*/
void Adafruit_SPIDevice::beginTransactionWithAssertingCS() {
beginTransaction();
setChipSelect(LOW);
}
/*!
* @brief Manually end a transaction (calls endTransaction if hardware SPI)
* with deasserting the CS pin
*/
void Adafruit_SPIDevice::endTransactionWithDeassertingCS() {
setChipSelect(HIGH);
endTransaction();
}
/*!
* @brief Write a buffer or two to the SPI device, with transaction
* management.
* @param buffer Pointer to buffer of data to write
* @param len Number of bytes from buffer to write
* @param prefix_buffer Pointer to optional array of data to write before
* buffer.
* @param prefix_len Number of bytes from prefix buffer to write
* @return Always returns true because there's no way to test success of SPI
* writes
*/
bool Adafruit_SPIDevice::write(const uint8_t *buffer, size_t len,
const uint8_t *prefix_buffer,
size_t prefix_len) {
beginTransactionWithAssertingCS();
// do the writing
#if defined(ARDUINO_ARCH_ESP32)
if (_spi) {
if (prefix_len > 0) {
_spi->transferBytes((uint8_t *)prefix_buffer, nullptr, prefix_len);
}
if (len > 0) {
_spi->transferBytes((uint8_t *)buffer, nullptr, len);
}
} else
#endif
{
for (size_t i = 0; i < prefix_len; i++) {
transfer(prefix_buffer[i]);
}
for (size_t i = 0; i < len; i++) {
transfer(buffer[i]);
}
}
endTransactionWithDeassertingCS();
#ifdef DEBUG_SERIAL
DEBUG_SERIAL.print(F("\tSPIDevice Wrote: "));
if ((prefix_len != 0) && (prefix_buffer != nullptr)) {
for (uint16_t i = 0; i < prefix_len; i++) {
DEBUG_SERIAL.print(F("0x"));
DEBUG_SERIAL.print(prefix_buffer[i], HEX);
DEBUG_SERIAL.print(F(", "));
}
}
for (uint16_t i = 0; i < len; i++) {
DEBUG_SERIAL.print(F("0x"));
DEBUG_SERIAL.print(buffer[i], HEX);
DEBUG_SERIAL.print(F(", "));
if (i % 32 == 31) {
DEBUG_SERIAL.println();
}
}
DEBUG_SERIAL.println();
#endif
return true;
}
/*!
* @brief Read from SPI into a buffer from the SPI device, with transaction
* management.
* @param buffer Pointer to buffer of data to read into
* @param len Number of bytes from buffer to read.
* @param sendvalue The 8-bits of data to write when doing the data read,
* defaults to 0xFF
* @return Always returns true because there's no way to test success of SPI
* writes
*/
bool Adafruit_SPIDevice::read(uint8_t *buffer, size_t len, uint8_t sendvalue) {
memset(buffer, sendvalue, len); // clear out existing buffer
beginTransactionWithAssertingCS();
transfer(buffer, len);
endTransactionWithDeassertingCS();
#ifdef DEBUG_SERIAL
DEBUG_SERIAL.print(F("\tSPIDevice Read: "));
for (uint16_t i = 0; i < len; i++) {
DEBUG_SERIAL.print(F("0x"));
DEBUG_SERIAL.print(buffer[i], HEX);
DEBUG_SERIAL.print(F(", "));
if (len % 32 == 31) {
DEBUG_SERIAL.println();
}
}
DEBUG_SERIAL.println();
#endif
return true;
}
/*!
* @brief Write some data, then read some data from SPI into another buffer,
* with transaction management. The buffers can point to same/overlapping
* locations. This does not transmit-receive at the same time!
* @param write_buffer Pointer to buffer of data to write from
* @param write_len Number of bytes from buffer to write.
* @param read_buffer Pointer to buffer of data to read into.
* @param read_len Number of bytes from buffer to read.
* @param sendvalue The 8-bits of data to write when doing the data read,
* defaults to 0xFF
* @return Always returns true because there's no way to test success of SPI
* writes
*/
bool Adafruit_SPIDevice::write_then_read(const uint8_t *write_buffer,
size_t write_len, uint8_t *read_buffer,
size_t read_len, uint8_t sendvalue) {
beginTransactionWithAssertingCS();
// do the writing
#if defined(ARDUINO_ARCH_ESP32)
if (_spi) {
if (write_len > 0) {
_spi->transferBytes((uint8_t *)write_buffer, nullptr, write_len);
}
} else
#endif
{
for (size_t i = 0; i < write_len; i++) {
transfer(write_buffer[i]);
}
}
#ifdef DEBUG_SERIAL
DEBUG_SERIAL.print(F("\tSPIDevice Wrote: "));
for (uint16_t i = 0; i < write_len; i++) {
DEBUG_SERIAL.print(F("0x"));
DEBUG_SERIAL.print(write_buffer[i], HEX);
DEBUG_SERIAL.print(F(", "));
if (write_len % 32 == 31) {
DEBUG_SERIAL.println();
}
}
DEBUG_SERIAL.println();
#endif
// do the reading
for (size_t i = 0; i < read_len; i++) {
read_buffer[i] = transfer(sendvalue);
}
#ifdef DEBUG_SERIAL
DEBUG_SERIAL.print(F("\tSPIDevice Read: "));
for (uint16_t i = 0; i < read_len; i++) {
DEBUG_SERIAL.print(F("0x"));
DEBUG_SERIAL.print(read_buffer[i], HEX);
DEBUG_SERIAL.print(F(", "));
if (read_len % 32 == 31) {
DEBUG_SERIAL.println();
}
}
DEBUG_SERIAL.println();
#endif
endTransactionWithDeassertingCS();
return true;
}
/*!
* @brief Write some data and read some data at the same time from SPI
* into the same buffer, with transaction management. This is basicaly a wrapper
* for transfer() with CS-pin and transaction management. This /does/
* transmit-receive at the same time!
* @param buffer Pointer to buffer of data to write/read to/from
* @param len Number of bytes from buffer to write/read.
* @return Always returns true because there's no way to test success of SPI
* writes
*/
bool Adafruit_SPIDevice::write_and_read(uint8_t *buffer, size_t len) {
beginTransactionWithAssertingCS();
transfer(buffer, len);
endTransactionWithDeassertingCS();
return true;
}
libraries/Adafruit_BusIO/Adafruit_SPIDevice.h
+149
View File
@@ -0,0 +1,149 @@
#ifndef Adafruit_SPIDevice_h
#define Adafruit_SPIDevice_h
#include <Arduino.h>
#if !defined(SPI_INTERFACES_COUNT) || \
(defined(SPI_INTERFACES_COUNT) && (SPI_INTERFACES_COUNT > 0))
// HW SPI available
#include <SPI.h>
#define BUSIO_HAS_HW_SPI
#else
// SW SPI ONLY
enum { SPI_MODE0, SPI_MODE1, SPI_MODE2, SPI_MODE3 };
typedef uint8_t SPIClass;
#endif
// some modern SPI definitions don't have BitOrder enum
#if (defined(__AVR__) && !defined(ARDUINO_ARCH_MEGAAVR)) || \
defined(ESP8266) || defined(TEENSYDUINO) || defined(SPARK) || \
defined(ARDUINO_ARCH_SPRESENSE) || defined(MEGATINYCORE) || \
defined(DXCORE) || defined(ARDUINO_AVR_ATmega4809) || \
defined(ARDUINO_AVR_ATmega4808) || defined(ARDUINO_AVR_ATmega3209) || \
defined(ARDUINO_AVR_ATmega3208) || defined(ARDUINO_AVR_ATmega1609) || \
defined(ARDUINO_AVR_ATmega1608) || defined(ARDUINO_AVR_ATmega809) || \
defined(ARDUINO_AVR_ATmega808) || defined(ARDUINO_ARCH_ARC32) || \
defined(ARDUINO_ARCH_XMC)
typedef enum _BitOrder {
SPI_BITORDER_MSBFIRST = MSBFIRST,
SPI_BITORDER_LSBFIRST = LSBFIRST,
} BusIOBitOrder;
#elif defined(ESP32) || defined(__ASR6501__) || defined(__ASR6502__)
// some modern SPI definitions don't have BitOrder enum and have different SPI
// mode defines
typedef enum _BitOrder {
SPI_BITORDER_MSBFIRST = SPI_MSBFIRST,
SPI_BITORDER_LSBFIRST = SPI_LSBFIRST,
} BusIOBitOrder;
#else
// Some platforms have a BitOrder enum but its named MSBFIRST/LSBFIRST
#define SPI_BITORDER_MSBFIRST MSBFIRST
#define SPI_BITORDER_LSBFIRST LSBFIRST
typedef BitOrder BusIOBitOrder;
#endif
#if defined(__IMXRT1062__) // Teensy 4.x
// *Warning* I disabled the usage of FAST_PINIO as the set/clear operations
// used in the cpp file are not atomic and can effect multiple IO pins
// and if an interrupt happens in between the time the code reads the register
// and writes out the updated value, that changes one or more other IO pins
// on that same IO port, those change will be clobbered when the updated
// values are written back. A fast version can be implemented that uses the
// ports set and clear registers which are atomic.
// typedef volatile uint32_t BusIO_PortReg;
// typedef uint32_t BusIO_PortMask;
// #define BUSIO_USE_FAST_PINIO
#elif defined(__MBED__) || defined(__ZEPHYR__)
// Boards based on RTOS cores like mbed or Zephyr are not going to expose the
// low level registers needed for fast pin manipulation
#undef BUSIO_USE_FAST_PINIO
#elif defined(ARDUINO_ARCH_XMC)
#undef BUSIO_USE_FAST_PINIO
#elif defined(__AVR__) || defined(TEENSYDUINO)
typedef volatile uint8_t BusIO_PortReg;
typedef uint8_t BusIO_PortMask;
#define BUSIO_USE_FAST_PINIO
#elif defined(ESP8266) || defined(ESP32) || defined(__SAM3X8E__) || \
defined(ARDUINO_ARCH_SAMD)
typedef volatile uint32_t BusIO_PortReg;
typedef uint32_t BusIO_PortMask;
#define BUSIO_USE_FAST_PINIO
#elif (defined(__arm__) || defined(ARDUINO_FEATHER52)) && \
!defined(ARDUINO_ARCH_RP2040) && !defined(ARDUINO_SILABS) && \
!defined(ARDUINO_UNOR4_MINIMA) && !defined(ARDUINO_UNOR4_WIFI) && \
!defined(PORTDUINO)
typedef volatile uint32_t BusIO_PortReg;
typedef uint32_t BusIO_PortMask;
#if !defined(__ASR6501__) && !defined(__ASR6502__)
#define BUSIO_USE_FAST_PINIO
#endif
#else
#undef BUSIO_USE_FAST_PINIO
#endif
/**! The class which defines how we will talk to this device over SPI **/
class Adafruit_SPIDevice {
public:
#ifdef BUSIO_HAS_HW_SPI
Adafruit_SPIDevice(int8_t cspin, uint32_t freq = 1000000,
BusIOBitOrder dataOrder = SPI_BITORDER_MSBFIRST,
uint8_t dataMode = SPI_MODE0, SPIClass *theSPI = &SPI);
#else
Adafruit_SPIDevice(int8_t cspin, uint32_t freq = 1000000,
BusIOBitOrder dataOrder = SPI_BITORDER_MSBFIRST,
uint8_t dataMode = SPI_MODE0, SPIClass *theSPI = nullptr);
#endif
Adafruit_SPIDevice(int8_t cspin, int8_t sck, int8_t miso, int8_t mosi,
uint32_t freq = 1000000,
BusIOBitOrder dataOrder = SPI_BITORDER_MSBFIRST,
uint8_t dataMode = SPI_MODE0);
~Adafruit_SPIDevice();
bool begin(void);
bool read(uint8_t *buffer, size_t len, uint8_t sendvalue = 0xFF);
bool write(const uint8_t *buffer, size_t len,
const uint8_t *prefix_buffer = nullptr, size_t prefix_len = 0);
bool write_then_read(const uint8_t *write_buffer, size_t write_len,
uint8_t *read_buffer, size_t read_len,
uint8_t sendvalue = 0xFF);
bool write_and_read(uint8_t *buffer, size_t len);
uint8_t transfer(uint8_t send);
void transfer(uint8_t *buffer, size_t len);
void beginTransaction(void);
void endTransaction(void);
void beginTransactionWithAssertingCS();
void endTransactionWithDeassertingCS();
private:
#ifdef BUSIO_HAS_HW_SPI
SPIClass *_spi = nullptr;
SPISettings *_spiSetting = nullptr;
#else
uint8_t *_spi = nullptr;
uint8_t *_spiSetting = nullptr;
#endif
uint32_t _freq;
BusIOBitOrder _dataOrder;
uint8_t _dataMode;
void setChipSelect(int value);
int8_t _cs, _sck, _mosi, _miso;
#ifdef BUSIO_USE_FAST_PINIO
BusIO_PortReg *mosiPort, *clkPort, *misoPort, *csPort;
BusIO_PortMask mosiPinMask, misoPinMask, clkPinMask, csPinMask;
#endif
bool _begun;
};
#endif // Adafruit_SPIDevice_h
libraries/Adafruit_BusIO/CMakeLists.txt
+11
View File
@@ -0,0 +1,11 @@
# Adafruit Bus IO Library
# https://github.com/adafruit/Adafruit_BusIO
# MIT License
cmake_minimum_required(VERSION 3.5)
idf_component_register(SRCS "Adafruit_I2CDevice.cpp" "Adafruit_BusIO_Register.cpp" "Adafruit_SPIDevice.cpp" "Adafruit_GenericDevice.cpp"
INCLUDE_DIRS "."
REQUIRES arduino-esp32)
project(Adafruit_BusIO)
libraries/Adafruit_BusIO/LICENSE
+21
View File
@@ -0,0 +1,21 @@
The MIT License (MIT)
Copyright (c) 2017 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.
libraries/Adafruit_BusIO/README.md
+8
View File
@@ -0,0 +1,8 @@
# Adafruit Bus IO Library [![Build Status](https://github.com/adafruit/Adafruit_BusIO/workflows/Arduino%20Library%20CI/badge.svg)](https://github.com/adafruit/Adafruit_BusIO/actions)
This is a helper library to abstract away I2C, SPI, and 'generic transport' (e.g. UART) transactions and registers
Adafruit invests time and resources providing this open source code, please support Adafruit and open-source hardware by purchasing products from Adafruit!
MIT license, all text above must be included in any redistribution
libraries/Adafruit_BusIO/component.mk
+1
View File
@@ -0,0 +1 @@
COMPONENT_ADD_INCLUDEDIRS = .
libraries/Adafruit_BusIO/examples/genericdevice_uartregtest/genericdevice_uartregtest.ino
+219
View File
@@ -0,0 +1,219 @@
/*
Advanced example of using bstracted transport for reading and writing
register data from a UART-based device such as a TMC2209
Written with help by Claude!
https://claude.ai/chat/335f50b1-3dd8-435e-9139-57ec7ca26a3c (at this time
chats are not shareable :(
*/
#include "Adafruit_BusIO_Register.h"
#include "Adafruit_GenericDevice.h"
// Debugging macros
#define DEBUG_SERIAL Serial
#ifdef DEBUG_SERIAL
#define DEBUG_PRINT(x) DEBUG_SERIAL.print(x)
#define DEBUG_PRINTLN(x) DEBUG_SERIAL.println(x)
#define DEBUG_PRINT_HEX(x) \
do { \
if (x < 0x10) \
DEBUG_SERIAL.print('0'); \
DEBUG_SERIAL.print(x, HEX); \
DEBUG_SERIAL.print(' '); \
} while (0)
#else
#define DEBUG_PRINT(x)
#define DEBUG_PRINTLN(x)
#define DEBUG_PRINT_HEX(x)
#endif
#define TMC2209_IOIN 0x06
class TMC2209_UART {
private:
Stream *_uart_stream;
uint8_t _addr;
static bool uart_read(void *thiz, uint8_t *buffer, size_t len) {
TMC2209_UART *dev = (TMC2209_UART *)thiz;
uint16_t timeout = 100;
while (dev->_uart_stream->available() < len && timeout--) {
delay(1);
}
if (timeout == 0) {
DEBUG_PRINTLN("Read timeout!");
return false;
}
DEBUG_PRINT("Reading: ");
for (size_t i = 0; i < len; i++) {
buffer[i] = dev->_uart_stream->read();
DEBUG_PRINT_HEX(buffer[i]);
}
DEBUG_PRINTLN("");
return true;
}
static bool uart_write(void *thiz, const uint8_t *buffer, size_t len) {
TMC2209_UART *dev = (TMC2209_UART *)thiz;
DEBUG_PRINT("Writing: ");
for (size_t i = 0; i < len; i++) {
DEBUG_PRINT_HEX(buffer[i]);
}
DEBUG_PRINTLN("");
dev->_uart_stream->write(buffer, len);
return true;
}
static bool uart_readreg(void *thiz, uint8_t *addr_buf, uint8_t addrsiz,
uint8_t *data, uint16_t datalen) {
TMC2209_UART *dev = (TMC2209_UART *)thiz;
while (dev->_uart_stream->available())
dev->_uart_stream->read();
uint8_t packet[4] = {0x05, uint8_t(dev->_addr << 1), addr_buf[0], 0x00};
packet[3] = calcCRC(packet, 3);
if (!uart_write(thiz, packet, 4))
return false;
// Read back echo
uint8_t echo[4];
if (!uart_read(thiz, echo, 4))
return false;
// Verify echo
for (uint8_t i = 0; i < 4; i++) {
if (echo[i] != packet[i]) {
DEBUG_PRINTLN("Echo mismatch");
return false;
}
}
uint8_t response[8]; // sync + 0xFF + reg + 4 data bytes + CRC
if (!uart_read(thiz, response, 8))
return false;
// Verify response
if (response[0] != 0x05) {
DEBUG_PRINTLN("Invalid sync byte");
return false;
}
if (response[1] != 0xFF) {
DEBUG_PRINTLN("Invalid reply address");
return false;
}
if (response[2] != addr_buf[0]) {
DEBUG_PRINTLN("Register mismatch");
return false;
}
uint8_t crc = calcCRC(response, 7);
if (crc != response[7]) {
DEBUG_PRINTLN("CRC mismatch");
return false;
}
memcpy(data, &response[3], 4);
return true;
}
static bool uart_writereg(void *thiz, uint8_t *addr_buf, uint8_t addrsiz,
const uint8_t *data, uint16_t datalen) {
TMC2209_UART *dev = (TMC2209_UART *)thiz;
while (dev->_uart_stream->available())
dev->_uart_stream->read();
uint8_t packet[8] = {0x05,
uint8_t(dev->_addr << 1),
uint8_t(addr_buf[0] | 0x80),
data[0],
data[1],
data[2],
data[3],
0x00};
packet[7] = calcCRC(packet, 7);
if (!uart_write(thiz, packet, 8))
return false;
uint8_t echo[8];
if (!uart_read(thiz, echo, 8))
return false;
for (uint8_t i = 0; i < 8; i++) {
if (echo[i] != packet[i]) {
DEBUG_PRINTLN("Write echo mismatch");
return false;
}
}
return true;
}
static uint8_t calcCRC(uint8_t *data, uint8_t length) {
uint8_t crc = 0;
for (uint8_t i = 0; i < length; i++) {
uint8_t currentByte = data[i];
for (uint8_t j = 0; j < 8; j++) {
if ((crc >> 7) ^ (currentByte & 0x01)) {
crc = (crc << 1) ^ 0x07;
} else {
crc = crc << 1;
}
currentByte = currentByte >> 1;
}
}
return crc;
}
public:
TMC2209_UART(Stream *serial, uint8_t addr)
: _uart_stream(serial), _addr(addr) {}
Adafruit_GenericDevice *createDevice() {
return new Adafruit_GenericDevice(this, uart_read, uart_write, uart_readreg,
uart_writereg);
}
};
void setup() {
Serial.begin(115200);
while (!Serial)
;
delay(100);
Serial.println("TMC2209 Generic Device register read/write test!");
Serial1.begin(115200);
TMC2209_UART uart(&Serial1, 0);
Adafruit_GenericDevice *device = uart.createDevice();
device->begin();
// Create register object for IOIN
Adafruit_BusIO_Register ioin_reg(device,
TMC2209_IOIN, // device and register address
4, // width = 4 bytes
MSBFIRST, // byte order
1); // address width = 1 byte
Serial.print("IOIN = 0x");
Serial.println(ioin_reg.read(), HEX);
// Create RegisterBits for VERSION field (bits 31:24)
Adafruit_BusIO_RegisterBits version_bits(
&ioin_reg, 8, 24); // 8 bits wide, starting at bit 24
Serial.println("Reading VERSION...");
uint8_t version = version_bits.read();
Serial.print("VERSION = 0x");
Serial.println(version, HEX);
}
void loop() { delay(1000); }
libraries/Adafruit_BusIO/examples/genericdevice_uarttest/genericdevice_uarttest.ino
+98
View File
@@ -0,0 +1,98 @@
/*
Abstracted transport for reading and writing data from a UART-based
device such as a TMC2209
Written with help by Claude!
https://claude.ai/chat/335f50b1-3dd8-435e-9139-57ec7ca26a3c (at this time
chats are not shareable :(
*/
#include "Adafruit_GenericDevice.h"
/**
* Basic UART device class that demonstrates using GenericDevice with a Stream
* interface. This example shows how to wrap a Stream (like HardwareSerial or
* SoftwareSerial) with read/write callbacks that can be used by BusIO's
* register functions.
*/
class UARTDevice {
public:
UARTDevice(Stream *serial) : _serial(serial) {}
// Static callback for writing data to UART
// Called by GenericDevice when data needs to be sent
static bool uart_write(void *thiz, const uint8_t *buffer, size_t len) {
UARTDevice *dev = (UARTDevice *)thiz;
dev->_serial->write(buffer, len);
return true;
}
// Static callback for reading data from UART
// Includes timeout and will return false if not enough data available
static bool uart_read(void *thiz, uint8_t *buffer, size_t len) {
UARTDevice *dev = (UARTDevice *)thiz;
uint16_t timeout = 100;
while (dev->_serial->available() < len && timeout--) {
delay(1);
}
if (timeout == 0) {
return false;
}
for (size_t i = 0; i < len; i++) {
buffer[i] = dev->_serial->read();
}
return true;
}
// Create a GenericDevice instance using our callbacks
Adafruit_GenericDevice *createDevice() {
return new Adafruit_GenericDevice(this, uart_read, uart_write);
}
private:
Stream *_serial; // Underlying Stream instance (HardwareSerial, etc)
};
void setup() {
Serial.begin(115200);
while (!Serial)
;
delay(100);
Serial.println("Generic Device test!");
// Initialize UART for device communication
Serial1.begin(115200);
// Create UART wrapper and BusIO device
UARTDevice uart(&Serial1);
Adafruit_GenericDevice *device = uart.createDevice();
device->begin();
// Test write/read cycle
uint8_t write_buf[4] = {0x5, 0x0, 0x0, 0x48};
uint8_t read_buf[8];
Serial.println("Writing data...");
if (!device->write(write_buf, 4)) {
Serial.println("Write failed!");
return;
}
Serial.println("Reading response...");
if (!device->read(read_buf, 8)) {
Serial.println("Read failed!");
return;
}
// Print response bytes
Serial.print("Got response: ");
for (int i = 0; i < 8; i++) {
Serial.print("0x");
Serial.print(read_buf[i], HEX);
Serial.print(" ");
}
Serial.println();
}
void loop() { delay(1000); }
libraries/Adafruit_BusIO/examples/i2c_address_detect/i2c_address_detect.ino
+22
View File
@@ -0,0 +1,22 @@
#include <Adafruit_I2CDevice.h>
Adafruit_I2CDevice i2c_dev = Adafruit_I2CDevice(0x10);
void setup() {
while (!Serial) {
delay(10);
}
Serial.begin(115200);
Serial.println("I2C address detection test");
if (!i2c_dev.begin()) {
Serial.print("Did not find device at 0x");
Serial.println(i2c_dev.address(), HEX);
while (1)
;
}
Serial.print("Device found on address 0x");
Serial.println(i2c_dev.address(), HEX);
}
void loop() {}
libraries/Adafruit_BusIO/examples/i2c_readwrite/i2c_readwrite.ino
+45
View File
@@ -0,0 +1,45 @@
#include <Adafruit_I2CDevice.h>
#define I2C_ADDRESS 0x60
Adafruit_I2CDevice i2c_dev = Adafruit_I2CDevice(I2C_ADDRESS);
void setup() {
while (!Serial) {
delay(10);
}
Serial.begin(115200);
Serial.println("I2C device read and write test");
if (!i2c_dev.begin()) {
Serial.print("Did not find device at 0x");
Serial.println(i2c_dev.address(), HEX);
while (1)
;
}
Serial.print("Device found on address 0x");
Serial.println(i2c_dev.address(), HEX);
uint8_t buffer[32];
// Try to read 32 bytes
i2c_dev.read(buffer, 32);
Serial.print("Read: ");
for (uint8_t i = 0; i < 32; i++) {
Serial.print("0x");
Serial.print(buffer[i], HEX);
Serial.print(", ");
}
Serial.println();
// read a register by writing first, then reading
buffer[0] = 0x0C; // we'll reuse the same buffer
i2c_dev.write_then_read(buffer, 1, buffer, 2, false);
Serial.print("Write then Read: ");
for (uint8_t i = 0; i < 2; i++) {
Serial.print("0x");
Serial.print(buffer[i], HEX);
Serial.print(", ");
}
Serial.println();
}
void loop() {}
libraries/Adafruit_BusIO/examples/i2c_registers/i2c_registers.ino
+43
View File
@@ -0,0 +1,43 @@
#include <Adafruit_BusIO_Register.h>
#include <Adafruit_I2CDevice.h>
#define I2C_ADDRESS 0x60
Adafruit_I2CDevice i2c_dev = Adafruit_I2CDevice(I2C_ADDRESS);
void setup() {
while (!Serial) {
delay(10);
}
Serial.begin(115200);
Serial.println("I2C device register test");
if (!i2c_dev.begin()) {
Serial.print("Did not find device at 0x");
Serial.println(i2c_dev.address(), HEX);
while (1)
;
}
Serial.print("Device found on address 0x");
Serial.println(i2c_dev.address(), HEX);
Adafruit_BusIO_Register id_reg =
Adafruit_BusIO_Register(&i2c_dev, 0x0C, 2, LSBFIRST);
uint16_t id;
id_reg.read(&id);
Serial.print("ID register = 0x");
Serial.println(id, HEX);
Adafruit_BusIO_Register thresh_reg =
Adafruit_BusIO_Register(&i2c_dev, 0x01, 2, LSBFIRST);
uint16_t thresh;
thresh_reg.read(&thresh);
Serial.print("Initial threshold register = 0x");
Serial.println(thresh, HEX);
thresh_reg.write(~thresh);
Serial.print("Post threshold register = 0x");
Serial.println(thresh_reg.read(), HEX);
}
void loop() {}
libraries/Adafruit_BusIO/examples/i2corspi_register/i2corspi_register.ino
+40
View File
@@ -0,0 +1,40 @@
#include <Adafruit_BusIO_Register.h>
// Define which interface to use by setting the unused interface to NULL!
#define SPIDEVICE_CS 10
Adafruit_SPIDevice *spi_dev = NULL; // new Adafruit_SPIDevice(SPIDEVICE_CS);
#define I2C_ADDRESS 0x5D
Adafruit_I2CDevice *i2c_dev = new Adafruit_I2CDevice(I2C_ADDRESS);
void setup() {
while (!Serial) {
delay(10);
}
Serial.begin(115200);
Serial.println("I2C or SPI device register test");
if (spi_dev && !spi_dev->begin()) {
Serial.println("Could not initialize SPI device");
}
if (i2c_dev) {
if (i2c_dev->begin()) {
Serial.print("Device found on I2C address 0x");
Serial.println(i2c_dev->address(), HEX);
} else {
Serial.print("Did not find I2C device at 0x");
Serial.println(i2c_dev->address(), HEX);
}
}
Adafruit_BusIO_Register id_reg =
Adafruit_BusIO_Register(i2c_dev, spi_dev, ADDRBIT8_HIGH_TOREAD, 0x0F);
uint8_t id = 0;
id_reg.read(&id);
Serial.print("ID register = 0x");
Serial.println(id, HEX);
}
void loop() {}
libraries/Adafruit_BusIO/examples/spi_modetest/spi_modetest.ino
+35
View File
@@ -0,0 +1,35 @@
#include <Adafruit_SPIDevice.h>
#define SPIDEVICE_CS 10
Adafruit_SPIDevice spi_dev =
Adafruit_SPIDevice(SPIDEVICE_CS, 100000, SPI_BITORDER_MSBFIRST, SPI_MODE1);
// Adafruit_SPIDevice spi_dev = Adafruit_SPIDevice(SPIDEVICE_CS, 13, 12, 11,
// 100000, SPI_BITORDER_MSBFIRST, SPI_MODE1);
void setup() {
while (!Serial) {
delay(10);
}
Serial.begin(115200);
Serial.println("SPI device mode test");
if (!spi_dev.begin()) {
Serial.println("Could not initialize SPI device");
while (1)
;
}
}
void loop() {
Serial.println("\n\nTransfer test");
for (uint16_t x = 0; x <= 0xFF; x++) {
uint8_t i = x;
Serial.print("0x");
Serial.print(i, HEX);
spi_dev.read(&i, 1, i);
Serial.print("/");
Serial.print(i, HEX);
Serial.print(", ");
delay(25);
}
}
libraries/Adafruit_BusIO/examples/spi_readwrite/spi_readwrite.ino
+43
View File
@@ -0,0 +1,43 @@
#include <Adafruit_SPIDevice.h>
#define SPIDEVICE_CS 10
Adafruit_SPIDevice spi_dev = Adafruit_SPIDevice(SPIDEVICE_CS);
void setup() {
while (!Serial) {
delay(10);
}
Serial.begin(115200);
Serial.println("SPI device read and write test");
if (!spi_dev.begin()) {
Serial.println("Could not initialize SPI device");
while (1)
;
}
uint8_t buffer[32];
// Try to read 32 bytes
spi_dev.read(buffer, 32);
Serial.print("Read: ");
for (uint8_t i = 0; i < 32; i++) {
Serial.print("0x");
Serial.print(buffer[i], HEX);
Serial.print(", ");
}
Serial.println();
// read a register by writing first, then reading
buffer[0] = 0x8F; // we'll reuse the same buffer
spi_dev.write_then_read(buffer, 1, buffer, 2, false);
Serial.print("Write then Read: ");
for (uint8_t i = 0; i < 2; i++) {
Serial.print("0x");
Serial.print(buffer[i], HEX);
Serial.print(", ");
}
Serial.println();
}
void loop() {}
libraries/Adafruit_BusIO/examples/spi_register_bits/spi_register_bits.ino
+268
View File
@@ -0,0 +1,268 @@
/***************************************************
This is an example for how to use Adafruit_BusIO_RegisterBits from
Adafruit_BusIO library.
Designed specifically to work with the Adafruit RTD Sensor
----> https://www.adafruit.com/products/3328
uisng a MAX31865 RTD-to-Digital Converter
----> https://datasheets.maximintegrated.com/en/ds/MAX31865.pdf
This sensor uses SPI to communicate, 4 pins are required to
interface.
A fifth pin helps to detect when a new conversion is ready.
Adafruit invests time and resources providing this open source code,
please support Adafruit and open-source hardware by purchasing
products from Adafruit!
Example written (2020/3) by Andreas Hardtung/AnHard.
BSD license, all text above must be included in any redistribution
****************************************************/
#include <Adafruit_BusIO_Register.h>
#include <Adafruit_SPIDevice.h>
#define MAX31865_SPI_SPEED (5000000)
#define MAX31865_SPI_BITORDER (SPI_BITORDER_MSBFIRST)
#define MAX31865_SPI_MODE (SPI_MODE1)
#define MAX31865_SPI_CS (10)
#define MAX31865_READY_PIN (2)
Adafruit_SPIDevice spi_dev = Adafruit_SPIDevice(
MAX31865_SPI_CS, MAX31865_SPI_SPEED, MAX31865_SPI_BITORDER,
MAX31865_SPI_MODE, &SPI); // Hardware SPI
// Adafruit_SPIDevice spi_dev = Adafruit_SPIDevice( MAX31865_SPI_CS, 13, 12, 11,
// MAX31865_SPI_SPEED, MAX31865_SPI_BITORDER, MAX31865_SPI_MODE); // Software
// SPI
// MAX31865 chip related
// *********************************************************************************************
Adafruit_BusIO_Register config_reg =
Adafruit_BusIO_Register(&spi_dev, 0x00, ADDRBIT8_HIGH_TOWRITE, 1, MSBFIRST);
Adafruit_BusIO_RegisterBits bias_bit =
Adafruit_BusIO_RegisterBits(&config_reg, 1, 7);
Adafruit_BusIO_RegisterBits auto_bit =
Adafruit_BusIO_RegisterBits(&config_reg, 1, 6);
Adafruit_BusIO_RegisterBits oneS_bit =
Adafruit_BusIO_RegisterBits(&config_reg, 1, 5);
Adafruit_BusIO_RegisterBits wire_bit =
Adafruit_BusIO_RegisterBits(&config_reg, 1, 4);
Adafruit_BusIO_RegisterBits faultT_bits =
Adafruit_BusIO_RegisterBits(&config_reg, 2, 2);
Adafruit_BusIO_RegisterBits faultR_bit =
Adafruit_BusIO_RegisterBits(&config_reg, 1, 1);
Adafruit_BusIO_RegisterBits fi50hz_bit =
Adafruit_BusIO_RegisterBits(&config_reg, 1, 0);
Adafruit_BusIO_Register rRatio_reg =
Adafruit_BusIO_Register(&spi_dev, 0x01, ADDRBIT8_HIGH_TOWRITE, 2, MSBFIRST);
Adafruit_BusIO_RegisterBits rRatio_bits =
Adafruit_BusIO_RegisterBits(&rRatio_reg, 15, 1);
Adafruit_BusIO_RegisterBits fault_bit =
Adafruit_BusIO_RegisterBits(&rRatio_reg, 1, 0);
Adafruit_BusIO_Register maxRratio_reg =
Adafruit_BusIO_Register(&spi_dev, 0x03, ADDRBIT8_HIGH_TOWRITE, 2, MSBFIRST);
Adafruit_BusIO_RegisterBits maxRratio_bits =
Adafruit_BusIO_RegisterBits(&maxRratio_reg, 15, 1);
Adafruit_BusIO_Register minRratio_reg =
Adafruit_BusIO_Register(&spi_dev, 0x05, ADDRBIT8_HIGH_TOWRITE, 2, MSBFIRST);
Adafruit_BusIO_RegisterBits minRratio_bits =
Adafruit_BusIO_RegisterBits(&minRratio_reg, 15, 1);
Adafruit_BusIO_Register fault_reg =
Adafruit_BusIO_Register(&spi_dev, 0x07, ADDRBIT8_HIGH_TOWRITE, 1, MSBFIRST);
Adafruit_BusIO_RegisterBits range_high_fault_bit =
Adafruit_BusIO_RegisterBits(&fault_reg, 1, 7);
Adafruit_BusIO_RegisterBits range_low_fault_bit =
Adafruit_BusIO_RegisterBits(&fault_reg, 1, 6);
Adafruit_BusIO_RegisterBits refin_high_fault_bit =
Adafruit_BusIO_RegisterBits(&fault_reg, 1, 5);
Adafruit_BusIO_RegisterBits refin_low_fault_bit =
Adafruit_BusIO_RegisterBits(&fault_reg, 1, 4);
Adafruit_BusIO_RegisterBits rtdin_low_fault_bit =
Adafruit_BusIO_RegisterBits(&fault_reg, 1, 3);
Adafruit_BusIO_RegisterBits voltage_fault_bit =
Adafruit_BusIO_RegisterBits(&fault_reg, 1, 2);
// Print the details of the configuration register.
void printConfig(void) {
Serial.print("BIAS: ");
if (bias_bit.read())
Serial.print("ON");
else
Serial.print("OFF");
Serial.print(", AUTO: ");
if (auto_bit.read())
Serial.print("ON");
else
Serial.print("OFF");
Serial.print(", ONES: ");
if (oneS_bit.read())
Serial.print("ON");
else
Serial.print("OFF");
Serial.print(", WIRE: ");
if (wire_bit.read())
Serial.print("3");
else
Serial.print("2/4");
Serial.print(", FAULTCLEAR: ");
if (faultR_bit.read())
Serial.print("ON");
else
Serial.print("OFF");
Serial.print(", ");
if (fi50hz_bit.read())
Serial.print("50HZ");
else
Serial.print("60HZ");
Serial.println();
}
// Check and print faults. Then clear them.
void checkFaults(void) {
if (fault_bit.read()) {
Serial.print("MAX: ");
Serial.println(maxRratio_bits.read());
Serial.print("VAL: ");
Serial.println(rRatio_bits.read());
Serial.print("MIN: ");
Serial.println(minRratio_bits.read());
if (range_high_fault_bit.read())
Serial.println("Range high fault");
if (range_low_fault_bit.read())
Serial.println("Range low fault");
if (refin_high_fault_bit.read())
Serial.println("REFIN high fault");
if (refin_low_fault_bit.read())
Serial.println("REFIN low fault");
if (rtdin_low_fault_bit.read())
Serial.println("RTDIN low fault");
if (voltage_fault_bit.read())
Serial.println("Voltage fault");
faultR_bit.write(1); // clear fault
}
}
void setup() {
#if (MAX31865_1_READY_PIN != -1)
pinMode(MAX31865_READY_PIN, INPUT_PULLUP);
#endif
while (!Serial) {
delay(10);
}
Serial.begin(115200);
Serial.println("SPI Adafruit_BusIO_RegisterBits test on MAX31865");
if (!spi_dev.begin()) {
Serial.println("Could not initialize SPI device");
while (1)
;
}
// Set up for automode 50Hz. We don't care about selfheating. We want the
// highest possible sampling rate.
auto_bit.write(0); // Don't switch filtermode while auto_mode is on.
fi50hz_bit.write(1); // Set filter to 50Hz mode.
faultR_bit.write(1); // Clear faults.
bias_bit.write(1); // In automode we want to have the bias current always on.
delay(5); // Wait until bias current settles down.
// 10.5 time constants of the input RC network is required.
// 10ms worst case for 10kω reference resistor and a 0.1µF capacitor
// across the RTD inputs. Adafruit Module has 0.1µF and only
// 430/4300ω So here 0.43/4.3ms
auto_bit.write(
1); // Now we can set automode. Automatically starting first conversion.
// Test the READY_PIN
#if (defined(MAX31865_READY_PIN) && (MAX31865_READY_PIN != -1))
int i = 0;
while (digitalRead(MAX31865_READY_PIN) && i++ <= 100) {
delay(1);
}
if (i >= 100) {
Serial.print("ERROR: Max31865 Pin detection does not work. PIN:");
Serial.println(MAX31865_READY_PIN);
}
#else
delay(100);
#endif
// Set ratio range.
// Setting the temperatures would need some more calculation - not related to
// Adafruit_BusIO_RegisterBits.
uint16_t ratio = rRatio_bits.read();
maxRratio_bits.write((ratio < 0x8fffu - 1000u) ? ratio + 1000u : 0x8fffu);
minRratio_bits.write((ratio > 1000u) ? ratio - 1000u : 0u);
printConfig();
checkFaults();
}
void loop() {
#if (defined(MAX31865_READY_PIN) && (MAX31865_1_READY_PIN != -1))
// Is conversion ready?
if (!digitalRead(MAX31865_READY_PIN))
#else
// Warant conversion is ready.
delay(21); // 21ms for 50Hz-mode. 19ms in 60Hz-mode.
#endif
{
// Read ratio, calculate temperature, scale, filter and print.
Serial.println(rRatio2C(rRatio_bits.read()) * 100.0f,
0); // Temperature scaled by 100
// Check, print, clear faults.
checkFaults();
}
// Do something else.
// delay(15000);
}
// Module/Sensor related. Here Adafruit PT100 module with a 2_Wire PT100 Class C
// *****************************
float rRatio2C(uint16_t ratio) {
// A simple linear conversion.
const float R0 = 100.0f;
const float Rref = 430.0f;
const float alphaPT = 0.003850f;
const float ADCmax = (1u << 15) - 1.0f;
const float rscale = Rref / ADCmax;
// Measured temperature in boiling water 101.08°C with factor a = 1 and b = 0.
// Rref and MAX at about 22±2°C. Measured temperature in ice/water bath 0.76°C
// with factor a = 1 and b = 0. Rref and MAX at about 22±2°C.
// const float a = 1.0f / (alphaPT * R0);
const float a = (100.0f / 101.08f) / (alphaPT * R0);
// const float b = 0.0f; // 101.08
const float b = -0.76f; // 100.32 > 101.08
return filterRing(((ratio * rscale) - R0) * a + b);
}
// General purpose
// *********************************************************************************************
#define RINGLENGTH 250
float filterRing(float newVal) {
static float ring[RINGLENGTH] = {0.0};
static uint8_t ringIndex = 0;
static bool ringFull = false;
if (ringIndex == RINGLENGTH) {
ringFull = true;
ringIndex = 0;
}
ring[ringIndex] = newVal;
uint8_t loopEnd = (ringFull) ? RINGLENGTH : ringIndex + 1;
float ringSum = 0.0f;
for (uint8_t i = 0; i < loopEnd; i++)
ringSum += ring[i];
ringIndex++;
return ringSum / loopEnd;
}
libraries/Adafruit_BusIO/examples/spi_registers/spi_registers.ino
+40
View File
@@ -0,0 +1,40 @@
#include <Adafruit_BusIO_Register.h>
#include <Adafruit_SPIDevice.h>
#define SPIDEVICE_CS 10
Adafruit_SPIDevice spi_dev = Adafruit_SPIDevice(SPIDEVICE_CS);
void setup() {
while (!Serial) {
delay(10);
}
Serial.begin(115200);
Serial.println("SPI device register test");
if (!spi_dev.begin()) {
Serial.println("Could not initialize SPI device");
while (1)
;
}
Adafruit_BusIO_Register id_reg =
Adafruit_BusIO_Register(&spi_dev, 0x0F, ADDRBIT8_HIGH_TOREAD);
uint8_t id = 0;
id_reg.read(&id);
Serial.print("ID register = 0x");
Serial.println(id, HEX);
Adafruit_BusIO_Register thresh_reg = Adafruit_BusIO_Register(
&spi_dev, 0x0C, ADDRBIT8_HIGH_TOREAD, 2, LSBFIRST);
uint16_t thresh = 0;
thresh_reg.read(&thresh);
Serial.print("Initial threshold register = 0x");
Serial.println(thresh, HEX);
thresh_reg.write(~thresh);
Serial.print("Post threshold register = 0x");
Serial.println(thresh_reg.read(), HEX);
}
void loop() {}
libraries/Adafruit_BusIO/library.properties
+9
View File
@@ -0,0 +1,9 @@
name=Adafruit BusIO
version=1.17.4
author=Adafruit
maintainer=Adafruit <info@adafruit.com>
sentence=This is a library for abstracting away UART, I2C and SPI interfacing
paragraph=This is a library for abstracting away UART, I2C and SPI interfacing
category=Signal Input/Output
url=https://github.com/adafruit/Adafruit_BusIO
architectures=*
libraries/Adafruit_CircuitPlayground/Adafruit_CircuitPlayground.cpp
+196
View File
@@ -0,0 +1,196 @@
#include <Adafruit_CircuitPlayground.h>
boolean Adafruit_CircuitPlayground::begin(uint8_t brightness) {
pinMode(CPLAY_REDLED, OUTPUT);
pinMode(CPLAY_SLIDESWITCHPIN, INPUT);
pinMode(CPLAY_LEFTBUTTON, INPUT);
pinMode(CPLAY_RIGHTBUTTON, INPUT);
pinMode(CPLAY_BUZZER, OUTPUT);
pinMode(CPLAY_CAPSENSE_SHARED, OUTPUT);
strip = Adafruit_CPlay_NeoPixel();
strip.updateType(NEO_GRB + NEO_KHZ800);
strip.updateLength(10);
strip.setPin(CPLAY_NEOPIXELPIN);
lis = Adafruit_CPlay_LIS3DH(CPLAY_LIS3DH_CS);
mic = Adafruit_CPlay_Mic();
strip.begin();
strip.show(); // Initialize all pixels to 'off'
strip.setBrightness(brightness);
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);
if (! lis.begin(0x18)) { // change this to 0x19 for alternative i2c address
return false;
}
return true;
}
uint16_t Adafruit_CircuitPlayground::readCap(uint8_t p, uint8_t samples) {
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;
}
}
// just turn on/off the red #13 LED
void Adafruit_CircuitPlayground::redLED(boolean v) {
digitalWrite(CPLAY_REDLED, v);
}
// just read the slide switch
boolean Adafruit_CircuitPlayground::slideSwitch(void) {
return digitalRead(CPLAY_SLIDESWITCHPIN);
}
// just read the left button
boolean Adafruit_CircuitPlayground::leftButton(void) {
return digitalRead(CPLAY_LEFTBUTTON);
}
// just read the right button
boolean Adafruit_CircuitPlayground::rightButton(void) {
return digitalRead(CPLAY_RIGHTBUTTON);
}
void Adafruit_CircuitPlayground::playTone(uint16_t freq, uint16_t time, boolean wait) {
tone(CPLAY_BUZZER, freq, time);
if (wait) delay(time);
}
uint16_t Adafruit_CircuitPlayground::lightSensor(void) {
return analogRead(CPLAY_LIGHTSENSOR);
}
uint16_t Adafruit_CircuitPlayground::soundSensor(void) {
return analogRead(CPLAY_SOUNDSENSOR);
}
float Adafruit_CircuitPlayground::motionX(void) {
sensors_event_t event;
CircuitPlayground.lis.getEvent(&event);
return event.acceleration.x;
}
float Adafruit_CircuitPlayground::motionY(void) {
sensors_event_t event;
CircuitPlayground.lis.getEvent(&event);
return event.acceleration.y;
}
float Adafruit_CircuitPlayground::motionZ(void) {
sensors_event_t event;
CircuitPlayground.lis.getEvent(&event);
return event.acceleration.z;
}
float Adafruit_CircuitPlayground::temperature(void) {
// Thermistor test
float 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);
float 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;
}
// Get the temperature in degrees Fahrenheit
float Adafruit_CircuitPlayground::temperatureF(void) {
float tempF = CircuitPlayground.temperature() * 1.8 + 32;
return tempF;
}
// Input a value 0 to 255 to get 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);
}
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);
}
// instantiate static
Adafruit_CircuitPlayground CircuitPlayground;
libraries/Adafruit_CircuitPlayground/Adafruit_CircuitPlayground.h
+127
View File
@@ -0,0 +1,127 @@
/*------------------------------------------------------------------------
This file is part of the Adafruit Dot Star library.
Adafruit Dot Star 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 Dot Star 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 DotStar. If not, see <http://www.gnu.org/licenses/>.
------------------------------------------------------------------------*/
#include "utility/Adafruit_CPlay_NeoPixel.h"
#include "utility/Adafruit_CPlay_LIS3DH.h"
#include "utility/Adafruit_CPlay_Mic.h"
#include "utility/Adafruit_CPlay_Speaker.h"
#include "utility/CPlay_CapacitiveSensor.h"
#include "utility/CP_Firmata.h"
#ifndef _ADAFRUIT_CIRCUITPLAYGROUND_H_
#define _ADAFRUIT_CIRCUITPLAYGROUND_H_
#ifndef NOT_AN_INTERRUPT // Not defined in Arduino 1.0.5
#define NOT_AN_INTERRUPT -1
#endif
#define CPLAY_REDLED 13
#define CPLAY_NEOPIXELPIN 17
#define CPLAY_SLIDESWITCHPIN 21
#define CPLAY_LEFTBUTTON 4
#define CPLAY_RIGHTBUTTON 19
#define CPLAY_LIGHTSENSOR A5
#define CPLAY_LIS3DH_CS 8
#define CPLAY_THERMISTORPIN A0
#define CPLAY_SOUNDSENSOR A4
#define CPLAY_BUZZER 5
#define CPLAY_CAPSENSE_SHARED 30
#define SERIESRESISTOR 10000
// resistance at 25 degrees C
#define THERMISTORNOMINAL 10000
// temp. for nominal resistance (almost always 25 C)
#define TEMPERATURENOMINAL 25
// The beta coefficient of the thermistor (usually 3000-4000)
#define BCOEFFICIENT 3380
// the value of the 'other' resistor
// Configuration to tune the color sensing logic:
#define LIGHT_SETTLE_MS 100 // Amount of time (in milliseconds) to wait between
// changing the pixel color and reading the light
// sensor.
#if (ARDUINO >= 100)
#include <Arduino.h>
#else
#include <WProgram.h>
#include <pins_arduino.h>
#endif
class Adafruit_CircuitPlayground {
public:
boolean begin(uint8_t brightness=20);
Adafruit_CPlay_NeoPixel strip;
Adafruit_CPlay_LIS3DH lis;
Adafruit_CPlay_Mic mic;
Adafruit_CPlay_Speaker speaker;
CPlay_CapacitiveSensor cap[8];
boolean slideSwitch(void);
void redLED(boolean v);
void playTone(uint16_t freq, uint16_t time, boolean wait=true);
boolean leftButton(void);
boolean rightButton(void);
uint16_t lightSensor(void);
uint16_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);
void setAccelRange(lis3dh_range_t range) { lis.setRange(range); }
void setAccelTap(uint8_t c, uint8_t clickthresh)
{ lis.setClick(c, clickthresh, 10, 20, 255); }
uint8_t getAccelTap(void) { return (lis.getClick() >> 8) & 0x3; }
// neopixels
void clearPixels(void) { strip.clear(); strip.show(); }
void setPixelColor(uint8_t p, uint32_t c) {strip.setPixelColor(p, c); strip.show();}
void setPixelColor(uint8_t p, uint8_t r, uint8_t g, uint8_t b) {strip.setPixelColor(p, r, g, b); strip.show();}
void setBrightness(uint16_t b){strip.setBrightness(b);}
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);
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;
}
private:
};
extern Adafruit_CircuitPlayground CircuitPlayground;
#endif
libraries/Adafruit_CircuitPlayground/examples/CircuitPlaygroundFirmata/CircuitPlaygroundFirmata.ino
+1174
View File
File diff suppressed because it is too large Load Diff
libraries/Adafruit_CircuitPlayground/examples/Hello_CircuitPlayground/Hello_Accelerometer/Hello_Accelerometer.ino
+23
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);
}
libraries/Adafruit_CircuitPlayground/examples/Hello_CircuitPlayground/Hello_Blink/Hello_Blink.ino
+12
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);
}
libraries/Adafruit_CircuitPlayground/examples/Hello_CircuitPlayground/Hello_Buttons/Hello_Buttons.ino
+30
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);
}
libraries/Adafruit_CircuitPlayground/examples/Hello_CircuitPlayground/Hello_LightSensor/Hello_LightSensor.ino
+17
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);
}
libraries/Adafruit_CircuitPlayground/examples/Hello_CircuitPlayground/Hello_NeoPixels/Hello_NeoPixels.ino
+25
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);
}
libraries/Adafruit_CircuitPlayground/examples/Hello_CircuitPlayground/Hello_SlideSwitch/Hello_SlideSwitch.ino
+22
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);
}
libraries/Adafruit_CircuitPlayground/examples/Hello_CircuitPlayground/Hello_SoundSensor/Hello_SoundSensor.ino
+17
View File
@@ -0,0 +1,17 @@
#include <Adafruit_CircuitPlayground.h>
int value;
void setup() {
Serial.begin(9600);
CircuitPlayground.begin();
}
void loop() {
value = CircuitPlayground.soundSensor();
Serial.print("Sound Sensor: ");
Serial.println(value);
delay(1000);
}
libraries/Adafruit_CircuitPlayground/examples/Hello_CircuitPlayground/Hello_Speaker/Hello_Speaker.ino
+10
View File
@@ -0,0 +1,10 @@
#include <Adafruit_CircuitPlayground.h>
void setup() {
CircuitPlayground.begin();
}
void loop() {
CircuitPlayground.playTone(500, 100);
delay(1000);
}
libraries/Adafruit_CircuitPlayground/examples/Hello_CircuitPlayground/Hello_Temperature/Hello_Temperature.ino
+20
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);
}
libraries/Adafruit_CircuitPlayground/examples/Hello_CircuitPlayground/README.md
+84
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.
libraries/Adafruit_CircuitPlayground/examples/Microphone/mic_fft/mic_fft.ino
+205
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;
}
libraries/Adafruit_CircuitPlayground/examples/Microphone/mic_meter/mic_meter.ino
+153
View File
@@ -0,0 +1,153 @@
// Audio level visualizer for Adafruit Circuit Playground: uses the
// built-in mic on A4, 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(255);
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;
a = CircuitPlayground.mic.peak(10); // 10 ms of audio
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;
}
libraries/Adafruit_CircuitPlayground/examples/ScatchSensorBoard/ScratchSensorBoard.ino
+68
View File
@@ -0,0 +1,68 @@
// 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>
#include <Wire.h>
#include <SPI.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.soundSensor();
s -= 340;
s = abs(s * 1.5);
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);
}
libraries/Adafruit_CircuitPlayground/examples/Speech/Talk_UK_Acorn/Talk_UK_Acorn.ino
+209
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() {
}
libraries/Adafruit_CircuitPlayground/examples/Speech/Talk_US_Clock/Talk_US_Clock.ino
+73
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() {
}
libraries/Adafruit_CircuitPlayground/examples/Speech/Talk_US_Large/Talk_US_Large.ino
+444
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() {
}
libraries/Adafruit_CircuitPlayground/examples/Speech/Talk_US_Male/Talk_US_Male.ino
+243
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() {
}
libraries/Adafruit_CircuitPlayground/examples/Speech/Talk_US_TI99/Talk_US_TI99.ino
+400
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() {
}
libraries/Adafruit_CircuitPlayground/examples/accelTap/accelTap.ino
+48
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(7), 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;
*/
}
libraries/Adafruit_CircuitPlayground/examples/accel_mouse/accel_mouse.ino
+137
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);
}
}
libraries/Adafruit_CircuitPlayground/examples/analog_sensors/analog_sensors.ino
+83
View File
@@ -0,0 +1,83 @@
// 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.
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);
// 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);
}
libraries/Adafruit_CircuitPlayground/examples/color_sense/color_sense.ino
+60
View File
@@ -0,0 +1,60 @@
// 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();
}
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);
// 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();
}
}
libraries/Adafruit_CircuitPlayground/examples/comm_badge/coin.h
+1095
View File
File diff suppressed because it is too large Load Diff
libraries/Adafruit_CircuitPlayground/examples/comm_badge/comm_badge.ino
+47
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(7), 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
}
libraries/Adafruit_CircuitPlayground/examples/comm_badge/trek.h
+580
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 };
libraries/Adafruit_CircuitPlayground/examples/demo/demo.ino
+78
View File
@@ -0,0 +1,78 @@
// Demo program for testing library and board - flip the switch to turn on/off buzzer
#include <Adafruit_CircuitPlayground.h>
#include <Wire.h>
#include <SPI.h>
// we light one pixel at a time, this is our counter
uint8_t pixeln = 0;
void setup() {
//while (!Serial);
Serial.begin(9600);
Serial.println("Circuit Playground test!");
CircuitPlayground.begin();
}
void loop() {
// test Red #13 LED
CircuitPlayground.redLED(HIGH);
delay(100);
CircuitPlayground.redLED(LOW);
delay(100);
/************* 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));
/************* TEST SLIDE SWITCH */
if (CircuitPlayground.slideSwitch()) {
Serial.println("Slide to the left");
} else {
Serial.println("Slide to the right");
CircuitPlayground.playTone(500 + pixeln * 500, 250);
}
/************* TEST 10 NEOPIXELS */
CircuitPlayground.setPixelColor(pixeln++, CircuitPlayground.colorWheel(25 * pixeln));
if (pixeln == 11) {
pixeln = 0;
CircuitPlayground.clearPixels();
}
/************* TEST BOTH BUTTONS */
if (CircuitPlayground.leftButton()) {
Serial.println("Left button pressed!");
}
if (CircuitPlayground.rightButton()) {
Serial.println("Right button pressed!");
}
/************* TEST LIGHT SENSOR */
Serial.print("Light sensor: ");
Serial.println(CircuitPlayground.lightSensor());
/************* TEST SOUND SENSOR */
Serial.print("Sound sensor: ");
Serial.println(CircuitPlayground.soundSensor());
/************* 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");
/************* TEST THERMISTOR */
Serial.print("Temperature ");
Serial.print(CircuitPlayground.temperature());
Serial.println(" *C");
}
libraries/Adafruit_CircuitPlayground/examples/mega_demo/CapTouchDemo.h
+85
View File
@@ -0,0 +1,85 @@
#ifndef CAPTOUCHDEMO_H
#define CAPTOUCHDEMO_H
#include "Demo.h"
#define CAP_THRESHOLD 300 // Threshold for a capacitive touch (higher = less sensitive).
#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:
CapTouchDemo() { playSound = false; }
~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
libraries/Adafruit_CircuitPlayground/examples/mega_demo/Demo.h
+27
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
libraries/Adafruit_CircuitPlayground/examples/mega_demo/RainbowCycleDemo.h
+40
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
libraries/Adafruit_CircuitPlayground/examples/mega_demo/SensorDemo.h
+65
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
libraries/Adafruit_CircuitPlayground/examples/mega_demo/TiltDemo.h
+66
View File
@@ -0,0 +1,66 @@
#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);
// 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
libraries/Adafruit_CircuitPlayground/examples/mega_demo/VUMeterDemo.h
+182
View File
@@ -0,0 +1,182 @@
// 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 MIC_PIN A4 // Microphone is attached to this analog pin (A4 for circuit playground)
#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 10 // Lower range of analogRead input
//#define INPUT_CEILING 500 // Max range of analogRead input, the lower the value the more sensitive (1023 = max)
static int inputCeilings[] = { 500, 1023, 250 };
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
//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);
}
}
static float fscale( float originalMin, float originalMax, float newBegin, float
newEnd, float inputValue, float curve){
float OriginalRange = 0;
float NewRange = 0;
float zeroRefCurVal = 0;
float normalizedCurVal = 0;
float rangedValue = 0;
boolean invFlag = 0;
// condition curve parameter
// limit range
if (curve > 10) curve = 10;
if (curve < -10) curve = -10;
curve = (curve * -.1) ; // - invert and scale - this seems more intuitive - postive numbers give more weight to high end on output
curve = pow(10, curve); // convert linear scale into lograthimic exponent for other pow function
/*
Serial.println(curve * 100, DEC); // multply by 100 to preserve resolution
Serial.println();
*/
// Check for out of range inputValues
if (inputValue < originalMin) {
inputValue = originalMin;
}
if (inputValue > originalMax) {
inputValue = originalMax;
}
// Zero Refference the values
OriginalRange = originalMax - originalMin;
if (newEnd > newBegin){
NewRange = newEnd - newBegin;
}
else
{
NewRange = newBegin - newEnd;
invFlag = 1;
}
zeroRefCurVal = inputValue - originalMin;
normalizedCurVal = zeroRefCurVal / OriginalRange; // normalize to 0 - 1 float
// Check for originalMin > originalMax - the math for all other cases i.e. negative numbers seems to work out fine
if (originalMin > originalMax ) {
return 0;
}
if (invFlag == 0){
rangedValue = (pow(normalizedCurVal, curve) * NewRange) + newBegin;
}
else // invert the ranges
{
rangedValue = newBegin - (pow(normalizedCurVal, curve) * NewRange);
}
return rangedValue;
}
class VUMeterDemo: public Demo {
public:
VUMeterDemo() { currentCeiling = 0; }
~VUMeterDemo() {}
virtual void loop() {
int numPixels = CircuitPlayground.strip.numPixels();
unsigned long startMillis= millis(); // Start of sample window
float peakToPeak = 0; // peak-to-peak level
unsigned int signalMax = 0;
unsigned int signalMin = 1023;
unsigned int c, y;
// collect data for length of sample window (in mS)
while (millis() - startMillis < SAMPLE_WINDOW)
{
sample = analogRead(MIC_PIN);
if (sample < 1024) // toss out spurious readings
{
if (sample > signalMax)
{
signalMax = sample; // save just the max levels
}
else if (sample < signalMin)
{
signalMin = sample; // save just the min levels
}
}
}
peakToPeak = signalMax - signalMin; // max - min = peak-peak amplitude
// 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)));
}
//Scale the input logarithmically instead of linearly
c = fscale(INPUT_FLOOR, inputCeilings[currentCeiling], numPixels, 0, peakToPeak, 2);
// 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() {
// Ratchet through different input ceiling values.
currentCeiling += 1;
if (currentCeiling >= (sizeof(inputCeilings)/sizeof(int))) {
currentCeiling = 0;
}
}
private:
int currentCeiling;
};
#endif
libraries/Adafruit_CircuitPlayground/examples/mega_demo/mega_demo.ino
+120
View File
@@ -0,0 +1,120 @@
// 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
//
// 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();
}
}
libraries/Adafruit_CircuitPlayground/examples/vu_meter/vu_meter.ino
+206
View File
@@ -0,0 +1,206 @@
/*
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.
fscale function:
Floating Point Autoscale Function V0.1
Written by Paul Badger 2007
Modified from code by Greg Shakar
*/
#include <Adafruit_CircuitPlayground.h>
#include <Wire.h>
#include <SPI.h>
#include <math.h>
#define MIC_PIN A4 // Microphone is attached to this analog pin (A4 for circuit playground)
#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 10 // Lower range of analogRead input
#define INPUT_CEILING 500 // Max range of analogRead input, the lower the value the more sensitive (1023 = max)
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 fscale(float originalMin, float originalMax, float newBegin, float newEnd, float inputValue, float curve);
void setup()
{
CircuitPlayground.begin();
}
void loop()
{
int numPixels = CircuitPlayground.strip.numPixels();
unsigned long startMillis= millis(); // Start of sample window
float peakToPeak = 0; // peak-to-peak level
unsigned int signalMax = 0;
unsigned int signalMin = 1023;
unsigned int c, y;
// collect data for length of sample window (in mS)
while (millis() - startMillis < SAMPLE_WINDOW)
{
sample = analogRead(MIC_PIN);
if (sample < 1024) // toss out spurious readings
{
if (sample > signalMax)
{
signalMax = sample; // save just the max levels
}
else if (sample < signalMin)
{
signalMin = sample; // save just the min levels
}
}
}
peakToPeak = signalMax - signalMin; // max - min = peak-peak amplitude
// 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)));
}
//Scale the input logarithmically instead of linearly
c = fscale(INPUT_FLOOR, INPUT_CEILING, numPixels, 0, peakToPeak, 2);
// 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 fscale( float originalMin, float originalMax, float newBegin, float
newEnd, float inputValue, float curve){
float OriginalRange = 0;
float NewRange = 0;
float zeroRefCurVal = 0;
float normalizedCurVal = 0;
float rangedValue = 0;
boolean invFlag = 0;
// condition curve parameter
// limit range
if (curve > 10) curve = 10;
if (curve < -10) curve = -10;
curve = (curve * -.1) ; // - invert and scale - this seems more intuitive - postive numbers give more weight to high end on output
curve = pow(10, curve); // convert linear scale into lograthimic exponent for other pow function
/*
Serial.println(curve * 100, DEC); // multply by 100 to preserve resolution
Serial.println();
*/
// Check for out of range inputValues
if (inputValue < originalMin) {
inputValue = originalMin;
}
if (inputValue > originalMax) {
inputValue = originalMax;
}
// Zero Refference the values
OriginalRange = originalMax - originalMin;
if (newEnd > newBegin){
NewRange = newEnd - newBegin;
}
else
{
NewRange = newBegin - newEnd;
invFlag = 1;
}
zeroRefCurVal = inputValue - originalMin;
normalizedCurVal = zeroRefCurVal / OriginalRange; // normalize to 0 - 1 float
// Check for originalMin > originalMax - the math for all other cases i.e. negative numbers seems to work out fine
if (originalMin > originalMax ) {
return 0;
}
if (invFlag == 0){
rangedValue = (pow(normalizedCurVal, curve) * NewRange) + newBegin;
}
else // invert the ranges
{
rangedValue = newBegin - (pow(normalizedCurVal, curve) * NewRange);
}
return rangedValue;
}
// 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);
}
}
libraries/Adafruit_CircuitPlayground/library.properties
+9
View File
@@ -0,0 +1,9 @@
name=Adafruit Circuit Playground
version=1.6.4
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. Requires no other dependencies and exposes all Circuit Playground components in a simple to use class.
category=Other
url=https://github.com/adafruit/Adafruit_CircuitPlayground
architectures=*
libraries/Adafruit_CircuitPlayground/utility/Adafruit_CPlay_LIS3DH.cpp
+435
View File
@@ -0,0 +1,435 @@
/**************************************************************************/
/*!
@file Adafruit_LIS3DH.cpp
@author K. Townsend / Limor Fried (Adafruit Industries)
@license BSD (see license.txt)
This is a library for the Adafruit LIS3DH Accel breakout board
----> https://www.adafruit.com/products/2809
Adafruit invests time and resources providing this open source code,
please support Adafruit and open-source hardware by purchasing
products from Adafruit!
@section HISTORY
v1.0 - First release
*/
/**************************************************************************/
#if ARDUINO >= 100
#include "Arduino.h"
#else
#include "WProgram.h"
#endif
#include <Wire.h>
#include <Adafruit_CPlay_LIS3DH.h>
/**************************************************************************/
/*!
@brief Instantiates a new LIS3DH class in I2C or SPI mode
*/
/**************************************************************************/
// I2C
Adafruit_CPlay_LIS3DH::Adafruit_CPlay_LIS3DH()
: _cs(-1), _mosi(-1), _miso(-1), _sck(-1), _sensorID(-1)
{
}
Adafruit_CPlay_LIS3DH::Adafruit_CPlay_LIS3DH(int8_t cspin)
: _cs(cspin), _mosi(-1), _miso(-1), _sck(-1), _sensorID(-1)
{ }
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.)
*/
/**************************************************************************/
bool Adafruit_CPlay_LIS3DH::begin(uint8_t i2caddr) {
_i2caddr = i2caddr;
if (_cs == -1) {
// i2c
Wire.begin();
} else {
digitalWrite(_cs, HIGH);
pinMode(_cs, OUTPUT);
#ifndef __AVR_ATtiny85__
if (_sck == -1) {
// hardware SPI
SPI.begin();
} else {
// software SPI
pinMode(_sck, OUTPUT);
pinMode(_mosi, OUTPUT);
pinMode(_miso, INPUT);
}
#endif
}
/*
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 != 0x33)
{
/* 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;
}
void Adafruit_CPlay_LIS3DH::read(void) {
// read x y z at once
if (_cs == -1) {
// i2c
Wire.beginTransmission(_i2caddr);
Wire.write(LIS3DH_REG_OUT_X_L | 0x80); // 0x80 for autoincrement
Wire.endTransmission();
Wire.requestFrom(_i2caddr, 6);
x = Wire.read(); x |= ((uint16_t)Wire.read()) << 8;
y = Wire.read(); y |= ((uint16_t)Wire.read()) << 8;
z = Wire.read(); z |= ((uint16_t)Wire.read()) << 8;
}
#ifndef __AVR_ATtiny85__
else {
#if SPI_HAS_TRANSACTION
if (_sck == -1)
SPI.beginTransaction(SPISettings(500000, MSBFIRST, SPI_MODE0));
#endif
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 SPI_HAS_TRANSACTION
if (_sck == -1)
SPI.endTransaction(); // release the SPI bus
#endif
}
#endif
uint8_t range = getRange();
uint16_t divider = 1;
if (range == LIS3DH_RANGE_16_G) divider = 1365;
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
*/
/**************************************************************************/
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
Wire.beginTransmission(_i2caddr);
Wire.write(reg | 0x80); // 0x80 for autoincrement
Wire.endTransmission();
Wire.requestFrom(_i2caddr, 2);
value = Wire.read(); value |= ((uint16_t)Wire.read()) << 8;
}
#ifndef __AVR_ATtiny85__
else {
#if SPI_HAS_TRANSACTION
if (_sck == -1)
SPI.beginTransaction(SPISettings(500000, MSBFIRST, SPI_MODE0));
#endif
digitalWrite(_cs, LOW);
spixfer(reg | 0x80 | 0x40); // read multiple, bit 7&6 high
value = spixfer(); value |= ((uint16_t)spixfer()) << 8;
digitalWrite(_cs, HIGH);
#if SPI_HAS_TRANSACTION
if (_sck == -1)
SPI.endTransaction(); // release the SPI bus
#endif
}
#endif
return value;
}
/**************************************************************************/
/*!
@brief Set INT to output for single or double click
*/
/**************************************************************************/
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
}
uint8_t Adafruit_CPlay_LIS3DH::getClick(void) {
return readRegister8(LIS3DH_REG_CLICKSRC);
}
/**************************************************************************/
/*!
@brief Sets the g range for the accelerometer
*/
/**************************************************************************/
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 Sets the g range for the accelerometer
*/
/**************************************************************************/
lis3dh_range_t Adafruit_CPlay_LIS3DH::getRange(void)
{
/* 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)
*/
/**************************************************************************/
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 Sets the data rate for the LIS3DH (controls power consumption)
*/
/**************************************************************************/
lis3dh_dataRate_t Adafruit_CPlay_LIS3DH::getDataRate(void)
{
return (lis3dh_dataRate_t)((readRegister8(LIS3DH_REG_CTRL1) >> 4)& 0x0F);
}
/**************************************************************************/
/*!
@brief Gets the most recent sensor event
*/
/**************************************************************************/
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;
}
/**************************************************************************/
/*!
@brief Gets the sensor_t data
*/
/**************************************************************************/
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
*/
/**************************************************************************/
uint8_t Adafruit_CPlay_LIS3DH::spixfer(uint8_t x) {
#ifndef __AVR_ATtiny85__
if (_sck == -1)
return SPI.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
*/
/**************************************************************************/
void Adafruit_CPlay_LIS3DH::writeRegister8(uint8_t reg, uint8_t value) {
if (_cs == -1) {
Wire.beginTransmission((uint8_t)_i2caddr);
Wire.write((uint8_t)reg);
Wire.write((uint8_t)value);
Wire.endTransmission();
}
#ifndef __AVR_ATtiny85__
else {
#if SPI_HAS_TRANSACTION
if (_sck == -1)
SPI.beginTransaction(SPISettings(500000, MSBFIRST, SPI_MODE0));
#endif
digitalWrite(_cs, LOW);
spixfer(reg & ~0x80); // write, bit 7 low
spixfer(value);
digitalWrite(_cs, HIGH);
#if SPI_HAS_TRANSACTION
if (_sck == -1)
SPI.endTransaction(); // release the SPI bus
#endif
}
#endif
}
/**************************************************************************/
/*!
@brief Reads 8-bits from the specified register
*/
/**************************************************************************/
uint8_t Adafruit_CPlay_LIS3DH::readRegister8(uint8_t reg) {
uint8_t value;
if (_cs == -1) {
Wire.beginTransmission(_i2caddr);
Wire.write((uint8_t)reg);
Wire.endTransmission();
Wire.requestFrom(_i2caddr, 1);
value = Wire.read();
}
#ifndef __AVR_ATtiny85__
else {
#if SPI_HAS_TRANSACTION
if (_sck == -1)
SPI.beginTransaction(SPISettings(500000, MSBFIRST, SPI_MODE0));
#endif
digitalWrite(_cs, LOW);
spixfer(reg | 0x80); // read, bit 7 high
value = spixfer(0);
digitalWrite(_cs, HIGH);
#if SPI_HAS_TRANSACTION
if (_sck == -1)
SPI.endTransaction(); // release the SPI bus
#endif
}
#endif
return value;
}
libraries/Adafruit_CircuitPlayground/utility/Adafruit_CPlay_LIS3DH.h
+152
View File
@@ -0,0 +1,152 @@
/**************************************************************************/
/*!
@file Adafruit_LIS3DH.h
@author K. Townsend / Limor Fried (Adafruit Industries)
@license BSD (see license.txt)
This is a library for the Adafruit LIS3DH Accel breakout board
----> https://www.adafruit.com/products/2809
Adafruit invests time and resources providing this open source code,
please support Adafruit and open-source hardware by purchasing
products from Adafruit!
@section HISTORY
v1.0 - First release
*/
/**************************************************************************/
#ifndef ADAFRUIT_CPLAY_LIS3DH_H
#define ADAFRUIT_CPLAY_LIS3DH_H
#if ARDUINO >= 100
#include "Arduino.h"
#else
#include "WProgram.h"
#endif
#include <Wire.h>
#ifndef __AVR_ATtiny85__
#include <SPI.h>
#endif
#include "utility/Adafruit_CPlay_Sensor.h"
/*=========================================================================
I2C ADDRESS/BITS
-----------------------------------------------------------------------*/
#define LIS3DH_DEFAULT_ADDRESS (0x18) // if SDO/SA0 is 3V, its 0x19
/*=========================================================================*/
#define LIS3DH_REG_STATUS1 0x07
#define LIS3DH_REG_OUTADC1_L 0x08
#define LIS3DH_REG_OUTADC1_H 0x09
#define LIS3DH_REG_OUTADC2_L 0x0A
#define LIS3DH_REG_OUTADC2_H 0x0B
#define LIS3DH_REG_OUTADC3_L 0x0C
#define LIS3DH_REG_OUTADC3_H 0x0D
#define LIS3DH_REG_INTCOUNT 0x0E
#define LIS3DH_REG_WHOAMI 0x0F
#define LIS3DH_REG_TEMPCFG 0x1F
#define LIS3DH_REG_CTRL1 0x20
#define LIS3DH_REG_CTRL2 0x21
#define LIS3DH_REG_CTRL3 0x22
#define LIS3DH_REG_CTRL4 0x23
#define LIS3DH_REG_CTRL5 0x24
#define LIS3DH_REG_CTRL6 0x25
#define LIS3DH_REG_REFERENCE 0x26
#define LIS3DH_REG_STATUS2 0x27
#define LIS3DH_REG_OUT_X_L 0x28
#define LIS3DH_REG_OUT_X_H 0x29
#define LIS3DH_REG_OUT_Y_L 0x2A
#define LIS3DH_REG_OUT_Y_H 0x2B
#define LIS3DH_REG_OUT_Z_L 0x2C
#define LIS3DH_REG_OUT_Z_H 0x2D
#define LIS3DH_REG_FIFOCTRL 0x2E
#define LIS3DH_REG_FIFOSRC 0x2F
#define LIS3DH_REG_INT1CFG 0x30
#define LIS3DH_REG_INT1SRC 0x31
#define LIS3DH_REG_INT1THS 0x32
#define LIS3DH_REG_INT1DUR 0x33
#define LIS3DH_REG_CLICKCFG 0x38
#define LIS3DH_REG_CLICKSRC 0x39
#define LIS3DH_REG_CLICKTHS 0x3A
#define LIS3DH_REG_TIMELIMIT 0x3B
#define LIS3DH_REG_TIMELATENCY 0x3C
#define LIS3DH_REG_TIMEWINDOW 0x3D
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;
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;
class Adafruit_CPlay_LIS3DH : public Adafruit_Sensor {
public:
Adafruit_CPlay_LIS3DH(void);
Adafruit_CPlay_LIS3DH(int8_t cspin);
Adafruit_CPlay_LIS3DH(int8_t cspin, int8_t mosipin, int8_t misopin, int8_t sckpin);
bool begin(uint8_t addr = LIS3DH_DEFAULT_ADDRESS);
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);
uint8_t getOrientation(void);
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, y, z;
float x_g, y_g, z_g;
private:
uint8_t readRegister8(uint8_t reg);
void writeRegister8(uint8_t reg, uint8_t value);
uint8_t spixfer(uint8_t x = 0xFF);
int32_t _sensorID;
int8_t _i2caddr;
// SPI
int8_t _cs, _mosi, _miso, _sck;
};
#endif
libraries/Adafruit_CircuitPlayground/utility/Adafruit_CPlay_Mic.cpp
+158
View File
@@ -0,0 +1,158 @@
// 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"
#define DC_OFFSET (1023 / 3)
#define NOISE_THRESHOLD 3
// -------------------------------------------------------------------------
// Reads ADC for given interval (in milliseconds, 1-65535), returns max
// deviation from DC_OFFSET (e.g. 0-341). Uses ADC free-run mode w/polling.
// Any currently-installed ADC interrupt handler will be temporarily
// disabled while this runs.
int Adafruit_CPlay_Mic::peak(uint16_t ms) {
uint8_t admux_save, adcsra_save, adcsrb_save, timsk0_save, channel;
uint16_t i, nSamples;
int16_t adc, adcMin, adcMax;
nSamples = (9615L * ms + 500) / 1000;
if(!nSamples) nSamples = 1;
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).
adcMin = 1023;
adcMax = 0;
for(i=0; i<nSamples; i++) {
while(!(ADCSRA & _BV(ADIF))); // Wait for ADC result
adc = ADC; // 0-1023
ADCSRA |= _BV(ADIF); // Clear bit
if(adc < adcMin) adcMin = adc;
if(adc > adcMax) adcMax = adc;
}
ADMUX = admux_save; // Restore ADC config
ADCSRB = adcsrb_save;
ADCSRA = adcsra_save;
(void)analogRead(A4); // Purge residue from ADC register
adcMin = abs(adcMin - DC_OFFSET);
adcMax = abs(adcMax - DC_OFFSET);
if(adcMin > DC_OFFSET) adcMin = DC_OFFSET;
if(adcMax > DC_OFFSET) adcMax = DC_OFFSET;
if(adcMin > adcMax) adcMax = adcMin;
return adcMax;
}
// -------------------------------------------------------------------------
// 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, uint8_t nSamples) {
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(uint8_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
}
// -------------------------------------------------------------------------
// 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.
typedef struct {
int16_t r;
int16_t i;
} 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 *);
}
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)
}
}
libraries/Adafruit_CircuitPlayground/utility/Adafruit_CPlay_Mic.h
+17
View File
@@ -0,0 +1,17 @@
// 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
class Adafruit_CPlay_Mic {
public:
Adafruit_CPlay_Mic(void) {}; // Empty constructor
int peak(uint16_t ms);
void capture(int16_t *buf, uint8_t nSamples),
fft(uint16_t *spectrum);
};
#endif // ADAFRUIT_CPLAY_MIC_H
libraries/Adafruit_CircuitPlayground/utility/Adafruit_CPlay_NeoPixel.cpp
+1000
View File
File diff suppressed because it is too large Load Diff
libraries/Adafruit_CircuitPlayground/utility/Adafruit_CPlay_NeoPixel.h
+179
View File
@@ -0,0 +1,179 @@
/*--------------------------------------------------------------------
This file is part of the Adafruit NeoPixel library.
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.
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
#if (ARDUINO >= 100)
#include <Arduino.h>
#else
#include <WProgram.h>
#include <pins_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
// 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.
// 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))
#define NEO_RBG ((0 << 6) | (0 << 4) | (2 << 2) | (1))
#define NEO_GRB ((1 << 6) | (1 << 4) | (0 << 2) | (2))
#define NEO_GBR ((2 << 6) | (2 << 4) | (0 << 2) | (1))
#define NEO_BRG ((1 << 6) | (1 << 4) | (2 << 2) | (0))
#define NEO_BGR ((2 << 6) | (2 << 4) | (1 << 2) | (0))
// RGBW NeoPixel permutations; all 4 offsets are distinct
// Offset: W R G B
#define NEO_WRGB ((0 << 6) | (1 << 4) | (2 << 2) | (3))
#define NEO_WRBG ((0 << 6) | (1 << 4) | (3 << 2) | (2))
#define NEO_WGRB ((0 << 6) | (2 << 4) | (1 << 2) | (3))
#define NEO_WGBR ((0 << 6) | (3 << 4) | (1 << 2) | (2))
#define NEO_WBRG ((0 << 6) | (2 << 4) | (3 << 2) | (1))
#define NEO_WBGR ((0 << 6) | (3 << 4) | (2 << 2) | (1))
#define NEO_RWGB ((1 << 6) | (0 << 4) | (2 << 2) | (3))
#define NEO_RWBG ((1 << 6) | (0 << 4) | (3 << 2) | (2))
#define NEO_RGWB ((2 << 6) | (0 << 4) | (1 << 2) | (3))
#define NEO_RGBW ((3 << 6) | (0 << 4) | (1 << 2) | (2))
#define NEO_RBWG ((2 << 6) | (0 << 4) | (3 << 2) | (1))
#define NEO_RBGW ((3 << 6) | (0 << 4) | (2 << 2) | (1))
#define NEO_GWRB ((1 << 6) | (2 << 4) | (0 << 2) | (3))
#define NEO_GWBR ((1 << 6) | (3 << 4) | (0 << 2) | (2))
#define NEO_GRWB ((2 << 6) | (1 << 4) | (0 << 2) | (3))
#define NEO_GRBW ((3 << 6) | (1 << 4) | (0 << 2) | (2))
#define NEO_GBWR ((2 << 6) | (3 << 4) | (0 << 2) | (1))
#define NEO_GBRW ((3 << 6) | (2 << 4) | (0 << 2) | (1))
#define NEO_BWRG ((1 << 6) | (2 << 4) | (3 << 2) | (0))
#define NEO_BWGR ((1 << 6) | (3 << 4) | (2 << 2) | (0))
#define NEO_BRWG ((2 << 6) | (1 << 4) | (3 << 2) | (0))
#define NEO_BRGW ((3 << 6) | (1 << 4) | (2 << 2) | (0))
#define NEO_BGWR ((2 << 6) | (3 << 4) | (1 << 2) | (0))
#define NEO_BGRW ((3 << 6) | (2 << 4) | (1 << 2) | (0))
// 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 datastream
#ifndef __AVR_ATtiny85__
#define NEO_KHZ400 0x0100 // 400 KHz datastream
#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;
#else
typedef uint8_t neoPixelType;
#endif
class Adafruit_CPlay_NeoPixel {
public:
// Constructor: number of LEDs, pin number, LED type
Adafruit_CPlay_NeoPixel(uint16_t n, uint8_t p=6, neoPixelType t=NEO_GRB + NEO_KHZ800);
Adafruit_CPlay_NeoPixel(void);
~Adafruit_CPlay_NeoPixel();
void
begin(void),
show(void),
setPin(uint8_t p),
setPixelColor(uint16_t n, uint8_t r, uint8_t g, uint8_t b),
setPixelColor(uint16_t n, uint8_t r, uint8_t g, uint8_t b, uint8_t w),
setPixelColor(uint16_t n, uint32_t c),
setBrightness(uint8_t),
clear(),
updateLength(uint16_t n),
updateType(neoPixelType t);
uint8_t
*getPixels(void) const,
getBrightness(void) const;
uint16_t
numPixels(void) const;
static uint32_t
Color(uint8_t r, uint8_t g, uint8_t b),
Color(uint8_t r, uint8_t g, uint8_t b, uint8_t w);
uint32_t
getPixelColor(uint16_t n) const;
inline bool
canShow(void) { return (micros() - endTime) >= 50L; }
private:
boolean
#ifdef NEO_KHZ400 // If 400 KHz NeoPixel support enabled...
is800KHz, // ...true if 800 KHz pixels
#endif
begun; // true if begin() previously called
uint16_t
numLEDs, // Number of RGB LEDs in strip
numBytes; // Size of 'pixels' buffer below (3 or 4 bytes/pixel)
int8_t
pin; // Output pin number (-1 if not yet set)
uint8_t
brightness,
*pixels, // Holds LED color values (3 or 4 bytes each)
rOffset, // Index of red byte within each 3- or 4-byte pixel
gOffset, // Index of green byte
bOffset, // Index of blue byte
wOffset; // Index of white byte (same as 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
};
#endif // ADAFRUIT_CPLAY_NEOPIXEL_H
libraries/Adafruit_CircuitPlayground/utility/Adafruit_CPlay_Sensor.h
+155
View File
@@ -0,0 +1,155 @@
/*
* 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];
struct {
float x;
float y;
float z;
};
/* Orientation sensors */
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° */
};
};
int8_t status;
uint8_t reserved[3];
} sensors_vec_t;
/** struct sensors_color_s is used to return color data in a common format. */
typedef struct {
union {
float c[3];
/* RGB color space */
struct {
float r; /**< Red component */
float g; /**< Green component */
float b; /**< Blue component */
};
};
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];
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 */
};
} 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;
class Adafruit_Sensor {
public:
// Constructor(s)
Adafruit_Sensor() {}
virtual ~Adafruit_Sensor() {}
// These must be defined by the subclass
virtual void enableAutoRange(bool enabled) {};
virtual bool getEvent(sensors_event_t*) = 0;
virtual void getSensor(sensor_t*) = 0;
private:
bool _autoRange;
};
#endif
libraries/Adafruit_CircuitPlayground/utility/Adafruit_CPlay_Speaker.cpp
+90
View File
@@ -0,0 +1,90 @@
// Adafruit Circuit Playground speaker library
// by Phil Burgess / Paint Your Dragon.
#include <Arduino.h>
#include "Adafruit_CPlay_Speaker.h"
// -------------------------------------------------------------------------
// 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) {
// 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
TC4H = 0; // Not 10-bit mode
DT4 = 0; // No dead time
OCR4C = 255; // TOP
OCR4A = 127; // 50% duty (idle position) to start
started = true;
pinMode(5, OUTPUT); // Enable output
}
// -------------------------------------------------------------------------
// Turns off PWM output to the speaker.
void Adafruit_CPlay_Speaker::end(void) {
pinMode(5, INPUT);
TCCR4A = 0; // PWMA off
started = false;
}
// -------------------------------------------------------------------------
// Sets speaker position (0-255; 127=idle), enables PWM output if needed.
void Adafruit_CPlay_Speaker::set(uint8_t value) {
if(!started) begin();
TCCR4A = value;
}
// -------------------------------------------------------------------------
// Plays digitized 8-bit audio from a PROGMEM (flash memory) buffer. Maybe
// 1-3 seconds tops depending on sampling rate (e.g. 8000 Hz data =
// 8 Kbytes/second). Max ~20K space avail on Circuit Playground.
// This function currently "blocks" -- it will not play sounds in the
// background while other code runs.
void Adafruit_CPlay_Speaker::playSound(
const uint8_t *data, uint16_t bytesToGo, uint16_t sampleRate) {
if(sampleRate < 7620) sampleRate = 7620; // Because 8-bit delay counter
uint8_t interval = (F_CPU / 4 + sampleRate / 2) / sampleRate - 6,
x, counter;
if(!started) begin();
// Trying cycle counting here (instead of interrupt) to avoid ISR
// conflicts (some sketches may need their own timers or related
// interrupts -- a precious resource!). Could also try this using
// micros(), but that might lack adequate resolution.
asm volatile(
"movw r30 , %[data]" "\n\t" // Z = data
"audioSampleLoop:"
"lpm %[x] , Z+" "\n\t" // x = pgm_read_byte(data++)
"sts %[pwmReg] , %[x]" "\n\t" // OCR4A = x
"mov %[counter] , %[interval]" "\n\t" // counter = interval
"audioDelayLoop:" "\n\t"
"nop" "\n\t"
"dec %[counter]" "\n\t" // counter--
"brne audioDelayLoop" "\n\t" // if(counter) goto audioDelay
"sbiw %[bytesToGo], 1" "\n\t" // bytesToGo--
"brne audioSampleLoop" "\n" // if(bytesToGo) goto audioSample
: [x] "+r" (x),
[counter] "+r" (counter),
[bytesToGo] "+w" (bytesToGo)
: [data] "e" (data),
[pwmReg] "M" (_SFR_ADDR(OCR4A)),
[interval] "r" (interval)
: "r30", "r31" ); // Z is clobbered
OCR4A = 127; // Idle position for next sound
}
libraries/Adafruit_CircuitPlayground/utility/Adafruit_CPlay_Speaker.h
+22
View File
@@ -0,0 +1,22 @@
// Adafruit Circuit Playground speaker library
// by Phil Burgess / Paint Your Dragon.
#ifndef ADAFRUIT_CPLAY_SPEAKER_H
#define ADAFRUIT_CPLAY_SPEAKER_H
#include <Arduino.h>
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, uint16_t length, uint16_t sampleRate),
say(const uint8_t *address);
private:
boolean started;
};
#endif // ADAFRUIT_CPLAY_SPEAKER_H
libraries/Adafruit_CircuitPlayground/utility/CP_Boards.h
+805
View File
@@ -0,0 +1,805 @@
/*
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
// anything else
#else
#error "Please edit 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 */
libraries/Adafruit_CircuitPlayground/utility/CP_Firmata.cpp
+668
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;
libraries/Adafruit_CircuitPlayground/utility/CP_Firmata.h
+224
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 */
libraries/Adafruit_CircuitPlayground/utility/CPlay_CapacitiveSensor.cpp
+197
View File
@@ -0,0 +1,197 @@
/*
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"
// Constructor /////////////////////////////////////////////////////////////////
// Function that handles the creation and setup of instances
CPlay_CapacitiveSensor::CPlay_CapacitiveSensor(uint8_t sendPin, uint8_t receivePin)
{
// initialize this instance's variables
// Serial.begin(9600); // for debugging
error = 1;
loopTimingFactor = 300; // determined empirically - a hack
CS_Timeout_Millis = (2000 * (float)loopTimingFactor * (float)F_CPU) / 16000000;
CS_AutocaL_Millis = 20000;
// Serial.print("timwOut = ");
// Serial.println(CS_Timeout_Millis);
// get pin mapping and port for send Pin - from PinMode function in core
#ifdef NUM_DIGITAL_PINS
if (sendPin >= NUM_DIGITAL_PINS) error = -1;
if (receivePin >= NUM_DIGITAL_PINS) error = -2;
#endif
// sendpin to OUTPUT
#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
sBit = PIN_TO_BITMASK(sendPin); // get send pin's ports and bitmask
sReg = PIN_TO_BASEREG(sendPin); // get pointer to output register
rBit = PIN_TO_BITMASK(receivePin); // get receive pin's ports and bitmask
rReg = PIN_TO_BASEREG(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
long CPlay_CapacitiveSensor::capacitiveSensor(uint8_t samples)
{
total = 0;
if (samples == 0) return 0;
if (error < 0) return -1; // bad pin
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);
}
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;
}
void CPlay_CapacitiveSensor::reset_CS_AutoCal(void){
leastTotal = 0x0FFFFFFFL;
}
void CPlay_CapacitiveSensor::set_CS_AutocaL_Millis(unsigned long autoCal_millis){
CS_AutocaL_Millis = autoCal_millis;
}
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
int CPlay_CapacitiveSensor::SenseOneCycle(void)
{
noInterrupts();
DIRECT_WRITE_LOW(sReg, sBit); // sendPin Register low
DIRECT_MODE_INPUT(rReg, rBit); // receivePin to input (pullups are off)
DIRECT_MODE_OUTPUT(rReg, rBit); // receivePin to OUTPUT
DIRECT_WRITE_LOW(rReg, rBit); // pin is now LOW AND OUTPUT
delayMicroseconds(10);
DIRECT_MODE_INPUT(rReg, rBit); // receivePin to input (pullups are off)
DIRECT_WRITE_HIGH(sReg, sBit); // sendPin High
interrupts();
while ( !DIRECT_READ(rReg, rBit) && (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();
DIRECT_WRITE_HIGH(rReg, rBit);
DIRECT_MODE_OUTPUT(rReg, rBit); // receivePin to OUTPUT - pin is now HIGH AND OUTPUT
DIRECT_WRITE_HIGH(rReg, rBit);
DIRECT_MODE_INPUT(rReg, rBit); // receivePin to INPUT (pullup is off)
DIRECT_WRITE_LOW(sReg, sBit); // sendPin LOW
interrupts();
#ifdef FIVE_VOLT_TOLERANCE_WORKAROUND
DIRECT_MODE_OUTPUT(rReg, rBit);
DIRECT_WRITE_LOW(rReg, rBit);
delayMicroseconds(10);
DIRECT_MODE_INPUT(rReg, rBit); // receivePin to INPUT (pullup is off)
#else
while ( DIRECT_READ(rReg, rBit) && (total < CS_Timeout_Millis) ) { // while receive pin is HIGH AND total is less than timeout
total++;
}
#endif
//Serial.print("SenseOneCycle(2): ");
//Serial.println(total);
if (total >= CS_Timeout_Millis) {
return -2; // total variable over timeout
} else {
return 1;
}
}
libraries/Adafruit_CircuitPlayground/utility/CPlay_CapacitiveSensor.h
+230
View File
@@ -0,0 +1,230 @@
/*
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
// Direct I/O through registers and bitmask (from OneWire library)
#if defined(__AVR__)
#define PIN_TO_BASEREG(pin) (portInputRegister(digitalPinToPort(pin)))
#define PIN_TO_BITMASK(pin) (digitalPinToBitMask(pin))
#define IO_REG_TYPE uint8_t
#define DIRECT_READ(base, mask) (((*(base)) & (mask)) ? 1 : 0)
#define DIRECT_MODE_INPUT(base, mask) ((*((base)+1)) &= ~(mask), (*((base)+2)) &= ~(mask))
#define DIRECT_MODE_OUTPUT(base, mask) ((*((base)+1)) |= (mask))
#define DIRECT_WRITE_LOW(base, mask) ((*((base)+2)) &= ~(mask))
#define DIRECT_WRITE_HIGH(base, mask) ((*((base)+2)) |= (mask))
#elif defined(__MK20DX128__) || defined(__MK20DX256__) || defined(__MK66FX1M0__) || defined(__MK64FX512__)
#define PIN_TO_BASEREG(pin) (portOutputRegister(pin))
#define PIN_TO_BITMASK(pin) (1)
#define IO_REG_TYPE uint8_t
#define IO_REG_ASM
#define DIRECT_READ(base, mask) (*((base)+512))
#define DIRECT_MODE_INPUT(base, mask) (*((base)+640) = 0)
#define DIRECT_MODE_OUTPUT(base, mask) (*((base)+640) = 1)
#define DIRECT_WRITE_LOW(base, mask) (*((base)+256) = 1)
#define DIRECT_WRITE_HIGH(base, mask) (*((base)+128) = 1)
#elif defined(__MKL26Z64__)
#define PIN_TO_BASEREG(pin) (portOutputRegister(pin))
#define PIN_TO_BITMASK(pin) (digitalPinToBitMask(pin))
#define IO_REG_TYPE uint8_t
#define IO_REG_ASM
#define DIRECT_READ(base, mask) ((*((base)+16) & (mask)) ? 1 : 0)
#define DIRECT_MODE_INPUT(base, mask) (*((base)+20) &= ~(mask))
#define DIRECT_MODE_OUTPUT(base, mask) (*((base)+20) |= (mask))
#define DIRECT_WRITE_LOW(base, mask) (*((base)+8) = (mask))
#define DIRECT_WRITE_HIGH(base, mask) (*((base)+4) = (mask))
#elif defined(__SAM3X8E__)
#define PIN_TO_BASEREG(pin) (&(digitalPinToPort(pin)->PIO_PER))
#define PIN_TO_BITMASK(pin) (digitalPinToBitMask(pin))
#define IO_REG_TYPE uint32_t
#define IO_REG_ASM
#define DIRECT_READ(base, mask) (((*((base)+15)) & (mask)) ? 1 : 0)
#define DIRECT_MODE_INPUT(base, mask) ((*((base)+5)) = (mask))
#define DIRECT_MODE_OUTPUT(base, mask) ((*((base)+4)) = (mask))
#define DIRECT_WRITE_LOW(base, mask) ((*((base)+13)) = (mask))
#define DIRECT_WRITE_HIGH(base, mask) ((*((base)+12)) = (mask))
#elif defined(__PIC32MX__)
#define PIN_TO_BASEREG(pin) (portModeRegister(digitalPinToPort(pin)))
#define PIN_TO_BITMASK(pin) (digitalPinToBitMask(pin))
#define IO_REG_TYPE uint32_t
#define IO_REG_ASM
#define DIRECT_READ(base, mask) (((*(base+4)) & (mask)) ? 1 : 0) //PORTX + 0x10
#define DIRECT_MODE_INPUT(base, mask) ((*(base+2)) = (mask)) //TRISXSET + 0x08
#define DIRECT_MODE_OUTPUT(base, mask) ((*(base+1)) = (mask)) //TRISXCLR + 0x04
#define DIRECT_WRITE_LOW(base, mask) ((*(base+8+1)) = (mask)) //LATXCLR + 0x24
#define DIRECT_WRITE_HIGH(base, mask) ((*(base+8+2)) = (mask)) //LATXSET + 0x28
#elif defined(ARDUINO_ARCH_ESP8266)
#define PIN_TO_BASEREG(pin) (portOutputRegister(digitalPinToPort(pin)))
#define PIN_TO_BITMASK(pin) (digitalPinToBitMask(pin))
#define IO_REG_TYPE uint32_t
#define IO_REG_ASM
#define DIRECT_READ(base, mask) (((*(base+6)) & (mask)) ? 1 : 0) //GPIO_IN_ADDRESS
#define DIRECT_MODE_INPUT(base, mask) ((*(base+5)) = (mask)) //GPIO_ENABLE_W1TC_ADDRESS
#define DIRECT_MODE_OUTPUT(base, mask) ((*(base+4)) = (mask)) //GPIO_ENABLE_W1TS_ADDRESS
#define DIRECT_WRITE_LOW(base, mask) ((*(base+2)) = (mask)) //GPIO_OUT_W1TC_ADDRESS
#define DIRECT_WRITE_HIGH(base, mask) ((*(base+1)) = (mask)) //GPIO_OUT_W1TS_ADDRESS
#elif defined(__SAMD21G18A__)
// runs extremely slow/unreliable on Arduino Zero - help wanted....
#define PIN_TO_BASEREG(pin) portModeRegister(digitalPinToPort(pin))
#define PIN_TO_BITMASK(pin) (digitalPinToBitMask(pin))
#define IO_REG_TYPE uint32_t
#define IO_REG_ASM
#define DIRECT_READ(base, mask) (((*((base)+8)) & (mask)) ? 1 : 0)
#define DIRECT_MODE_INPUT(base, mask) ((*((base)+1)) = (mask))
#define DIRECT_MODE_OUTPUT(base, mask) ((*((base)+2)) = (mask))
#define DIRECT_WRITE_LOW(base, mask) ((*((base)+5)) = (mask))
#define DIRECT_WRITE_HIGH(base, mask) ((*((base)+6)) = (mask))
#elif defined(RBL_NRF51822)
#define PIN_TO_BASEREG(pin) (0)
#define PIN_TO_BITMASK(pin) (pin)
#define IO_REG_TYPE uint32_t
#define IO_REG_ASM
#define DIRECT_READ(base, pin) nrf_gpio_pin_read(pin)
#define DIRECT_WRITE_LOW(base, pin) nrf_gpio_pin_clear(pin)
#define DIRECT_WRITE_HIGH(base, pin) nrf_gpio_pin_set(pin)
#define DIRECT_MODE_INPUT(base, pin) nrf_gpio_cfg_input(pin, NRF_GPIO_PIN_NOPULL)
#define DIRECT_MODE_OUTPUT(base, pin) nrf_gpio_cfg_output(pin)
#elif defined(__arc__)
#include "scss_registers.h"
#include "portable.h"
#include "avr/pgmspace.h"
#define GPIO_ID(pin) (g_APinDescription[pin].ulGPIOId)
#define GPIO_TYPE(pin) (g_APinDescription[pin].ulGPIOType)
#define GPIO_BASE(pin) (g_APinDescription[pin].ulGPIOBase)
#define DIR_OFFSET_SS 0x01
#define DIR_OFFSET_SOC 0x04
#define EXT_PORT_OFFSET_SS 0x0A
#define EXT_PORT_OFFSET_SOC 0x50
/* GPIO registers base address */
#define PIN_TO_BASEREG(pin) ((volatile uint32_t *)g_APinDescription[pin].ulGPIOBase)
#define PIN_TO_BITMASK(pin) pin
#define IO_REG_TYPE uint32_t
#define IO_REG_ASM
static inline __attribute__((always_inline))
IO_REG_TYPE directRead(volatile IO_REG_TYPE *base, IO_REG_TYPE pin)
{
IO_REG_TYPE ret;
if (SS_GPIO == GPIO_TYPE(pin)) {
ret = READ_ARC_REG(((IO_REG_TYPE)base + EXT_PORT_OFFSET_SS));
} else {
ret = MMIO_REG_VAL_FROM_BASE((IO_REG_TYPE)base, EXT_PORT_OFFSET_SOC);
}
return ((ret >> GPIO_ID(pin)) & 0x01);
}
static inline __attribute__((always_inline))
void directModeInput(volatile IO_REG_TYPE *base, IO_REG_TYPE pin)
{
if (SS_GPIO == GPIO_TYPE(pin)) {
WRITE_ARC_REG(READ_ARC_REG((((IO_REG_TYPE)base) + DIR_OFFSET_SS)) & ~(0x01 << GPIO_ID(pin)),
((IO_REG_TYPE)(base) + DIR_OFFSET_SS));
} else {
MMIO_REG_VAL_FROM_BASE((IO_REG_TYPE)base, DIR_OFFSET_SOC) &= ~(0x01 << GPIO_ID(pin));
}
}
static inline __attribute__((always_inline))
void directModeOutput(volatile IO_REG_TYPE *base, IO_REG_TYPE pin)
{
if (SS_GPIO == GPIO_TYPE(pin)) {
WRITE_ARC_REG(READ_ARC_REG(((IO_REG_TYPE)(base) + DIR_OFFSET_SS)) | (0x01 << GPIO_ID(pin)),
((IO_REG_TYPE)(base) + DIR_OFFSET_SS));
} else {
MMIO_REG_VAL_FROM_BASE((IO_REG_TYPE)base, DIR_OFFSET_SOC) |= (0x01 << GPIO_ID(pin));
}
}
static inline __attribute__((always_inline))
void directWriteLow(volatile IO_REG_TYPE *base, IO_REG_TYPE pin)
{
if (SS_GPIO == GPIO_TYPE(pin)) {
WRITE_ARC_REG(READ_ARC_REG(base) & ~(0x01 << GPIO_ID(pin)), base);
} else {
MMIO_REG_VAL(base) &= ~(0x01 << GPIO_ID(pin));
}
}
static inline __attribute__((always_inline))
void directWriteHigh(volatile IO_REG_TYPE *base, IO_REG_TYPE pin)
{
if (SS_GPIO == GPIO_TYPE(pin)) {
WRITE_ARC_REG(READ_ARC_REG(base) | (0x01 << GPIO_ID(pin)), base);
} else {
MMIO_REG_VAL(base) |= (0x01 << GPIO_ID(pin));
}
}
#define DIRECT_READ(base, pin) directRead(base, pin)
#define DIRECT_MODE_INPUT(base, pin) directModeInput(base, pin)
#define DIRECT_MODE_OUTPUT(base, pin) directModeOutput(base, pin)
#define DIRECT_WRITE_LOW(base, pin) directWriteLow(base, pin)
#define DIRECT_WRITE_HIGH(base, pin) directWriteHigh(base, pin)
#endif
// some 3.3V chips with 5V tolerant pins need this workaround
//
#if defined(__MK20DX256__)
#define FIVE_VOLT_TOLERANCE_WORKAROUND
#endif
// library interface description
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;
IO_REG_TYPE sBit; // send pin's ports and bitmask
volatile IO_REG_TYPE *sReg;
IO_REG_TYPE rBit; // receive pin's ports and bitmask
volatile IO_REG_TYPE *rReg;
// methods
int SenseOneCycle(void);
};
#endif
libraries/Adafruit_CircuitPlayground/utility/README.md
+13
View File
@@ -0,0 +1,13 @@
#CapacitiveSensor Library#
CapacitiveSensor lets you create sensors that can detect touch or proximity.
http://www.pjrc.com/teensy/td_libs_CapacitiveSensor.html
http://playground.arduino.cc/Main/CapacitiveSensor
http://www.youtube.com/watch?v=BHQPqQ_5ulc
CapacitiveSensor was originally written by Paul Badger and is now maintained by Paul Stoffregen.
![CapacitiveSensor Demo](http://www.pjrc.com/teensy/td_libs_CapacitiveSensor_1.jpg)
libraries/Adafruit_CircuitPlayground/utility/esp8266.c
+67
View File
@@ -0,0 +1,67 @@
// This is a mash-up of the Due show() code + insights from Michael Miller's
// ESP8266 work for the NeoPixelBus library: github.com/Makuna/NeoPixelBus
// Needs to be a separate .c file to enforce ICACHE_RAM_ATTR execution.
#ifdef ESP8266
#include <Arduino.h>
#include <eagle_soc.h>
static uint32_t _getCycleCount(void) __attribute__((always_inline));
static inline uint32_t _getCycleCount(void) {
uint32_t ccount;
__asm__ __volatile__("rsr %0,ccount":"=a" (ccount));
return ccount;
}
void ICACHE_RAM_ATTR espShow(
uint8_t pin, uint8_t *pixels, uint32_t numBytes, boolean is800KHz) {
#define CYCLES_800_T0H (F_CPU / 2500000) // 0.4us
#define CYCLES_800_T1H (F_CPU / 1250000) // 0.8us
#define CYCLES_800 (F_CPU / 800000) // 1.25us per bit
#define CYCLES_400_T0H (F_CPU / 2000000) // 0.5uS
#define CYCLES_400_T1H (F_CPU / 833333) // 1.2us
#define CYCLES_400 (F_CPU / 400000) // 2.5us per bit
uint8_t *p, *end, pix, mask;
uint32_t t, time0, time1, period, c, startTime, pinMask;
pinMask = _BV(pin);
p = pixels;
end = p + numBytes;
pix = *p++;
mask = 0x80;
startTime = 0;
#ifdef NEO_KHZ400
if(is800KHz) {
#endif
time0 = CYCLES_800_T0H;
time1 = CYCLES_800_T1H;
period = CYCLES_800;
#ifdef NEO_KHZ400
} else { // 400 KHz bitstream
time0 = CYCLES_400_T0H;
time1 = CYCLES_400_T1H;
period = CYCLES_400;
}
#endif
for(t = time0;; t = time0) {
if(pix & mask) t = time1; // Bit high duration
while(((c = _getCycleCount()) - startTime) < period); // Wait for bit start
GPIO_REG_WRITE(GPIO_OUT_W1TS_ADDRESS, pinMask); // Set high
startTime = c; // Save start time
while(((c = _getCycleCount()) - startTime) < t); // Wait high duration
GPIO_REG_WRITE(GPIO_OUT_W1TC_ADDRESS, pinMask); // Set low
if(!(mask >>= 1)) { // Next bit/byte
if(p >= end) break;
pix = *p++;
mask = 0x80;
}
}
while((_getCycleCount() - startTime) < period); // Wait for last bit
}
#endif // ESP8266
libraries/Adafruit_CircuitPlayground/utility/ffft.S
+431
View File
@@ -0,0 +1,431 @@
;-----------------------------------------------------------------------------;
; Fixed-point FFT routines for megaAVRs (C)ChaN, 2005
;-----------------------------------------------------------------------------;
; * This program is opened under license policy of following trems.
;
; Copyright (C) 2005, ChaN, all right reserved.
;
; * This program is a free software and there is NO WARRANTY.
; * No restriction on use. You can use, modify and redistribute it for
; personal, non-profit or commercial use UNDER YOUR RESPONSIBILITY.
; * Redistributions of source code must retain the above copyright notice.
;
;-----------------------------------------------------------------------------;
;
; void fft_input (const int16_t *array_src, complex_t *array_bfly);
; void fft_execute (complex_t *array_bfly);
; void fft_output (complex_t *array_bfly, uint16_t *array_dst);
;
; <array_src>: Wave form to be processed.
; <array_bfly>: Complex array for butterfly operations.
; <array_dst>: Spectrum output buffer.
;
; These functions must be called in sequence to do a DFT in FFT algorithm.
; fft_input() fills the complex array with a wave form to prepare butterfly
; operations. A hamming window is applied at the same time.
; fft_execute() executes the butterfly operations.
; fft_output() re-orders the results, converts the complex spectrum into
; scalar spectrum and output it in linear scale.
;
;----------------------------------------------------------------------------;
; THIS CODE HAS BEEN MODIFIED FROM ITS ORIGINAL FORM - it is pared down
; to handle 64 points only, for the Circuit Playground microphone library.
; Original FFFT code can be found on GitHub.
;----------------------------------------------------------------------------;
.list
#define FFT_N 64
#define FFT_B 6
#define T0L r0
#define T0H r1
#define T2L r2
#define T2H r3
#define T4L r4
#define T4H r5
#define T6L r6
#define T6H r7
#define T8L r8
#define T8H r9
#define T10L r10
#define T10H r11
#define T12L r12
#define T12H r13
#define T14L r14
#define T14H r15
#define AL r16
#define AH r17
#define BL r18
#define BH r19
#define CL r20
#define CH r21
#define DL r22
#define DH r23
#define EL r24
#define EH r25
#define XL r26
#define XH r27
#define YL r28
#define YH r29
#define ZL r30
#define ZH r31
.macro ldiw dh,dl, abs
ldi \dl, lo8(\abs)
ldi \dh, hi8(\abs)
.endm
.macro subiw dh,dl, abs
subi \dl, lo8(\abs)
sbci \dh, hi8(\abs)
.endm
.macro addw dh,dl, sh,sl
add \dl, \sl
adc \dh, \sh
.endm
.macro addd d3,d2,d1,d0, s3,s2,s1,s0
add \d0, \s0
adc \d1, \s1
adc \d2, \s2
adc \d3, \s3
.endm
.macro subw dh,dl, sh,sl
sub \dl, \sl
sbc \dh, \sh
.endm
.macro subd d3,d2,d1,d0, s3,s2,s1,s0
sub \d0, \s0
sbc \d1, \s1
sbc \d2, \s2
sbc \d3, \s3
.endm
.macro lddw dh,dl, src
ldd \dl, \src
ldd \dh, \src+1
.endm
.macro ldw dh,dl, src
ld \dl, \src
ld \dh, \src
.endm
.macro stw dst, sh,sl
st \dst, \sl
st \dst, \sh
.endm
.macro clrw dh, dl
clr \dh
clr \dl
.endm
.macro lsrw dh, dl
lsr \dh
ror \dl
.endm
.macro asrw dh, dl
asr \dh
ror \dl
.endm
.macro lslw dh, dl
lsl \dl
rol \dh
.endm
.macro pushw dh, dl
push \dh
push \dl
.endm
.macro popw dh, dl
pop \dl
pop \dh
.endm
.macro lpmw dh,dl, src
lpm \dl, \src
lpm \dh, \src
.endm
.macro rjne lbl
breq 99f
rjmp \lbl
99:
.endm
.macro FMULS16 d3,d2,d1,d0 ,s1h,s1l, s2h,s2l ;Fractional Multiply (19clk)
fmuls \s1h, \s2h
movw \d2, T0L
fmul \s1l, \s2l
movw \d0, T0L
adc \d2, EH ;EH: zero reg.
fmulsu \s1h, \s2l
sbc \d3, EH
add \d1, T0L
adc \d2, T0H
adc \d3, EH
fmulsu \s2h, \s1l
sbc \d3, EH
add \d1, T0L
adc \d2, T0H
adc \d3, EH
.endm
.macro SQRT32 ; 32bit square root (526..542clk)
clr T6L
clr T6H
clr T8L
clr T8H
ldi BL, 1
ldi BH, 0
clr CL
clr CH
ldi DH, 16
90: lsl T2L
rol T2H
rol T4L
rol T4H
rol T6L
rol T6H
rol T8L
rol T8H
lsl T2L
rol T2H
rol T4L
rol T4H
rol T6L
rol T6H
rol T8L
rol T8H
brpl 91f
add T6L, BL
adc T6H, BH
adc T8L, CL
adc T8H, CH
rjmp 92f
91: sub T6L, BL
sbc T6H, BH
sbc T8L, CL
sbc T8H, CH
92: lsl BL
rol BH
rol CL
andi BL, 0b11111000
ori BL, 0b00000101
sbrc T8H, 7
subi BL, 2
dec DH
brne 90b
lsr CL
ror BH
ror BL
lsr CL
ror BH
ror BL
.endm
;----------------------------------------------------------------------------;
; Constant Tables
.global tbl_window
tbl_window: ; tbl_window[] = ... (This is a Hamming window)
.dc.w 2621, 2693, 2910, 3270, 3768, 4401, 5161, 6042, 7036, 8132, 9320, 10588, 11926, 13318, 14753, 16216
.dc.w 17694, 19171, 20634, 22069, 23462, 24799, 26068, 27256, 28352, 29345, 30226, 30987, 31619, 32117, 32477, 32694
.dc.w 32766, 32694, 32477, 32117, 31619, 30987, 30226, 29345, 28352, 27256, 26068, 24799, 23462, 22069, 20634, 19171
.dc.w 17694, 16216, 14753, 13318, 11926, 10588, 9320, 8132, 7036, 6042, 5161, 4401, 3768, 3270, 2910, 2693
tbl_cos_sin: ; Table of {cos(x),sin(x)}, (0 <= x < pi, in FFT_N/2 steps)
.dc.w 32767, 0, 32609, 3211, 32137, 6392, 31356, 9511, 30272, 12539, 28897, 15446, 27244, 18204, 25329, 20787
.dc.w 23169, 23169, 20787, 25329, 18204, 27244, 15446, 28897, 12539, 30272, 9511, 31356, 6392, 32137, 3211, 32609
.dc.w 0, 32766, -3211, 32609, -6392, 32137, -9511, 31356, -12539, 30272, -15446, 28897, -18204, 27244, -20787, 25329
.dc.w -23169, 23169, -25329, 20787, -27244, 18204, -28897, 15446, -30272, 12539, -31356, 9511, -32137, 6392, -32609, 3211
tbl_bitrev: ; tbl_bitrev[] = ...
.dc.w 0*4, 32*4, 16*4, 48*4, 8*4, 40*4, 24*4, 56*4, 4*4, 36*4, 20*4, 52*4, 12*4, 44*4, 28*4, 60*4
.dc.w 2*4, 34*4, 18*4, 50*4, 10*4, 42*4, 26*4, 58*4, 6*4, 38*4, 22*4, 54*4, 14*4, 46*4, 30*4, 62*4
;----------------------------------------------------------------------------;
.global fft_input
.func fft_input
fft_input:
pushw T2H,T2L
pushw AH,AL
pushw YH,YL
movw XL, EL ;X = array_src;
movw YL, DL ;Y = array_bfly;
clr EH ;Zero
ldiw ZH,ZL, tbl_window ;Z = &tbl_window[0];
ldiw AH,AL, FFT_N ;A = FFT_N;
1: lpmw BH,BL, Z+ ;B = *Z++; (window)
ldw CH,CL, X+ ;C = *X++; (I-axis)
FMULS16 DH,DL,T2H,T2L, BH,BL, CH,CL ;D = B * C;
stw Y+, DH,DL ;*Y++ = D;
stw Y+, DH,DL ;*Y++ = D;
subiw AH,AL, 1 ;while(--A)
brne 1b ;/
popw YH,YL
popw AH,AL
popw T2H,T2L
clr r1
ret
.endfunc
;----------------------------------------------------------------------------;
.global fft_execute
.func fft_execute
fft_execute:
pushw T2H,T2L
pushw T4H,T4L
pushw T6H,T6L
pushw T8H,T8L
pushw T10H,T10L
pushw T12H,T12L
pushw T14H,T14L
pushw AH,AL
pushw YH,YL
movw ZL, EL ;Z = array_bfly;
ldiw EH,EL, 1 ;E = 1;
ldiw XH,XL, FFT_N/2 ;X = FFT_N/2;
1: ldi AL, 4 ;T12 = E; (angular speed)
mul EL, AL ;
movw T12L, T0L ;
mul EH, AL ;
add T12H, T0L ;/
movw T14L, EL ;T14 = E;
pushw EH,EL
movw YL, ZL ;Z = &array_bfly[0];
mul XL, AL ;Y = &array_bfly[X];
addw YH,YL, T0H,T0L ;
mul XH, AL ;
add YH, T0L ;/
pushw ZH,ZL
2: clrw T10H,T10L ;T10 = 0 (angle)
clr EH ;Zero reg.
3: lddw AH,AL, Z+0 ;A = *Z - *Y; *Z++ += *Y;
asrw AH,AL ;
lddw DH,DL, Y+0 ;
asrw DH,DL ;
movw CL, AL ;
subw AH,AL, DH,DL ;
addw CH,CL, DH,DL ;
stw Z+, CH,CL ;/
lddw BH,BL, Z+0 ;B = *Z - *Y; *Z++ += *Y;
asrw BH,BL ;
lddw DH,DL, Y+2 ;
asrw DH,DL ;
movw CL, BL ;
subw BH,BL, DH,DL ;
addw CH,CL, DH,DL ;
stw Z+, CH,CL ;/
movw T0L, ZL
ldiw ZH,ZL, tbl_cos_sin ;C = cos(T10); D = sin(T10);
addw ZH,ZL, T10H,T10L ;
lpmw CH,CL, Z+ ;
lpmw DH,DL, Z+ ;/
movw ZL, T0L
FMULS16 T4H,T4L,T2H,T2L, AH,AL, CH,CL ;*Y++ = A * C + B * D;
FMULS16 T8H,T8L,T6H,T6L, BH,BL, DH,DL ;
addd T4H,T4L,T2H,T2L, T8H,T8L,T6H,T6L;
stw Y+, T4H,T4L ;/
FMULS16 T4H,T4L,T2H,T2L, BH,BL, CH,CL ;*Y++ = B * C - A * D;
FMULS16 T8H,T8L,T6H,T6L, AH,AL, DH,DL ;
subd T4H,T4L,T2H,T2L, T8H,T8L,T6H,T6L;
stw Y+, T4H,T4L ;/
addw T10H,T10L, T12H,T12L ;T10 += T12; (next angle)
#if FFT_N >= 128
sbrs T10H, FFT_B - 7 ;while(T10 < pi)
#else
sbrs T10L, FFT_B + 1
#endif
rjmp 3b ;/
ldi AL, 4 ;Y += X; Z += X; (skip split segment)
mul XL, AL
addw YH,YL, T0H,T0L ;
addw ZH,ZL, T0H,T0L ;
mul XH, AL ;
add YH, T0L ;
add ZH, T0L ;/
ldi EL, 1 ;while(--T14)
subw T14H,T14L, EH,EL ;
rjne 2b ;/
popw ZH,ZL
popw EH,EL
lslw EH,EL ;E *= 2;
lsrw XH,XL ;while(X /= 2)
adiw XL, 0 ;
rjne 1b ;/
popw YH,YL
popw AH,AL
popw T14H,T14L
popw T12H,T12L
popw T10H,T10L
popw T8H,T8L
popw T6H,T6L
popw T4H,T4L
popw T2H,T2L
; clr r1
ret
.endfunc
;----------------------------------------------------------------------------;
.global fft_output
.func fft_output
fft_output:
pushw T2H,T2L
pushw T4H,T4L
pushw T6H,T6L
pushw T8H,T8L
pushw T10H,T10L
pushw AH,AL
pushw YH,YL
movw T10L, EL ;T10 = array_bfly;
movw YL, DL ;Y = array_output;
ldiw ZH,ZL, tbl_bitrev ;Z = tbl_bitrev;
clr EH ;Zero
ldiw AH,AL, FFT_N / 2 ;A = FFT_N / 2; (plus only)
1: lpmw XH,XL, Z+ ;X = *Z++;
addw XH,XL, T10H,T10L ;X += array_bfly;
ldw BH,BL, X+ ;B = *X++;
ldw CH,CL, X+ ;C = *X++;
FMULS16 T4H,T4L,T2H,T2L, BH,BL, BH,BL ;T4:T2 = B * B;
FMULS16 T8H,T8L,T6H,T6L, CH,CL, CH,CL ;T8:T6 = C * C;
addd T4H,T4L,T2H,T2L, T8H,T8L,T6H,T6L;T4:T2 += T8:T6;
SQRT32 ;B = sqrt(T4:T2);
stw Y+, BH,BL ;*Y++ = B;
subiw AH,AL, 1 ;while(--A)
rjne 1b ;/
popw YH,YL
popw AH,AL
popw T10H,T10L
popw T8H,T8L
popw T6H,T6L
popw T4H,T4L
popw T2H,T2L
clr r1
ret
.endfunc
;----------------------------------------------------------------------------;
.global fmuls_f
.func fmuls_f
fmuls_f:
movw CL, EL ;C = E;
clr EH ;Zero
FMULS16 ZH,ZL,XH,XL, CH,CL, DH,DL ;Z:X = C * D;
movw EL, ZL
clr r1
ret
.endfunc
libraries/Adafruit_CircuitPlayground/utility/talkie.cpp
+167
View File
@@ -0,0 +1,167 @@
// Talkie library
// Copyright 2011 Peter Knight
// This code is released under GPLv2 license.
#include "Adafruit_CPlay_Speaker.h"
#define FS 8000 // Speech engine sample rate
#define TICKS (FS / 40) // Speech data rate
#define USEC ((1000000 + (FS / 2)) / FS) // Sample period (microseconds)
static const int16_t PROGMEM
tmsK1[] = {0x82C0,0x8380,0x83C0,0x8440,0x84C0,0x8540,0x8600,0x8780,
0x8880,0x8980,0x8AC0,0x8C00,0x8D40,0x8F00,0x90C0,0x92C0,
0x9900,0xA140,0xAB80,0xB840,0xC740,0xD8C0,0xEBC0,0x0000,
0x1440,0x2740,0x38C0,0x47C0,0x5480,0x5EC0,0x6700,0x6D40},
tmsK2[] = {0xAE00,0xB480,0xBB80,0xC340,0xCB80,0xD440,0xDDC0,0xE780,
0xF180,0xFBC0,0x0600,0x1040,0x1A40,0x2400,0x2D40,0x3600,
0x3E40,0x45C0,0x4CC0,0x5300,0x5880,0x5DC0,0x6240,0x6640,
0x69C0,0x6CC0,0x6F80,0x71C0,0x73C0,0x7580,0x7700,0x7E80};
static const int8_t PROGMEM
tmsK3[] = {0x92,0x9F,0xAD,0xBA,0xC8,0xD5,0xE3,0xF0,
0xFE,0x0B,0x19,0x26,0x34,0x41,0x4F,0x5C},
tmsK4[] = {0xAE,0xBC,0xCA,0xD8,0xE6,0xF4,0x01,0x0F,
0x1D,0x2B,0x39,0x47,0x55,0x63,0x71,0x7E},
tmsK5[] = {0xAE,0xBA,0xC5,0xD1,0xDD,0xE8,0xF4,0xFF,
0x0B,0x17,0x22,0x2E,0x39,0x45,0x51,0x5C},
tmsK6[] = {0xC0,0xCB,0xD6,0xE1,0xEC,0xF7,0x03,0x0E,
0x19,0x24,0x2F,0x3A,0x45,0x50,0x5B,0x66},
tmsK7[] = {0xB3,0xBF,0xCB,0xD7,0xE3,0xEF,0xFB,0x07,
0x13,0x1F,0x2B,0x37,0x43,0x4F,0x5A,0x66},
tmsK8[] = {0xC0,0xD8,0xF0,0x07,0x1F,0x37,0x4F,0x66},
tmsK9[] = {0xC0,0xD4,0xE8,0xFC,0x10,0x25,0x39,0x4D},
tmsK10[] = {0xCD,0xDF,0xF1,0x04,0x16,0x20,0x3B,0x4D},
chirp[] = {0x00,0x2A,0xD4,0x32,0xB2,0x12,0x25,0x14,
0x02,0xE1,0xC5,0x02,0x5F,0x5A,0x05,0x0F,
0x26,0xFC,0xA5,0xA5,0xD6,0xDD,0xDC,0xFC,
0x25,0x2B,0x22,0x21,0x0F,0xFF,0xF8,0xEE,
0xED,0xEF,0xF7,0xF6,0xFA,0x00,0x03,0x02,0x01};
static const uint8_t PROGMEM
tmsEnergy[] = {0x00,0x02,0x03,0x04,0x05,0x07,0x0A,0x0F,
0x14,0x20,0x29,0x39,0x51,0x72,0xA1,0xFF},
tmsPeriod[] = {0x00,0x10,0x11,0x12,0x13,0x14,0x15,0x16,
0x17,0x18,0x19,0x1A,0x1B,0x1C,0x1D,0x1E,
0x1F,0x20,0x21,0x22,0x23,0x24,0x25,0x26,
0x27,0x28,0x29,0x2A,0x2B,0x2D,0x2F,0x31,
0x33,0x35,0x36,0x39,0x3B,0x3D,0x3F,0x42,
0x45,0x47,0x49,0x4D,0x4F,0x51,0x55,0x57,
0x5C,0x5F,0x63,0x66,0x6A,0x6E,0x73,0x77,
0x7B,0x80,0x85,0x8A,0x8F,0x95,0x9A,0xA0};
static const uint8_t *ptrAddr;
static uint16_t buf;
static uint8_t bufBits;
static inline uint8_t rev(uint8_t a) { // Reverse bit sequence in 8-bit value
a = ( a >> 4) | ( a << 4); // 76543210 -> 32107654
a = ((a & 0xCC) >> 2) | ((a & 0x33) << 2); // 32107654 -> 10325476
a = ((a & 0xAA) >> 1) | ((a & 0x55) << 1); // 10325476 -> 01234567
return a;
}
static uint8_t getBits(uint8_t bits) {
uint8_t value;
if(bits > bufBits) {
buf |= rev(pgm_read_byte(ptrAddr)) << (8 - bufBits);
bufBits += 8;
ptrAddr++; // Don't post-inc in pgm_read_byte! Is a macro.
}
value = buf >> (16 - bits);
buf <<= bits;
bufBits -= bits;
return value;
}
#define read8(base, bits) pgm_read_byte(&base[getBits(bits)]);
#define read16(base, bits) pgm_read_word(&base[getBits(bits)]);
void Adafruit_CPlay_Speaker::say(const uint8_t *addr) {
int16_t x0=0, x1=0, x2=0, x3=0, x4=0,
x5=0, x6=0, x7=0, x8=0, x9=0,
synthK1, synthK2, u0;
uint16_t synthEnergy, synthRand = 1;
int8_t synthK3, synthK4, synthK5, synthK6,
synthK7, synthK8, synthK9, synthK10;
uint8_t periodCounter=0, nextPwm = 0x7F, synthPeriod;
uint8_t iCount = TICKS;
uint32_t nowTime, prevTime=0;
if(!started) begin();
buf = bufBits = 0; // Reset 'ROM' reader (global stuff)
ptrAddr = addr;
for(;;) {
while(((nowTime = micros()) - prevTime) < USEC);
OCR4A = nextPwm;
prevTime = nowTime;
if(++iCount >= TICKS) {
// Read speech data, processing the variable size frames
uint8_t energy;
if((energy = getBits(4)) == 0) { // Rest frame
synthEnergy = 0;
} else if(energy == 0xF) { // Stop frame; silence
TCCR4A = 0x7F;
break;
} else {
synthEnergy = pgm_read_byte(&tmsEnergy[energy]);
uint8_t repeat = getBits(1);
synthPeriod = pgm_read_byte(&tmsPeriod[getBits(6)]);
if(!repeat) { // A repeat frame uses last coefficients
synthK1 = read16(tmsK1, 5); // All frames
synthK2 = read16(tmsK2, 5); // use the first
synthK3 = read8( tmsK3, 4); // 4 coefficients
synthK4 = read8( tmsK4, 4);
if(synthPeriod) {
synthK5 = read8(tmsK5 , 4); // Voiced
synthK6 = read8(tmsK6 , 4); // frames
synthK7 = read8(tmsK7 , 4); // use
synthK8 = read8(tmsK8 , 3); // six
synthK9 = read8(tmsK9 , 3); // extra
synthK10 = read8(tmsK10, 3); // coeffs
}
}
}
iCount = 0;
}
if(synthPeriod) { // Voiced source
if(++periodCounter >= synthPeriod) periodCounter = 0;
u0 = (periodCounter >= sizeof(chirp)) ? 0 :
(pgm_read_byte(&chirp[periodCounter]) *
(uint32_t)synthEnergy) >> 8;
} else { // Unvoiced source
synthRand = (synthRand >> 1) ^ ((synthRand & 1) ? 0xB800 : 0);
u0 = (synthRand & 1) ? synthEnergy : -synthEnergy;
}
u0 -= ((synthK10 * x9) +
(synthK9 * x8)) >> 7;
x9 = x8 + ((synthK9 * u0 ) >> 7);
u0 -= ((synthK8 * x7 ) >> 7);
x8 = x7 + ((synthK8 * u0 ) >> 7);
u0 -= ((synthK7 * x6 ) >> 7);
x7 = x6 + ((synthK7 * u0 ) >> 7);
u0 -= ((synthK6 * x5 ) >> 7);
x6 = x5 + ((synthK6 * u0 ) >> 7);
u0 -= ((synthK5 * x4 ) >> 7);
x5 = x4 + ((synthK5 * u0 ) >> 7);
u0 -= ((synthK4 * x3 ) >> 7);
x4 = x3 + ((synthK4 * u0 ) >> 7);
u0 -= ((synthK3 * x2 ) >> 7);
x3 = x2 + ((synthK3 * u0 ) >> 7);
u0 -= ((synthK2 * (int32_t)x1 ) >> 15);
x2 = x1 + ((synthK2 * (int32_t)u0 ) >> 15);
u0 -= ((synthK1 * (int32_t)x0 ) >> 15);
x1 = x0 + ((synthK1 * (int32_t)u0 ) >> 15);
if( u0 > 511) u0 = 511; // Output clamp
else if(u0 < -512) u0 = -512;
x0 = u0;
nextPwm = (u0 >> 2) + 0x80;
}
}
libraries/Adafruit_Circuit_Playground/Adafruit_CircuitPlayground.cpp
+451
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;
libraries/Adafruit_Circuit_Playground/Adafruit_CircuitPlayground.h
+3
View File
@@ -0,0 +1,3 @@
// this is a placeholder file. dont undo or delete this 'clever hack' :)
#include <Adafruit_Circuit_Playground.h>
libraries/Adafruit_Circuit_Playground/Adafruit_Circuit_Playground.h
+266
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
libraries/Adafruit_Circuit_Playground/CONTRIBUTING.md
+13
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
libraries/Adafruit_Circuit_Playground/Doxyfile
+2492
View File
File diff suppressed because it is too large Load Diff
libraries/Adafruit_Circuit_Playground/README.md
+131
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.
libraries/Adafruit_Circuit_Playground/examples/CircuitPlaygroundFirmata/CircuitPlaygroundFirmata.ino
+1245
View File
File diff suppressed because it is too large Load Diff
libraries/Adafruit_Circuit_Playground/examples/CircuitPlaygroundFirmata_Express_CodeOrg/CircuitPlaygroundFirmata_Express_CodeOrg.ino
+1549
View File
File diff suppressed because it is too large Load Diff
libraries/Adafruit_Circuit_Playground/examples/FidgetSpinner/FidgetSpinner.h
+56
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
libraries/Adafruit_Circuit_Playground/examples/FidgetSpinner/FidgetSpinner.ino
+269
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();
}
libraries/Adafruit_Circuit_Playground/examples/FidgetSpinner/PeakDetector.h
+122
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
libraries/Adafruit_Circuit_Playground/examples/Hello_CircuitPlayground/Hello_Accelerometer/Hello_Accelerometer.ino
+23
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);
}
libraries/Adafruit_Circuit_Playground/examples/Hello_CircuitPlayground/Hello_Blink/Hello_Blink.ino
+12
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);
}
libraries/Adafruit_Circuit_Playground/examples/Hello_CircuitPlayground/Hello_Buttons/Hello_Buttons.ino
+30
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);
}
libraries/Adafruit_Circuit_Playground/examples/Hello_CircuitPlayground/Hello_LightSensor/Hello_LightSensor.ino
+17
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);
}
libraries/Adafruit_Circuit_Playground/examples/Hello_CircuitPlayground/Hello_NeoPixels/Hello_NeoPixels.ino
+25
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);
}
libraries/Adafruit_Circuit_Playground/examples/Hello_CircuitPlayground/Hello_SlideSwitch/Hello_SlideSwitch.ino
+22
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);
}
libraries/Adafruit_Circuit_Playground/examples/Hello_CircuitPlayground/Hello_SoundSensor/Hello_SoundSensor.ino
+18
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);
}
libraries/Adafruit_Circuit_Playground/examples/Hello_CircuitPlayground/Hello_Speaker/Hello_Speaker.ino
+10
View File
@@ -0,0 +1,10 @@
#include <Adafruit_CircuitPlayground.h>
void setup() {
CircuitPlayground.begin();
}
void loop() {
CircuitPlayground.playTone(500, 100);
delay(1000);
}
libraries/Adafruit_Circuit_Playground/examples/Hello_CircuitPlayground/Hello_Temperature/Hello_Temperature.ino
+20
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);
}

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