hexsha stringlengths 40 40 | size int64 7 1.05M | ext stringclasses 13
values | lang stringclasses 1
value | max_stars_repo_path stringlengths 4 269 | max_stars_repo_name stringlengths 5 108 | max_stars_repo_head_hexsha stringlengths 40 40 | max_stars_repo_licenses listlengths 1 9 | max_stars_count int64 1 191k ⌀ | max_stars_repo_stars_event_min_datetime stringlengths 24 24 ⌀ | max_stars_repo_stars_event_max_datetime stringlengths 24 24 ⌀ | max_issues_repo_path stringlengths 4 269 | max_issues_repo_name stringlengths 5 116 | max_issues_repo_head_hexsha stringlengths 40 40 | max_issues_repo_licenses listlengths 1 9 | max_issues_count int64 1 67k ⌀ | max_issues_repo_issues_event_min_datetime stringlengths 24 24 ⌀ | max_issues_repo_issues_event_max_datetime stringlengths 24 24 ⌀ | max_forks_repo_path stringlengths 4 269 | max_forks_repo_name stringlengths 5 116 | max_forks_repo_head_hexsha stringlengths 40 40 | max_forks_repo_licenses listlengths 1 9 | max_forks_count int64 1 105k ⌀ | max_forks_repo_forks_event_min_datetime stringlengths 24 24 ⌀ | max_forks_repo_forks_event_max_datetime stringlengths 24 24 ⌀ | content stringlengths 7 1.05M | avg_line_length float64 1.21 330k | max_line_length int64 6 990k | alphanum_fraction float64 0.01 0.99 | author_id stringlengths 2 40 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
4157bb240e3d2cda3d23e1f4b368b41827d797b2 | 37,664 | cpp | C++ | Image/Gif.cpp | davemc0/DMcTools | 7fa65abc99330c4cc49cf4037cf629051aa516a6 | [
"CC0-1.0"
] | null | null | null | Image/Gif.cpp | davemc0/DMcTools | 7fa65abc99330c4cc49cf4037cf629051aa516a6 | [
"CC0-1.0"
] | null | null | null | Image/Gif.cpp | davemc0/DMcTools | 7fa65abc99330c4cc49cf4037cf629051aa516a6 | [
"CC0-1.0"
] | null | null | null | //////////////////////////////////////////////////////////////////////
// Gif.cpp - Load and save GIF images
//
// Changes Copyright David K. McAllister, Aug. 1997.
// Taken from XV v. 3.10, which was taken from xgif and others 1987-1999.
// As I'm sure you know, the LZW compression contained herein is patented.
// You need to make sure that your use complies with the licensing agreement.
// By the way, I heard the patent expires in 2003.
// Also, don't worry about the unused variable warnings generated
// during compile.
#include "Image/ImageLoadSave.h"
#include "Image/Quant.h"
#include <cstdio>
#include <memory>
typedef unsigned char byte;
#define NEXTBYTE (*dataptr++)
#define EATBYTE (dataptr++)
#define EXTENSION 0x21
#define IMAGESEP 0x2c
#define TRAILER 0x3b
#define INTERLACEMASK 0x40
#define COLORMAPMASK 0x80
static const char* id87 = "GIF87a";
static const char* id89 = "GIF89a";
static int EGApalette[16][3] = {{0, 0, 0}, {0, 0, 128}, {0, 128, 0}, {0, 128, 128}, {128, 0, 0}, {128, 0, 128},
{128, 128, 0}, {200, 200, 200}, {100, 100, 100}, {100, 100, 255}, {100, 255, 100}, {100, 255, 255},
{255, 100, 100}, {255, 100, 255}, {255, 255, 100}, {255, 255, 255}};
/* Fetch the next code from the raster data stream. The codes can be
* any length from 3 to 12 bits, packed into 8-bit bytes, so we have to
* maintain our location in the Raster array as a BIT Offset. We compute
* the byte Offset into the raster array by dividing this by 8, pick up
* three bytes, compute the bit Offset into our 24-bit chunk, shift to
* bring the desired code to the bottom, then mask it off and return it.
*/
/*****************************/
// Info structure filled in by ReadGIF()
class GIFReader {
public:
GIFReader(const std::string& fname_) : fname(fname_) {}
unsigned char* pic; // Image data
int chan;
unsigned char r[256], g[256], b[256]; // Colormap
int BitOffset, // Bit Offset of next code
XC, YC, // Output X and Y coords of current pixel
Pass, // Used by output routine if interlaced pic
OutCount, // Decompressor output 'stack count'
LeftOfs, TopOfs, // Image offset
Width, Height, // Image dimensions
BitsPerPixel, // Bits per pixel, read from GIF header
ColorMapSize, // Number of colors
Background, // Background color
CodeSize, // Code size, read from GIF header
InitCodeSize, // Starting code size, used during Clear
Code, // Value returned by ReadCode
MaxCode, // Limiting value for current code size
ClearCode, // GIF clear code
EOFCode, // GIF end-of-information code
CurCode, OldCode, InCode, // Decompressor variables
FirstFree, // First free code, generated per GIF spec
FreeCode, // Decompressor, next free slot in hash table
FinChar, // Decompressor variable
BitMask, // AND mask for data size
ReadMask, // Code AND mask for current code size
Misc, // Miscellaneous bits (interlace, local cmap)
filesize; // Length of the input file.
const std::string& fname;
bool Interlace, HasColormap, GrayColormap, WantPaletteInds;
byte* RawGIF; // The heap array to hold it, raw
byte* Raster; // The raster data stream, unblocked
byte* pic8;
byte* dataptr;
// TODO: Allocate these on heap to save stack size
// The hash table used by the decompressor
int Prefix[4096];
int Suffix[4096];
// An output array used by the decompressor
int OutCode[4097];
//////////////////////////////
DMC_DECL void gifWarning(const char* st)
{
#ifdef DMC_DEBUG
std::cerr << fname << ": " << st << std::endl;
#endif
}
//////////////////////////////
DMC_DECL int gifError(const char* st)
{
if (RawGIF != NULL) delete[] RawGIF;
if (Raster != NULL) delete[] Raster;
if (pic) delete[] pic;
if (pic8 && pic8 != pic) delete[] pic8;
pic = (byte*)NULL;
throw DMcError(st);
}
//////////////////////////////
DMC_DECL int readCode()
{
int RawCode, ByteOffset;
ByteOffset = BitOffset / 8;
RawCode = Raster[ByteOffset] + (Raster[ByteOffset + 1] << 8);
if (CodeSize >= 8) RawCode += (((int)Raster[ByteOffset + 2]) << 16);
RawCode >>= (BitOffset % 8);
BitOffset += CodeSize;
return (RawCode & ReadMask);
}
//////////////////////////////
DMC_DECL void doInterlace(int Index)
{
static byte* ptr = NULL;
static int oldYC = -1;
if (oldYC != YC) {
ptr = pic8 + YC * Width * chan;
oldYC = YC;
}
if (YC < Height) {
*ptr++ = r[Index];
if (!GrayColormap) {
*ptr++ = g[Index];
*ptr++ = b[Index];
}
}
// Update the X-coordinate, and if it overflows, update the Y-coordinate
if (++XC == Width) {
/* deal with the interlace as described in the GIF
* spec. Put the decoded scan line out to the screen if we haven't gone
* past the bottom of it
*/
XC = 0;
switch (Pass) {
case 0:
YC += 8;
if (YC >= Height) {
Pass++;
YC = 4;
}
break;
case 1:
YC += 8;
if (YC >= Height) {
Pass++;
YC = 2;
}
break;
case 2:
YC += 4;
if (YC >= Height) {
Pass++;
YC = 1;
}
break;
case 3: YC += 2; break;
default: break;
}
}
}
//////////////////////////////
int readImage()
{
byte ch, ch1, *ptr1, *picptr;
int npixels, maxpixels;
npixels = maxpixels = 0;
// Read in values from the image descriptor
ch = NEXTBYTE;
LeftOfs = ch + 0x100 * NEXTBYTE;
ch = NEXTBYTE;
TopOfs = ch + 0x100 * NEXTBYTE;
ch = NEXTBYTE;
Width = ch + 0x100 * NEXTBYTE;
ch = NEXTBYTE;
Height = ch + 0x100 * NEXTBYTE;
Misc = NEXTBYTE;
Interlace = (Misc & INTERLACEMASK) ? true : false;
if (Misc & 0x80) {
GrayColormap = true;
for (int i = 0; i < 1 << ((Misc & 7) + 1); i++) {
r[i] = NEXTBYTE;
g[i] = NEXTBYTE;
b[i] = NEXTBYTE;
GrayColormap = GrayColormap && (r[i] == g[i] && r[i] == b[i]);
std::cerr << i << std::endl;
}
if (WantPaletteInds) {
GrayColormap = true;
for (int i = 0; i < 256; i++) {
// for(i=0; i< 1 << ((Misc&7)+1); i++) {
r[i] = i;
}
}
}
chan = GrayColormap ? 1 : 3;
if (!HasColormap && !(Misc & 0x80)) {
// No global or local colormap */
gifWarning(": No colormap in this GIF file. Assuming EGA colors.\n");
}
// Start reading the raster data. First we get the intial code size
// and compute decompressor constant values, based on this code size.
CodeSize = NEXTBYTE;
ClearCode = (1 << CodeSize);
EOFCode = ClearCode + 1;
FreeCode = FirstFree = ClearCode + 2;
// The GIF spec has it that the code size is the code size used to
// compute the above values is the code size given in the file, but
// the code size used in compression/decompression is the code size
// given in the file plus one. (thus the ++).
CodeSize++;
InitCodeSize = CodeSize;
MaxCode = (1 << CodeSize);
ReadMask = MaxCode - 1;
// UNBLOCK: Read the raster data. Here we just transpose it from the
// GIF array to the Raster array, turning it from a series of blocks
// into one long data stream, which makes life much easier for
// readCode().
ptr1 = Raster;
do {
ch = ch1 = NEXTBYTE;
while (ch--) {
*ptr1 = NEXTBYTE;
ptr1++;
}
if ((dataptr - RawGIF) > filesize) {
gifWarning(": This GIF file seems to be truncated. Winging it.\n");
break;
}
} while (ch1);
#ifdef DMC_DEBUG
std::cerr << "ReadGIF() - picture is " << Width << "x" << Height << ", " << BitsPerPixel << " bits, " << (Interlace ? "" : "non-") << "interlaced\n";
#endif
// Allocate the 'pic' */
maxpixels = Width * Height;
picptr = pic8 = new unsigned char[maxpixels * chan];
// Decompress the file, continuing until you see the GIF EOF
// code. One obvious enhancement is to add checking for corrupt
// files here.
Code = readCode();
while (Code != EOFCode) {
// Clear code sets everything back to its initial value, then
// reads the immediately subsequent code as uncompressed data.
if (Code == ClearCode) {
CodeSize = InitCodeSize;
MaxCode = (1 << CodeSize);
ReadMask = MaxCode - 1;
FreeCode = FirstFree;
Code = readCode();
CurCode = OldCode = Code;
FinChar = CurCode & BitMask;
if (!Interlace) {
*picptr++ = r[FinChar];
// std::cerr << int(FinChar) << '-';
if (!GrayColormap) {
*picptr++ = g[FinChar];
*picptr++ = b[FinChar];
}
} else
doInterlace(FinChar);
npixels++;
} else {
// If not a clear code, must be data: save same as CurCode and InCode
// If we're at maxcode and didn't get a clear, stop loading
if (FreeCode >= 4096) {
gifWarning("freecode blew up");
break;
}
CurCode = InCode = Code;
// If greater or equal to FreeCode, not in the hash table yet; repeat the last character decoded.
if (CurCode >= FreeCode) {
CurCode = OldCode;
if (OutCount > 4096) {
gifWarning("outcount1 blew up");
break;
}
OutCode[OutCount++] = FinChar;
}
// Unless this code is raw data, pursue the chain pointed to by
// CurCode through the hash table to its end; each code in the
// chain puts its associated output code on the output queue.
while (CurCode > BitMask) {
if (OutCount > 4096) break; // Corrupt file
OutCode[OutCount++] = Suffix[CurCode];
CurCode = Prefix[CurCode];
}
if (OutCount > 4096) {
gifWarning("outcount blew up");
break;
}
// The last code in the chain is treated as raw data.
FinChar = CurCode & BitMask;
OutCode[OutCount++] = FinChar;
// Now we put the data out to the Output routine. It's been stacked LIFO, so deal with it that way...
// safety thing: prevent exceeding range of 'pic8'
if (npixels + OutCount > maxpixels) OutCount = maxpixels - npixels;
npixels += OutCount;
if (!Interlace)
for (int i = OutCount - 1; i >= 0; i--) {
*picptr++ = r[OutCode[i]];
// std::cerr << OutCode[i] << '_';
if (!GrayColormap) {
*picptr++ = g[OutCode[i]];
*picptr++ = b[OutCode[i]];
}
}
else
for (int i = OutCount - 1; i >= 0; i--) doInterlace(OutCode[i]);
OutCount = 0;
// Build the hash table on-the-fly. No table is stored in the file.
Prefix[FreeCode] = OldCode;
Suffix[FreeCode] = FinChar;
OldCode = InCode;
// Point to the next slot in the table. If we exceed the current
// MaxCode value, increment the code size unless it's already
// 12. If it is, do nothing: the next code decompressed better
// be CLEAR
FreeCode++;
if (FreeCode >= MaxCode) {
if (CodeSize < 12) {
CodeSize++;
MaxCode *= 2;
ReadMask = (1 << CodeSize) - 1;
}
}
}
Code = readCode();
if (npixels >= maxpixels) break;
}
if (npixels != maxpixels) {
gifWarning(": This GIF file seems to be truncated. Winging it.\n");
if (!Interlace) // clear->EOBuffer */
memset((char*)pic8 + npixels, 0, (size_t)(maxpixels - npixels));
}
pic = pic8;
return 1;
}
//////////////////////////////////////////////////////////////////////
int ReadGIF()
{
// Returns 1 if successful
byte ch, *origptr;
int block;
bool gotimage;
// Initialize variables
BitOffset = XC = YC = Pass = OutCount = 0;
gotimage = false;
RawGIF = Raster = pic8 = NULL;
bool gif89 = false;
pic = NULL;
FILE* fp = fopen(fname.c_str(), "rb");
if (!fp) return (gifError("can't open file"));
// Find the size of the file
fseek(fp, 0L, 2);
filesize = (int)ftell(fp);
fseek(fp, 0L, 0);
// The +256's are so we can read truncated GIF files without fear of seg violation
dataptr = RawGIF = new byte[filesize + 256];
ASSERT_RM(dataptr, "memory alloc failed");
memset(dataptr, 0, filesize + 256);
Raster = new byte[filesize + 256];
ASSERT_RM(Raster, "memory alloc failed");
memset(Raster, 0, filesize + 256);
if (fread(dataptr, (size_t)filesize, (size_t)1, fp) != 1) return (gifError("GIF data read failed"));
fclose(fp);
origptr = dataptr;
if (strncmp((char*)dataptr, id87, (size_t)6) == 0)
gif89 = false;
else if (strncmp((char*)dataptr, id89, (size_t)6) == 0)
gif89 = true;
else
return (gifError("not a GIF file"));
dataptr += 6;
// Get variables from the GIF screen descriptor
EATBYTE;
EATBYTE;
EATBYTE;
EATBYTE;
ch = NEXTBYTE;
HasColormap = (ch & COLORMAPMASK) ? true : false;
BitsPerPixel = (ch & 7) + 1;
ColorMapSize = 1 << BitsPerPixel;
BitMask = ColorMapSize - 1;
Background = NEXTBYTE; // Background color... not used.
EATBYTE;
// Read in global colormap.
if (HasColormap) {
#ifdef DMC_DEBUG
std::cerr << "Reading " << ColorMapSize << " element colormap.\n";
#endif
GrayColormap = true;
for (int i = 0; i < ColorMapSize; i++) {
r[i] = NEXTBYTE;
g[i] = NEXTBYTE;
b[i] = NEXTBYTE;
// std::cerr << i << " " << int(r[i]) << " " << int(g[i]) << " " << int(b[i]) << std::endl;
GrayColormap = GrayColormap && (r[i] == g[i] && r[i] == b[i]);
}
} else { // No colormap in GIF file
// Put std EGA palette (repeated 16 times) into colormap, for lack of anything better to do
GrayColormap = false;
for (int i = 0; i < 256; i++) {
r[i] = EGApalette[i & 15][0];
g[i] = EGApalette[i & 15][1];
b[i] = EGApalette[i & 15][2];
}
}
if (WantPaletteInds) {
GrayColormap = true;
for (int i = 0; i < ColorMapSize; i++) { r[i] = i; }
}
/* possible things at this point are:
* an application extension block
* a comment extension block
* an (optional) graphic control extension block
* followed by either an image
* or a plaintext extension
*/
while (1) {
block = NEXTBYTE;
if (block == EXTENSION) { // Parse extension blocks
int fn, blocksize;
fn = NEXTBYTE; // Read extension block
#ifdef DMC_DEBUG
std::cerr << "GIF extension type 0x%02x\n", fn;
#endif
if (fn == 'R') { // GIF87 aspect extension
blocksize = NEXTBYTE;
if (blocksize == 2) {
EATBYTE;
EATBYTE;
} else {
for (int i = 0; i < blocksize; i++) EATBYTE;
}
int sbsize;
while ((sbsize = NEXTBYTE) > 0) { // Eat any following data subblocks
for (int i = 0; i < sbsize; i++) EATBYTE;
}
} else if (fn == 0xFE) { // Comment Extension
int j, sbsize, cmtlen;
byte* ptr1;
char* sp;
cmtlen = 0;
ptr1 = dataptr; // Remember start of comments
do { // Figure out length of comment
sbsize = NEXTBYTE;
cmtlen += sbsize;
for (j = 0; j < sbsize; j++) EATBYTE;
} while (sbsize);
if (cmtlen > 0) { // Build into one un-blocked comment
char* cmt = new char[cmtlen + 1];
ASSERT_RM(cmt, "memory alloc failed");
sp = cmt;
do {
sbsize = (*ptr1++);
for (j = 0; j < sbsize; j++, sp++, ptr1++) *sp = *ptr1;
} while (sbsize);
*sp = '\0';
std::cerr << "GIF Comment: " << cmt << std::endl;
}
} else if (fn == 0x01) { // PlainText Extension
int j, sbsize;
int tgLeft, tgTop, tgWidth, tgHeight, cWidth, cHeight, fg, bg;
gifWarning("PlainText extension found in GIF file. Ignored.\n");
sbsize = NEXTBYTE;
tgLeft = NEXTBYTE;
tgLeft += (NEXTBYTE) << 8;
tgTop = NEXTBYTE;
tgTop += (NEXTBYTE) << 8;
tgWidth = NEXTBYTE;
tgWidth += (NEXTBYTE) << 8;
tgHeight = NEXTBYTE;
tgHeight += (NEXTBYTE) << 8;
cWidth = NEXTBYTE;
cHeight = NEXTBYTE;
fg = NEXTBYTE;
bg = NEXTBYTE;
for (int i = 12; i < sbsize; i++) EATBYTE; // Read rest of first subblock
#ifdef DMC_DEBUG
std::cerr << "PlainText: tgrid=" << tgLeft << "," << tgTop << " " << tgWidth << "x" << tgHeight << " cell=" << cWidth << "x" << cHeight
<< " col=" << fg << "," << bg << std::endl;
#endif
// Read (and ignore) data sub-blocks
do {
j = 0;
sbsize = NEXTBYTE;
while (j < sbsize) {
EATBYTE;
j++;
}
} while (sbsize);
#ifdef DMC_DEBUG
std::cerr << std::endl << std::endl;
#endif
} else if (fn == 0xF9) { // Graphic Control Extension
int j, sbsize;
gifWarning("Graphic Control Extension in GIF file. Ignored.\n");
// Read (and ignore) data sub-blocks
do {
j = 0;
sbsize = NEXTBYTE;
while (j < sbsize) {
EATBYTE;
j++;
}
} while (sbsize);
} else if (fn == 0xFF) { // Application Extension
int j, sbsize;
gifWarning("Application extension");
// Read (and ignore) data sub-blocks
do {
j = 0;
sbsize = NEXTBYTE;
while (j < sbsize) {
EATBYTE;
j++;
}
} while (sbsize);
} else { // Unknown extension
int j, sbsize;
gifWarning("unknown GIF extension 0x%02x");
// Read (and ignore) data sub-blocks
do {
j = 0;
sbsize = NEXTBYTE;
while (j < sbsize) {
EATBYTE;
j++;
}
} while (sbsize);
}
}
else if (block == IMAGESEP) {
#ifdef DMC_DEBUG
std::cerr << "imagesep (got=" << gotimage << ") at start: offset=" << long(dataptr - RawGIF) << std::endl;
#endif
if (gotimage) { // Just skip over remaining images
// Skip image header
EATBYTE;
EATBYTE; // Left position
EATBYTE;
EATBYTE; // Top position
EATBYTE;
EATBYTE; // Width
EATBYTE;
EATBYTE; // Height
int misc = NEXTBYTE; // Misc. bits
if (misc & 0x80) { // Image has local colormap. skip it
for (int i = 0; i < 1 << ((misc & 7) + 1); i++) {
EATBYTE;
EATBYTE;
EATBYTE;
}
}
EATBYTE; // Minimum code size
// Skip image data sub-blocks
int ch1;
do {
int eatch;
eatch = ch1 = NEXTBYTE;
while (eatch--) EATBYTE;
if ((dataptr - RawGIF) > filesize) break; // EOF
} while (ch1);
} else if (readImage())
gotimage = true;
#ifdef DMC_DEBUG
std::cerr << " at end: dataptr=0x" << long(dataptr - RawGIF) << std::endl;
#endif
}
else if (block == TRAILER) { // Stop reading blocks
#ifdef DMC_DEBUG
std::cerr << "trailer ";
#endif
break;
}
else { // Unknown block type
char str[128];
#ifdef DMC_DEBUG
std::cerr << "block type " << block;
#endif
// Don't mention bad block if file was trunc'd, as it's all bogus
if ((dataptr - origptr) < filesize) {
sprintf(str, "Unknown block type (0x%02x) at offset 0x%lx", block, (long unsigned int)((dataptr - origptr) - 1));
if (!gotimage)
return gifError(str);
else
gifWarning(str);
}
break;
}
#ifdef DMC_DEBUG
std::cerr << std::endl;
#endif
}
delete[] RawGIF;
RawGIF = NULL;
delete[] Raster;
Raster = NULL;
if (!gotimage) return (gifError("no image data found in GIF file"));
#ifdef DMC_DEBUG
std::cerr << std::endl << std::endl;
#endif
return 1;
}
};
//////////////////////////////////////////////////////////////////////
void ImageLoadSave::LoadGIF(const std::string& fname)
{
GIFReader gi(fname);
gi.WantPaletteInds = SP.wantPaletteInds;
int ret = gi.ReadGIF();
if (ret == 0) {
wid = hgt = chan = 0;
Pix = NULL;
throw DMcError("LoadGIF() failed: can't read GIF image file " + std::string(fname));
}
wid = gi.Width;
hgt = gi.Height;
chan = gi.chan;
is_uint = false;
is_float = false;
Pix = ImageAlloc();
memcpy(Pix, gi.pic, size_bytes());
delete[] gi.pic;
}
//////////////////////////////////////////////////////////////////////
// GIF Saving Routines
// Used in output
static unsigned long masks[] = {0x0000, 0x0001, 0x0003, 0x0007, 0x000F, 0x001F, 0x003F, 0x007F, 0x00FF,
0x01FF, 0x03FF, 0x07FF, 0x0FFF, 0x1FFF, 0x3FFF, 0x7FFF, 0xFFFF};
class GIFWriter {
int init_bits;
int EOFCode;
// Number of characters so far in this 'packet'
int a_count;
// Define the storage for the packet accumulator
char accum[256];
// What file we will write to.
FILE* fp;
const char* bname;
//////////////////////////////////////////////////////////////////////
// Set up the 'byte output' routine
DMC_DECL void char_init() { a_count = 0; }
//////////////////////////////////////////////////////////////////////
// Flush the packet to disk, and reset the accumulator
DMC_DECL void flush_char()
{
if (a_count > 0) {
fputc(a_count, fp);
fwrite(accum, (size_t)1, (size_t)a_count, fp);
a_count = 0;
}
}
//////////////////////////////////////////////////////////////////////
// Add a character to the end of the current packet, and if it is 254
// characters, flush the packet to disk.
DMC_DECL void char_out(int c)
{
accum[a_count++] = c;
if (a_count >= 254) flush_char();
}
//////////////////////////////////////////////////////////////////////
// Crap used by the compress routine
unsigned long cur_accum;
int cur_bits;
#define min(a, b) ((a > b) ? b : a)
#define NUM_BITS 12 /* BITS was already defined on some systems */
#define HSIZE 5003 /* 80% occupancy */
typedef long int count_int;
int n_bits; /* number of bits/code */
int maxbits; /* user settable max # bits/code */
int maxcode; /* maximum code, given n_bits */
int maxmaxcode; /* NEVER generate this */
#define MAXCODE(n_bits) ((1 << (n_bits)) - 1)
count_int htab[HSIZE];
unsigned short codetab[HSIZE];
#define HashTabOf(i) htab[i]
#define CodeTabOf(i) codetab[i]
int hsize; /* for dynamic table sizing */
/*
* To save much memory, we overlay the table used by compress() with those
* used by decompress(). The tab_prefix table is the same size and type
* as the codetab. The tab_suffix table needs 2**BITS characters. We
* get this from the beginning of htab. The output stack uses the rest
* of htab, and contains characters. There is plenty of room for any
* possible stack (stack used to be 8000 characters).
*/
#define tab_prefixof(i) CodeTabOf(i)
#define tab_suffixof(i) ((byte*)(htab))[i]
#define de_stack ((byte*)&tab_suffixof(1 << NUM_BITS))
int free_ent; /* first unused entry */
// Block compression parameters -- after all codes are used up,
// and compression rate changes, start over.
int clear_flg;
long int in_count; /* length of input */
long int out_count; /* # of codes output (for debugging) */
void cl_hash(count_int hsize_)
{
for (int i = 0; i < hsize_; i++) htab[i] = -1;
}
/*
* Compress
*
* Algorithm: use open addressing double hashing (no chaining) on the
* prefix code / next character combination. We do a variant of Knuth's
* algorithm D (vol. 3, sec. 6.4) along with G. Knott's relatively-prime
* secondary probe. Here, the modular division first probe gives way
* to a faster exclusive-or manipulation. Also do block compression with
* an adaptive reset, whereby the code table is cleared when the compression
* ratio decreases, but after the table fills. The variable-length output
* codes are re-sized at this point, and a special CLEAR code is generated
* for the decompressor. Late addition: construct the table according to
* file size for noticeable speed improvement on small files. Please direct
* questions about this implementation to ames!jaw.
*/
/*****************************************************************
* Output the given code.
* Inputs:
* code: A n_bits-bit integer. If == -1, then EOF. This assumes
* that n_bits <= (long)wordsize - 1.
*
* Outputs:
* Outputs code to the file.
*
* Algorithm:
* Maintain a BITS character long buffer (so that 8 codes will
* fit in it exactly). Use the VAX insv instruction to insert each
* code in turn. When the buffer fills up empty it and start over.
*/
void output(int code)
{
cur_accum &= masks[cur_bits];
if (cur_bits > 0)
cur_accum |= ((long)code << cur_bits);
else
cur_accum = code;
cur_bits += n_bits;
while (cur_bits >= 8) {
char_out((int)(cur_accum & 0xff));
cur_accum >>= 8;
cur_bits -= 8;
}
/*
* If the next entry is going to be too big for the code size,
* then increase it, if possible.
*/
if (free_ent > maxcode || clear_flg) {
if (clear_flg) {
maxcode = MAXCODE(n_bits = init_bits);
clear_flg = 0;
} else {
n_bits++;
if (n_bits == maxbits)
maxcode = maxmaxcode;
else
maxcode = MAXCODE(n_bits);
}
}
if (code == EOFCode) {
/* At EOF, write the rest of the buffer */
while (cur_bits > 0) {
char_out((int)(cur_accum & 0xff));
cur_accum >>= 8;
cur_bits -= 8;
}
flush_char();
fflush(fp);
ASSERT_RM(!ferror(fp), "unable to write GIF file");
}
}
//////////////////////////////////////////////////////////////////////
void compress(byte* data, int len)
{
long fcode;
int i = 0;
int c;
int ent;
int disp;
int hsize_reg;
int hshift;
// Set up the necessary values
maxbits = NUM_BITS;
maxmaxcode = 1 << NUM_BITS;
memset(htab, 0, sizeof(htab));
memset(codetab, 0, sizeof(codetab));
hsize = HSIZE;
free_ent = 0;
cur_accum = 0;
cur_bits = 0;
out_count = 0;
clear_flg = 0;
in_count = 1;
maxcode = MAXCODE(n_bits = init_bits);
int ClearCode = (1 << (init_bits - 1));
EOFCode = ClearCode + 1;
free_ent = ClearCode + 2;
char_init();
// Translate the byte using lookup table.
ent = *data++;
len--;
hshift = 0;
for (fcode = (long)hsize; fcode < 65536L; fcode *= 2L) hshift++;
hshift = 8 - hshift; /* set hash code range bound */
hsize_reg = hsize;
cl_hash((count_int)hsize_reg); /* clear hash table */
output(ClearCode);
while (len) {
c = *data++;
len--;
in_count++;
fcode = (long)(((long)c << maxbits) + ent);
i = (((int)c << hshift) ^ ent); /* xor hashing */
if (HashTabOf(i) == fcode) {
ent = CodeTabOf(i);
continue;
}
else if ((long)HashTabOf(i) < 0) /* empty slot */
goto nomatch;
disp = hsize_reg - i; /* secondary hash (after G. Knott) */
if (i == 0) disp = 1;
probe:
if ((i -= disp) < 0) i += hsize_reg;
if (HashTabOf(i) == fcode) {
ent = CodeTabOf(i);
continue;
}
if ((long)HashTabOf(i) >= 0) goto probe;
nomatch:
output(ent);
out_count++;
ent = c;
if (free_ent < maxmaxcode) {
CodeTabOf(i) = free_ent++; /* code -> hashtable */
HashTabOf(i) = fcode;
} else {
// Clear out the hash table for block compress.
cl_hash((count_int)hsize);
free_ent = ClearCode + 2;
clear_flg = 1;
output(ClearCode);
}
}
/* Put out the final code */
output(ent);
out_count++;
output(EOFCode);
}
//////////////////////////////
DMC_DECL void putword(int w, FILE* fp_)
{
/* writes a 16-bit integer in GIF order (LSB first) */
fputc(w & 0xff, fp_);
fputc((w >> 8) & 0xff, fp_);
}
public:
//////////////////////////////////////////////////////////////////////
void WriteGIF(const std::string& fname, int wid, int hgt, byte* Pix, bool isOneChan, LoadSaveParams SP)
{
int size = wid * hgt;
if ((fp = fopen(fname.c_str(), "wb")) == 0) throw DMcError("WriteGIF() failed: can't write GIF image file " + std::string(fname));
int ColorMapSize, InitCodeSize, BitsPerPixel;
// Fill in the 8-bit image and the color map somehow
Quantizer<uc3Pixel, unsigned char> Qnt((uc3Pixel*)Pix, size, isOneChan, SP.QP);
byte* pic8 = Qnt.GetIndexImage(); // It allocates pic8; I delete it.
size_t NumColors = Qnt.GetColorMap().size();
// Compute BitsPerPixel
for (BitsPerPixel = 1; BitsPerPixel < 8; BitsPerPixel++) {
if (size_t(1ull << BitsPerPixel) >= NumColors) break;
}
ColorMapSize = 1 << BitsPerPixel;
if (BitsPerPixel <= 1)
InitCodeSize = 2;
else
InitCodeSize = BitsPerPixel;
fwrite(id89, (size_t)1, (size_t)6, fp); // The GIF magic number (can use id87 if no comment)
putword(wid, fp); // Screen descriptor
putword(hgt, fp);
int code = 0x80; // Yes, there is a color map
code |= (8 - 1) << 4; // OR in the color resolution (hardwired 8)
code |= (BitsPerPixel - 1); // OR in the # of bits per pixel
fputc(code, fp);
int Background = 0;
fputc(Background, fp); // Background color
fputc(0, fp); // Future expansion byte
// Write the colormap
int i = 0;
for (i = 0; i < NumColors && i < ColorMapSize; i++) {
// std::cerr << Qnt.GetColorMap()[i] << '\n';
fputc(Qnt.GetColorMap()[i].r(), fp);
fputc(Qnt.GetColorMap()[i].g(), fp);
fputc(Qnt.GetColorMap()[i].b(), fp);
}
for (; i < ColorMapSize; i++) {
fputc(0, fp);
fputc(0, fp);
fputc(0, fp);
}
if (!SP.comment.empty()) { // Write comment blocks
int blen;
fputc(0x21, fp); // EXTENSION block
fputc(0xFE, fp); // Comment extension
const char* sp = SP.comment.c_str();
while ((blen = int(strlen(sp))) > 0) {
if (blen > 255) blen = 255;
fputc(blen, fp);
for (int j = 0; j < blen; j++, sp++) fputc(*sp, fp);
}
fputc(0, fp); // Zero-length data subblock to end extension
}
fputc(',', fp); // Image separator
// Write the Image header
putword(0, fp); // LeftOfs
putword(0, fp); // TopOfs
putword(wid, fp);
putword(hgt, fp);
fputc(0x00, fp); // Global colormap, no interlace.
fputc(InitCodeSize, fp);
init_bits = InitCodeSize + 1;
compress(pic8, wid * hgt); // Write the compressed pixel data
fputc(0, fp); // Write out a Zero-length packet (EOF)
fputc(';', fp); // Write GIF file terminator
delete[] pic8;
if (ferror(fp)) {
fclose(fp);
throw DMcError("File error in WriteGIF()");
}
fclose(fp);
}
};
void ImageLoadSave::SaveGIF(const std::string& fname) const
{
if (Pix == NULL || chan < 1 || wid < 1 || hgt < 1) { throw DMcError("Image is empty. Not saving."); }
if (chan != 1 && chan != 3) throw DMcError(std::string("Can't save a ") + std::to_string(chan) + " channel image as a GIF.");
GIFWriter gw; // TODO: gw uses a lot of stack
gw.WriteGIF(fname, wid, hgt, (unsigned char*)Pix, chan == 1, SP);
}
| 32.751304 | 157 | 0.463812 | davemc0 |
415837581f6014c260c7549b3959af48aa0e12fa | 13,090 | cpp | C++ | Analysis/AnalysisOrg/justBeadFind/justBeadFind.cpp | konradotto/TS | bf088bd8432b1e3f4b8c8c083650a30d9ef2ae2e | [
"Apache-2.0"
] | 125 | 2015-01-22T05:43:23.000Z | 2022-03-22T17:15:59.000Z | Analysis/AnalysisOrg/justBeadFind/justBeadFind.cpp | konradotto/TS | bf088bd8432b1e3f4b8c8c083650a30d9ef2ae2e | [
"Apache-2.0"
] | 59 | 2015-02-10T09:13:06.000Z | 2021-11-11T02:32:38.000Z | Analysis/AnalysisOrg/justBeadFind/justBeadFind.cpp | konradotto/TS | bf088bd8432b1e3f4b8c8c083650a30d9ef2ae2e | [
"Apache-2.0"
] | 98 | 2015-01-17T01:25:10.000Z | 2022-03-18T17:29:42.000Z | /* Copyright (C) 2010 Ion Torrent Systems, Inc. All Rights Reserved */
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <armadillo>
#include <fenv.h> // Floating point exceptions
#include "CommandLineOpts.h"
#include "OptBase.h"
#include "Mask.h"
#include "Region.h"
#include "SeqList.h"
#include "TrackProgress.h"
#include "SlicedPrequel.h"
#include "SeparatorInterface.h"
#include "SetUpForProcessing.h"
#include "IonErr.h"
#include "ImageSpecClass.h"
#include "MaskFunctions.h"
void PrintHelp()
{
printf ("\n");
printf ("Usage: justBeadFind [options] [dat-source-directory]\n");
printf ("\n");
printf ("[dat-source-directory]: if there is no option --dat-source-directory, this directory string must be the last one in the commandline\n");
printf ("General options:(VECTOR input must be comma separated string)\n");
printf (" -h,--help print this help message and exit\n");
printf (" -v,--version print version and exit\n");
printf (" --region-list INT VECTOR OF 4 region list for SlicedPrequel setup []\n");
printf ("\n");
CommandLineOpts cmdOpts;
cmdOpts.PrintHelp();
printf ("\n");
exit (EXIT_SUCCESS);
}
void DumpStartingStateOfProgram (int argc, char *argv[], TrackProgress &my_progress)
{
char myHostName[128] = { 0 };
gethostname (myHostName, 128);
fprintf (stdout, "\n");
fprintf (stdout, "Hostname = %s\n", myHostName);
fprintf (stdout, "Start Time = %s", ctime (&my_progress.analysis_start_time));
fprintf (stdout, "Version = %s.%s (%s) (%s)\n",
IonVersion::GetVersion().c_str(), IonVersion::GetRelease().c_str(),
IonVersion::GetGitHash().c_str(), IonVersion::GetBuildNum().c_str());
fprintf (stdout, "Command line = ");
for (int i = 0; i < argc; i++)
fprintf (stdout, "%s ", argv[i]);
fprintf (stdout, "\n");
fflush (NULL);
}
void TheSilenceOfTheArmadillos(ofstream &null_ostream)
{
// Disable armadillo warning messages.
arma::set_stream_err1(null_ostream);
arma::set_stream_err2(null_ostream);
}
int TrapAndDeprecateOldArgs(int argc, char *argv[], char *argv2[])
{
int datind = -1;
for(int i = 1; i < argc; ++i)
{
string s = argv[i];
int index = s.find("--dat-source-directory");
if(index == 0)
{
datind = i;
}
}
//jz check to see if the last argument is dat_source_directory
if(datind < 0) // there is no "--dat-source-directory"
{
if(argc > 1) // must have arg
{
if(argv[argc - 1][0] == '-')
{
string s = argv[argc - 1];
if(s != "-h" && s != "-v" && s != "--help" && s != "--version")
{
delete [] argv2;
cerr << "ERROR: dat_source_directory must be provided at the end of the command line." << endl;
exit ( EXIT_FAILURE );
}
}
if(argc != 2)
{
if(argc == 3) // 2 args
{
if(argv[argc - 2][0] != '-') // not option + dat_source_directory
{
delete [] argv2;
cerr << "ERROR: both arguments of the command line are not option name. The last argument must be dat_source_directory and the other one must be an option." << endl;
exit ( EXIT_FAILURE );
}
else
{
string s = argv[argc - 2];
int index = s.find("=");
if(index < 0)
{
delete [] argv2;
cerr << "ERROR: the last argument must be dat_source_directory and the other one must be an option with assignment value." << endl;
exit ( EXIT_FAILURE );
}
}
}
else
{
if(argv[argc - 2][0] == '-')
{
string s = argv[argc - 2];
int index = s.find("=");
if(index < 0)
{
delete [] argv2;
cerr << "ERROR: the last argument must be dat_source_directory and the second last one must be an option with assignment value." << endl;
exit ( EXIT_FAILURE );
}
}
}
}
}
}
for(int i = 0; i < argc; ++i)
{
size_t slen0 = strlen(argv[i]) + 1;
string s0 = argv[i];
int index0 = s0.find("--region-size");
if(index0 == 0)
{
if(s0 == "--region-size")
{
argv2[i] = new char[slen0];
memcpy(argv2[i], argv[i], slen0);
++i;
if(i >= argc)
{
for(int k = 0; k <= i ; ++k)
{
delete [] argv2[k];
}
delete [] argv2;
cerr << "*ERROR* - Region-size option must be followed by a value." << endl;
exit ( EXIT_FAILURE );
}
string s1 = argv[i];
int index1 = s1.find("x");
if(index1 > 0)
{
cout << "*WARNING* - You are using a deprecated format of region-size value. Please change " << s1 << " to ";
s1.replace(index1, 1, ",");
cout << s1 << endl;
}
int slen1 = strlen(argv[i]) + 1;
argv2[i] = new char[slen1];
sprintf(argv2[i], "%s", s1.c_str());
}
else
{
int index2 = s0.find("x");
if(index2 > 0)
{
cout << "*WARNING* - You are using a deprecated format of region-size value. Please change " << s0 << " to ";
s0.replace(index2, 1, ",");
cout << s0 << endl;
}
argv2[i] = new char[slen0];
sprintf(argv2[i], "%s", s0.c_str());
}
}
else if(s0 == "on")
{
cout << "*WARNING* - You are using a deprecated format of " << argv[i - 1] << " value. Please change on to true." << endl;
argv2[i] = new char[5];
sprintf(argv2[i], "true");
}
else if(s0 == "off")
{
cout << "*WARNING* - You are using a deprecated format of " << argv[i - 1] << " value. Please change off to false." << endl;
argv2[i] = new char[6];
sprintf(argv2[i], "false");
}
else
{
int indexon = s0.find("=on");
int indexoff = s0.find("=off");
if(indexon > 0 && indexon == ((int)(s0.length()) - 3))
{
cout << "*WARNING* - You are using a deprecated format of " << argv[i] << ". Please change on to true as ";
string s3 = s0.substr(0, s0.length() - 2);
s3 += "true";
int slen3 = s3.length() + 1;
argv2[i] = new char[slen3];
sprintf(argv2[i], "%s", s3.c_str());
cout << argv2[i] << endl;
}
else if(indexoff > 0 && indexoff == ((int)(s0.length()) - 4))
{
cout << "*WARNING* - You are using a deprecated format of " << argv[i] << ". Please change off to false as ";
string s4 = s0.substr(0, s0.length() - 3);
s4 += "false";
int slen4 = s4.length() + 1;
argv2[i] = new char[slen4];
sprintf(argv2[i], "%s", s4.c_str());
cout << argv2[i] << endl;
}
else
{
argv2[i] = new char[slen0];
memcpy( argv2[i], argv[i], slen0);
}
}
// convert long option to lower case
string s5 = argv2[i];
int index5 = s5.find("--");
int index6 = s5.find("=");
if(0 == index5)
{
if(index6 < 2)
{
index6 = strlen(argv2[i]) + 1;
}
for(int j = 2; j < index6; ++j)
{
argv2[i][j] = tolower (argv2[i][j]);
}
}
}
return datind;
}
void LoadArgsJson(const string& argsJsonFile, Json::Value& json_params, bool thumbnail)
{
Json::Value json_params0;
ifstream ifs(argsJsonFile.c_str());
Json::Reader reader;
reader.parse(ifs, json_params0, false);
ifs.close();
Json::Value json_tn;
Json::Value::Members groups = json_params0.getMemberNames();
for(Json::Value::Members::iterator it1 = groups.begin(); it1 != groups.end(); ++it1)
{
if(*it1 == "chipType")
{
json_params["chipType"] = json_params0["chipType"];
}
else if(*it1 == "ThumbnailControl")
{
if(thumbnail)
{
Json::Value::Members items = json_params0[*it1].getMemberNames();
for(Json::Value::Members::iterator it2 = items.begin(); it2 != items.end(); ++it2)
{
string sname(*it2);
for(size_t i = 0; i < sname.size(); ++i)
{
if(sname[i] == '-')
{
sname[i] = '_';
}
}
json_tn[sname] = json_params0[*it1][*it2];
}
}
}
else
{
Json::Value::Members items = json_params0[*it1].getMemberNames();
for(Json::Value::Members::iterator it2 = items.begin(); it2 != items.end(); ++it2)
{
string sname(*it2);
for(size_t i = 0; i < sname.size(); ++i)
{
if(sname[i] == '-')
{
sname[i] = '_';
}
}
json_params[sname] = json_params0[*it1][*it2];
}
}
}
if(thumbnail)
{
Json::Value::Members items = json_tn.getMemberNames();
for(Json::Value::Members::iterator it2 = items.begin(); it2 != items.end(); ++it2)
{
string sname(*it2);
if(json_params.isMember(sname))
{
json_params[sname] = json_tn[*it2];
}
}
}
}
/*************************************************************************************************
*************************************************************************************************
*
* Start of Main Function
*
*************************************************************************************************
************************************************************************************************/
int main (int argc, char *argv[])
{
init_salute();
ofstream null_ostream("/dev/null"); // must stay live for entire scope, or crash when writing
TheSilenceOfTheArmadillos(null_ostream);
TrackProgress my_progress;
DumpStartingStateOfProgram (argc,argv,my_progress);
if(argc < 2)
{
PrintHelp();
}
for(int i = 1; i < argc; ++i)
{
string s = argv[i];
if(s == "-" || s == "--")
{
cerr << "ERROR: command line input \"-\" must be followed by a short option name (a letter) and \"--\" must be followed by a long option name." << endl;
exit ( EXIT_FAILURE );
}
else if(s == "-?" || s == "-h" || s == "--help")
{
PrintHelp();
}
}
ValidateOpts validater;
validater.Validate(argc, argv);
char** argv2 = new char*[argc];
int datind = TrapAndDeprecateOldArgs(argc, argv, argv2);
OptArgs opts;
opts.ParseCmdLine(argc, (const char**)argv2);
// enable floating point exceptions during program execution
if (opts.GetFirstBoolean('-', "float-exceptions", false)) {
cout << "JustBeadFind: Floating point exceptions enabled." << endl;
feenableexcept(FE_DIVBYZERO | FE_INVALID | FE_OVERFLOW);
} //*/
for(int k = 0; k < argc ; ++k)
{
delete [] argv2[k];
}
delete [] argv2;
Json::Value json_params;
bool thumbnail = opts.GetFirstBoolean('-', "thumbnail", false);
string argsJsonFile = opts.GetFirstString('-', "args-json", "");
if(argsJsonFile.length() > 0)
{
struct stat sb0;
if(!(stat(argsJsonFile.c_str(), &sb0) == 0 && S_ISREG(sb0.st_mode)))
{
cerr << "ERROR: " << argsJsonFile << " does not exist or it is not a regular file." << endl;
exit ( EXIT_FAILURE );
}
LoadArgsJson(argsJsonFile, json_params, thumbnail);
}
else
{
cerr << "ERROR: --args-json must be provided." << endl;
exit ( EXIT_FAILURE );
}
CommandLineOpts inception_state;
inception_state.SetOpts(opts, json_params);
inception_state.bfd_control.SetThumbnail(thumbnail);
if(datind < 0) // there is no "--dat-source-directory"
{
inception_state.sys_context.dat_source_directory = argv[argc - 1];
cout << "dat_source_directory = " << inception_state.sys_context.dat_source_directory << endl;
}
struct stat sb;
if(!(stat(inception_state.sys_context.dat_source_directory, &sb) == 0 && S_ISDIR(sb.st_mode)))
{
cerr << "ERROR: " << inception_state.sys_context.dat_source_directory << " does not exist or it is not a directory." << endl;
exit ( EXIT_FAILURE );
}
string chipType = GetParamsString(json_params, "chipType", "");
ChipIdDecoder::SetGlobalChipId ( chipType.c_str() );
SeqListClass my_keys;
ImageSpecClass my_image_spec;
SlicedPrequel my_prequel_setup;
SetUpOrLoadInitialState(inception_state, my_keys, my_progress, my_image_spec, my_prequel_setup);
// Start logging process parameters & timing now that we have somewhere to log
my_progress.InitFPLog(inception_state);
// Write processParameters.parse file now that processing is about to begin
my_progress.WriteProcessParameters(inception_state);
// Do separator
Region wholeChip(0, 0, my_image_spec.cols, my_image_spec.rows);
IsolatedBeadFind( my_prequel_setup, my_image_spec, wholeChip, inception_state,
inception_state.sys_context.GetResultsFolder(), inception_state.sys_context.analysisLocation, my_keys, my_progress, chipType);
exit (EXIT_SUCCESS);
}
| 29.088889 | 172 | 0.542857 | konradotto |
41590d3bfbc2eafda2fc5badcc2fd7423609d8a5 | 22,120 | cpp | C++ | video/common/Processing/jhcDist.cpp | jconnell11/ALIA | f7a6c9dfd775fbd41239051aeed7775adb878b0a | [
"Apache-2.0"
] | 1 | 2020-03-01T13:22:34.000Z | 2020-03-01T13:22:34.000Z | video/common/Processing/jhcDist.cpp | jconnell11/ALIA | f7a6c9dfd775fbd41239051aeed7775adb878b0a | [
"Apache-2.0"
] | null | null | null | video/common/Processing/jhcDist.cpp | jconnell11/ALIA | f7a6c9dfd775fbd41239051aeed7775adb878b0a | [
"Apache-2.0"
] | 1 | 2020-07-30T10:24:58.000Z | 2020-07-30T10:24:58.000Z | // jhcDist.cpp : spreading activation like space claiming
//
// Written by Jonathan H. Connell, jconnell@alum.mit.edu
//
///////////////////////////////////////////////////////////////////////////
//
// Copyright 1999-2016 IBM Corporation
//
// 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
// 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.
//
///////////////////////////////////////////////////////////////////////////
#include <math.h>
#include "Interface/jhcMessage.h"
#include "Processing/jhcDist.h"
///////////////////////////////////////////////////////////////////////////
// Manhattan Distance //
///////////////////////////////////////////////////////////////////////////
//= Claim "empty" pixels for nearest "seed" based on Manhattan metric.
// when two seeds are equidistant, higher label dominates
// default version for labels of 16 bits (2 fields) and 16 bit distances
int jhcDist::Nearest (jhcImg& label, const jhcImg& seed, int bg, jhcImg *rng)
{
jhcImg *dist = rng;
// check size and special cases, possibly make up scratch array
if (label.Valid(1))
return Nearest8(label, seed, bg, rng);
if (!label.Valid(2) || !label.SameFormat(seed) || label.SameImg(seed))
return Fatal("Bad images to jhcDist::Nearest");
if ((dist != NULL) && !label.SameSize(*dist))
return Fatal("Bad range image to jhcDist::Nearest");
if (dist == NULL)
dist = a2.SetSize(seed);
label.CopyRoi(seed);
dist->CopyRoi(seed);
// set up iteration variables
int x, y, rw = seed.RoiW(), rh = seed.RoiH();
US16 cnt, last, bval = (US16) bg;
UL32 roff = seed.RoiOff(), rsk = seed.Line() >> 1;
US16 *s1, *s = (US16 *)(seed.PxlSrc() + roff);
US16 *d, *d0 = (US16 *)(dist->PxlSrc() + roff);
US16 *n, *n0 = (US16 *)(label.PxlSrc() + roff);
// PASS 1: find nearest neighbor and distance in horizontal direction
d = d0;
n = n0;
for (y = rh; y > 0; y--)
{
// right wipe, extend last label and increment distance
s1 = s;
cnt = 0;
last = bval;
for (x = rw; x > 0; x--)
{
if (last != bval)
cnt++;
if (*s != bval)
{
last = *s;
cnt = 0;
}
s++;
*n++ = last;
*d++ = cnt;
}
// left wipe, extend last label if better and increment distance
cnt = 0;
last = bval;
for (x = rw; x > 0; x--)
{
n--;
d--;
if (last != bval)
cnt++;
if ((*n != bval) && (*d == 0))
{
last = *n;
cnt = 0;
}
if ((last != bval) &&
((*n == bval) || (*d > cnt) || ((*d == cnt) && (last > *n))))
{
*n = last;
*d = cnt;
}
}
// set up for next line
s = s1 + rsk;
d += rsk;
n += rsk;
}
// PASS2: find nearest neighbor and distance in vertical direction
d = d0;
n = n0;
for (x = rw; x > 0; x--)
{
// down wipe, extend last label if better and reset distance
cnt = 0;
last = bval;
for (y = rh; y > 0; y--)
{
if (last != bval)
cnt++;
if ((*n != bval) && ((last == bval) || (*d <= cnt)))
{
last = *n;
cnt = *d;
}
if ((last != bval) &&
((*n == bval) || (*d > cnt) || ((*d == cnt) && (last > *n))))
{
*n = last;
*d = cnt;
}
n += rsk;
d += rsk;
}
// up wipe, extend last label if better and reset distance
cnt = 0;
last = bval;
for (y = rh; y > 0; y--)
{
n -= rsk;
d -= rsk;
if (last != bval)
cnt++;
if ((*n != bval) && ((last == bval) || (*d <= cnt)))
{
last = *n;
cnt = *d;
}
if ((last != bval) &&
((*n == bval) || (*d > cnt) || ((*d == cnt) && (last > *n))))
{
*n = last;
*d = cnt;
}
}
// set up for next column
n++;
d++;
}
return 1;
}
//= Same as Nearest but specialized for 8 bit labels and distances (saturated).
// when two seeds are equidistant, higher label dominates
int jhcDist::Nearest8 (jhcImg& label, const jhcImg& seed, int bg, jhcImg *rng)
{
jhcImg *dist = rng;
// check image sizes, possibly make up scratch array
if (!label.Valid(1) || !label.SameFormat(seed) || label.SameImg(seed))
return Fatal("Bad images to jhcDist::Nearest8");
if ((dist != NULL) && !label.SameSize(*dist))
return Fatal("Bad range image to jhcDist::Nearest8");
if (dist == NULL)
dist = a1.SetSize(seed);
label.CopyRoi(seed);
dist->CopyRoi(seed);
// set up iteration variables
int x, y, rw = seed.RoiW(), rh = seed.RoiH();
UC8 cnt, last, bval = BOUND(bg);
UL32 roff = seed.RoiOff(), rsk = seed.Line();
const UC8 *s1, *s = seed.PxlSrc() + roff;
UC8 *d, *d0 = dist->PxlDest() + roff;
UC8 *n, *n0 = label.PxlDest() + roff;
// PASS 1: find nearest neighbor and distance in horizontal direction
d = d0;
n = n0;
for (y = rh; y > 0; y--)
{
// right wipe, extend last label and increment distance
s1 = s;
cnt = 0;
last = bval;
for (x = rw; x > 0; x--)
{
if ((last != bval) && (cnt < 255))
cnt++;
if (*s != bval)
{
last = *s;
cnt = 0;
}
s++;
*n++ = last;
*d++ = cnt;
}
// left wipe, extend last label if better and increment distance
cnt = 0;
last = bval;
for (x = rw; x > 0; x--)
{
n--;
d--;
if ((last != bval) && (cnt < 255))
cnt++;
if ((*n != bval) && (*d == 0))
{
last = *n;
cnt = 0;
}
if ((last != bval) &&
((*n == bval) || (*d > cnt) || ((*d == cnt) && (last > *n))))
{
*n = last;
*d = cnt;
}
}
// set up for next line
s = s1 + rsk;
d += rsk;
n += rsk;
}
// PASS2: find nearest neighbor and distance in vertical direction
d = d0;
n = n0;
for (x = rw; x > 0; x--)
{
// down wipe, extend last label if better and reset distance
cnt = 0;
last = bval;
for (y = rh; y > 0; y--)
{
if ((last != bval) && (cnt < 255))
cnt++;
if ((*n != bval) && ((last == bval) || (*d <= cnt)))
{
last = *n;
cnt = *d;
}
if ((last != bval) &&
((*n == bval) || (*d > cnt) || ((*d == cnt) && (last > *n))))
{
*n = last;
*d = cnt;
}
n += rsk;
d += rsk;
}
// up wipe, extend last label if better and reset distance
cnt = 0;
last = bval;
for (y = rh; y > 0; y--)
{
n -= rsk;
d -= rsk;
if ((last != bval) && (cnt < 255))
cnt++;
if ((*n != bval) && ((last == bval) || (*d <= cnt)))
{
last = *n;
cnt = *d;
}
if ((last != bval) &&
((*n == bval) || (*d > cnt) || ((*d == cnt) && (last > *n))))
{
*n = last;
*d = cnt;
}
}
// set up for next column
n++;
d++;
}
return 1;
}
//= Extend each blob over background regions by dmax at most.
int jhcDist::Expand (jhcImg& label, const jhcImg& seed, int dmax, int bg)
{
if (!label.Valid(1, 2) || !label.SameFormat(seed) || (dmax < 0) || (dmax > 255))
return Fatal("Bad range image to jhcDist::Expand");
// get claims and ranges (exploit a1 and a2 from inside Nearest)
Nearest(label, seed, bg);
if (label.Valid(2))
{
a1.SetSize(seed);
a1.Sat8(a2);
}
// local variables
int x, y, rw = label.RoiW(), rh = label.RoiH();
int nsk = label.RoiSkip() >> 1, dsk = a1.RoiSkip(label);
const UC8 *d = a1.RoiSrc(label);
US16 *n = (US16 *) label.RoiDest();
// invalidate any labels that are too far away
for (y = rh; y > 0; y--, n += nsk, d += dsk)
for (x = rw; x > 0; x--, n++, d++)
if (*d > dmax)
*n = (US16) bg;
return 1;
}
///////////////////////////////////////////////////////////////////////////
// Euclidean Distance //
///////////////////////////////////////////////////////////////////////////
//= Version of nearest seed claims using Euclidean distance.
// when two seeds are equidistant, higher label dominates
// default version for labels of 16 bits (2 fields) and 16 bit distances
// about 3x slower than Nearest (5x if distance is returned)
int jhcDist::Voronoi (jhcImg& label, const jhcImg& seed, int bg, jhcImg *rng,
jhcImg *xrng, jhcImg *yrng, jhcImg *rng2)
{
jhcImg *dist = rng, *xdist = xrng, *ydist = yrng, *sqdist = rng2;
// check image sizes, possibly make up scratch arrays
if (label.Valid(1))
return Voronoi8(label, seed, bg, rng, xrng, yrng, rng2);
if (!label.Valid(2) || !label.SameFormat(seed) || label.SameImg(seed))
return Fatal("Bad images to jhcDist::Voronoi");
if (((dist != NULL) && !label.SameFormat(*dist)) ||
((xdist != NULL) && !label.SameFormat(*xdist)) ||
((ydist != NULL) && !label.SameFormat(*ydist)) ||
((sqdist != NULL) && !label.SameSize(*sqdist, 4)))
return Fatal("Bad auxilliary images to jhcDist::Voronoi");
if (xdist == NULL)
xdist = a2.SetSize(seed);
if (ydist == NULL)
ydist = b2.SetSize(seed);
if (sqdist == NULL)
sqdist = a4.SetSize(seed, 4);
label.CopyRoi(seed);
xdist->CopyRoi(seed);
ydist->CopyRoi(seed);
sqdist->CopyRoi(seed);
// set up iteration variables
int x, y, rw = seed.RoiW(), rh = seed.RoiH();
US16 dx, dy, last, bval = (US16) bg;
UL32 dx2, dy2, r2, roff = seed.RoiOff();
UL32 rsk = seed.Line() >> 1, dsk = sqdist->Line() >> 2;
UL32 *dsq, *dsq0 = (UL32 *)(sqdist->PxlSrc() + sqdist->RoiOff());
US16 *s1, *s = (US16 *)(seed.PxlSrc() + roff);
US16 *n, *n0 = (US16 *)(label.PxlSrc() + roff);
US16 *d, *xoff, *xoff0 = (US16 *)(xdist->PxlSrc() + roff);
US16 *yoff, *yoff1, *yoff0 = (US16 *)(ydist->PxlSrc() + roff);
// PASS 1: find nearest neighbor and distance in horizontal direction
n = n0;
xoff = xoff0;
yoff = yoff0;
dsq = dsq0;
for (y = rh; y > 0; y--)
{
// right wipe, extend last label and increment distance
s1 = s;
yoff1 = yoff;
last = bval;
for (x = rw; x > 0; x--)
{
if (*s != bval)
{
dx = 0;
last = *s;
*n = last;
*xoff = 0;
*yoff = 0;
*dsq = 0;
}
else if (last != bval)
{
dx++;
*n = last;
*xoff = dx;
*yoff = 0;
*dsq = dx * dx;
}
else
{
*n = bval;
*xoff = 0;
*yoff = 0;
*dsq = 0;
}
s++;
n++;
xoff++;
yoff++;
dsq++;
}
// left wipe, extend last label if better and increment distance
last = bval;
for (x = rw; x > 0; x--)
{
n--;
xoff--;
dsq--;
if ((*n != bval) && (*xoff == 0))
{
dx = 0;
last = *n;
}
else if (last != bval)
{
dx++;
if ((*n == bval) || (*xoff > dx) || ((*xoff == dx) && (last > *n)))
{
*n = last;
*xoff = dx;
*dsq = dx * dx;
}
}
}
// set up for next line
s = s1 + rsk;
n += rsk;
xoff += rsk;
yoff = yoff1 + rsk;
dsq += dsk;
}
// PASS2: find nearest neighbor and distance in vertical direction
n = n0;
xoff = xoff0;
yoff = yoff0;
dsq = dsq0;
for (x = rw; x > 0; x--)
{
// down wipe, extend last label if better and reset distance
last = bval;
for (y = rh; y > 0; y--)
{
if ((*n != bval) && ((last == bval) || (*dsq <= r2)))
{
last = *n;
dx = *xoff;
dx2 = dx * dx;
dy = *yoff;
r2 = *dsq;
}
else if (last != bval)
{
dy++;
dy2 = dy * dy;
r2 = dx2 + dy2;
}
if ((last != bval) &&
((*n == bval) || (*dsq > r2) || ((*dsq == r2) && (last > *n))))
{
*n = last;
*xoff = dx;
*yoff = dy;
*dsq = r2;
}
n += rsk;
xoff += rsk;
yoff += rsk;
dsq += dsk;
}
// up wipe, extend last label if better and reset distance
last = bval;
for (y = rh; y > 0; y--)
{
n -= rsk;
xoff -= rsk;
yoff -= rsk;
dsq -= dsk;
if ((*n != bval) && ((last == bval) || (*dsq <= r2)))
{
last = *n;
dx = *xoff;
dx2 = dx * dx;
dy = *yoff;
r2 = *dsq;
}
else if (last != bval)
{
dy++;
dy2 = dy * dy;
r2 = dx2 + dy2;
}
if ((last != bval) &&
((*n == bval) || (*dsq > r2) || ((*dsq == r2) && (last > *n))))
{
*n = last;
*xoff = dx;
*yoff = dy;
*dsq = r2;
}
}
// set up for next column
n++;
xoff++;
yoff++;
dsq++;
}
// PASS 3: find nearest neighbor and distance in horizontal direction again
n = n0;
xoff = xoff0;
yoff = yoff0;
dsq = dsq0;
for (y = rh; y > 0; y--)
{
// down right, extend last label if better and reset distance
last = bval;
for (x = rw; x > 0; x--)
{
if ((*n != bval) && ((last == bval) || (*dsq <= r2)))
{
last = *n;
dx = *xoff;
dy = *yoff;
dy2 = dy * dy;
r2 = *dsq;
}
else if (last != bval)
{
dx++;
dx2 = dx * dx;
r2 = dx2 + dy2;
}
if ((last != bval) &&
((*n == bval) || (*dsq > r2) || ((*dsq == r2) && (last > *n))))
{
*n = last;
*xoff = dx;
*yoff = dy;
*dsq = r2;
}
n++;
xoff++;
yoff++;
dsq++;
}
// left wipe, extend last label if better and reset distance
last = bval;
for (x = rw; x > 0; x--)
{
n--;
xoff--;
yoff--;
dsq--;
if ((*n != bval) && ((last == bval) || (*dsq <= r2)))
{
last = *n;
dx = *xoff;
dy = *yoff;
dy2 = dy * dy;
r2 = *dsq;
}
else if (last != bval)
{
dx++;
dx2 = dx * dx;
r2 = dx2 + dy2;
}
if ((last != bval) &&
((*n == bval) || (*dsq > r2) || ((*dsq == r2) && (last > *n))))
{
*n = last;
*xoff = dx;
*yoff = dy;
*dsq = r2;
}
}
// set up for next row
n += rsk;
xoff += rsk;
yoff += rsk;
dsq += dsk;
}
// PASS 4: fix up distances
if (dist != NULL)
{
dist->CopyRoi(seed);
rsk = dist->RoiSkip();
dsk = sqdist->RoiSkip();
d = (US16 *)(dist->PxlSrc() + roff);
dsq = dsq0;
for (y = rh; y > 0; y--)
{
for (x = rw; x > 0; x--)
*d++ = (US16) ROUND(sqrt((double)(*dsq++)));
d += rsk;
dsq += dsk;
}
}
return 1;
}
//= Same as Voronoi but specialized for 8 bit labels and distances (saturated).
// when two seeds are equidistant, higher label dominates
// about 3.4x slower than Nearest8 (5.3x if distance is returned)
int jhcDist::Voronoi8 (jhcImg& label, const jhcImg& seed, int bg, jhcImg *rng,
jhcImg *xrng, jhcImg *yrng, jhcImg *rng2)
{
jhcImg *dist = rng, *xdist = xrng, *ydist = yrng, *sqdist = rng2;
// check image sizes, possibly make up scratch arrays
if (!label.Valid(1) || !label.SameFormat(seed) || label.SameImg(seed))
return Fatal("Bad images to jhcDist::Voronoi8");
if (((dist != NULL) && !label.SameFormat(*dist)) ||
((xdist != NULL) && !label.SameFormat(*xdist)) ||
((ydist != NULL) && !label.SameFormat(*ydist)) ||
((sqdist != NULL) && !label.SameSize(*sqdist, 2)))
return Fatal("Bad auxilliary images to jhcDist::Voronoi8");
if (xdist == NULL)
xdist = a1.SetSize(seed);
if (ydist == NULL)
ydist = b1.SetSize(seed);
if (sqdist == NULL)
sqdist = a2.SetSize(seed, 2);
label.CopyRoi(seed);
xdist->CopyRoi(seed);
ydist->CopyRoi(seed);
sqdist->CopyRoi(seed);
// set up iteration variables
int x, y, rw = seed.RoiW(), rh = seed.RoiH();
UC8 dx, dy, last, bval = BOUND(bg);
US16 dx2, dy2;
UL32 r2, roff = seed.RoiOff();
UL32 rsk = seed.Line(), dsk = sqdist->Line() >> 1;
US16 *dsq, *dsq0 = (US16 *)(sqdist->PxlSrc() + sqdist->RoiOff());
const UC8 *s1, *s = seed.PxlSrc() + roff;
UC8 *n, *n0 = label.PxlDest() + roff;
UC8 *d, *xoff, *xoff0 = xdist->PxlDest() + roff;
UC8 *yoff, *yoff1, *yoff0 = ydist->PxlDest() + roff;
// PASS 1: find nearest neighbor and distance in horizontal direction
n = n0;
xoff = xoff0;
yoff = yoff0;
dsq = dsq0;
for (y = rh; y > 0; y--)
{
// right wipe, extend last label and increment distance
s1 = s;
yoff1 = yoff;
last = bval;
for (x = rw; x > 0; x--)
{
if (*s != bval)
{
dx = 0;
last = *s;
*n = last;
*xoff = 0;
*yoff = 0;
*dsq = 0;
}
else if (last != bval)
{
if (dx < 255)
dx++;
*n = last;
*xoff = dx;
*yoff = 0;
*dsq = dx * dx;
}
else
{
*n = bval;
*xoff = 0;
*yoff = 0;
*dsq = 0;
}
s++;
n++;
xoff++;
yoff++;
dsq++;
}
// left wipe, extend last label if better and increment distance
last = bval;
for (x = rw; x > 0; x--)
{
n--;
xoff--;
dsq--;
if ((*n != bval) && (*xoff == 0))
{
dx = 0;
last = *n;
}
else if (last != bval)
{
if (dx < 255)
dx++;
if ((*n == bval) || (*xoff > dx) || ((*xoff == dx) && (last > *n)))
{
*n = last;
*xoff = dx;
*dsq = dx * dx;
}
}
}
// set up for next line
s = s1 + rsk;
n += rsk;
xoff += rsk;
yoff = yoff1 + rsk;
dsq += dsk;
}
// PASS2: find nearest neighbor and distance in vertical direction
n = n0;
xoff = xoff0;
yoff = yoff0;
dsq = dsq0;
for (x = rw; x > 0; x--)
{
// down wipe, extend last label if better and reset distance
last = bval;
for (y = rh; y > 0; y--)
{
if ((*n != bval) && ((last == bval) || (*dsq <= r2)))
{
last = *n;
dx = *xoff;
dx2 = dx * dx;
dy = *yoff;
r2 = *dsq;
}
else if ((last != bval) && (dy < 255))
{
dy++;
dy2 = dy * dy;
r2 = dx2 + dy2;
}
if ((last != bval) &&
((*n == bval) || (*dsq > r2) || ((*dsq == r2) && (last > *n))))
{
*n = last;
*xoff = dx;
*yoff = dy;
*dsq = (US16) __min(r2, 65535);
}
n += rsk;
xoff += rsk;
yoff += rsk;
dsq += dsk;
}
// up wipe, extend last label if better and reset distance
last = bval;
for (y = rh; y > 0; y--)
{
n -= rsk;
xoff -= rsk;
yoff -= rsk;
dsq -= dsk;
if ((*n != bval) && ((last == bval) || (*dsq <= r2)))
{
last = *n;
dx = *xoff;
dx2 = dx * dx;
dy = *yoff;
r2 = *dsq;
}
else if ((last != bval) && (dy < 255))
{
dy++;
dy2 = dy * dy;
r2 = dx2 + dy2;
}
if ((last != bval) &&
((*n == bval) || (*dsq > r2) || ((*dsq == r2) && (last > *n))))
{
*n = last;
*xoff = dx;
*yoff = dy;
*dsq = (US16) __min(r2, 65535);
}
}
// set up for next column
n++;
xoff++;
yoff++;
dsq++;
}
// PASS 3: find nearest neighbor and distance in horizontal direction again
n = n0;
xoff = xoff0;
yoff = yoff0;
dsq = dsq0;
for (y = rh; y > 0; y--)
{
// down right, extend last label if better and reset distance
last = bval;
for (x = rw; x > 0; x--)
{
if ((*n != bval) && ((last == bval) || (*dsq <= r2)))
{
last = *n;
dx = *xoff;
dy = *yoff;
dy2 = dy * dy;
r2 = *dsq;
}
else if ((last != bval) && (dx < 255))
{
dx++;
dx2 = dx * dx;
r2 = dx2 + dy2;
}
if ((last != bval) &&
((*n == bval) || (*dsq > r2) || ((*dsq == r2) && (last > *n))))
{
*n = last;
*xoff = dx;
*yoff = dy;
*dsq = (US16) __min(r2, 65535);
}
n++;
xoff++;
yoff++;
dsq++;
}
// left wipe, extend last label if better and reset distance
last = bval;
for (x = rw; x > 0; x--)
{
n--;
xoff--;
yoff--;
dsq--;
if ((*n != bval) && ((last == bval) || (*dsq <= r2)))
{
last = *n;
dx = *xoff;
dy = *yoff;
dy2 = dy * dy;
r2 = *dsq;
}
else if ((last != bval) && (dx < 255))
{
dx++;
dx2 = dx * dx;
r2 = dx2 + dy2;
}
if ((last != bval) &&
((*n == bval) || (*dsq > r2) || ((*dsq == r2) && (last > *n))))
{
*n = last;
*xoff = dx;
*yoff = dy;
*dsq = (US16) __min(r2, 65535);
}
}
// set up for next row
n += rsk;
xoff += rsk;
yoff += rsk;
dsq += dsk;
}
// PASS 4: fix up distances
if (dist != NULL)
{
dist->CopyRoi(seed);
rsk = dist->RoiSkip();
dsk = sqdist->RoiSkip();
d = dist->PxlDest() + roff;
dsq = dsq0;
for (y = rh; y > 0; y--)
{
for (x = rw; x > 0; x--)
{
r2 = *dsq++;
if (r2 >= 65025)
*d++ = 255;
else
*d++ = (UC8) ROUND(sqrt((double) r2));
}
d += rsk;
dsq += dsk;
}
}
return 1;
}
| 23.457052 | 82 | 0.437161 | jconnell11 |
4159acedb53270b6a6a37e3abc46597436ad018c | 6,013 | cpp | C++ | libs/foe_yaml/src/pod_parsing.cpp | StableCoder/foe-engine | 5d49696a46c119e708dc4055b99e18194bcd4c4f | [
"Apache-2.0"
] | 4 | 2021-04-09T13:11:22.000Z | 2022-03-26T07:29:31.000Z | libs/foe_yaml/src/pod_parsing.cpp | StableCoder/foe-engine | 5d49696a46c119e708dc4055b99e18194bcd4c4f | [
"Apache-2.0"
] | null | null | null | libs/foe_yaml/src/pod_parsing.cpp | StableCoder/foe-engine | 5d49696a46c119e708dc4055b99e18194bcd4c4f | [
"Apache-2.0"
] | 1 | 2022-02-10T14:51:00.000Z | 2022-02-10T14:51:00.000Z | /*
Copyright (C) 2020 George Cave.
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
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.
*/
#include <foe/yaml/exception.hpp>
#include <foe/yaml/export.h>
#include <foe/yaml/parsing.hpp>
#include <cstdint>
template <typename T>
bool yaml_read_optional(std::string const &typeName,
std::string const &nodeName,
YAML::Node const &node,
T &data) {
YAML::Node const &subNode = (nodeName.empty()) ? node : node[nodeName];
if (!subNode) {
return false;
}
try {
data = subNode.as<T>();
} catch (...) {
switch (node.Type()) {
case YAML::NodeType::Null:
throw foeYamlException(nodeName + " - Could not parse Null-type node as '" + typeName +
"'");
case YAML::NodeType::Scalar:
throw foeYamlException(nodeName + " - Could not parse node as '" + typeName +
"' with value of: " + subNode.as<std::string>());
case YAML::NodeType::Sequence:
throw foeYamlException(nodeName + " - Could not parse Sequence-type node as '" +
typeName + "'");
case YAML::NodeType::Map:
throw foeYamlException(nodeName + " - Could not parse Map-type node as '" + typeName +
"'");
case YAML::NodeType::Undefined:
throw foeYamlException(nodeName + " - Could not parse Undefined-type node as '" +
typeName + "'");
}
}
return true;
}
template <typename T>
void yaml_read_required(std::string const &typeName,
std::string const &nodeName,
YAML::Node const &node,
T &data) {
if (!yaml_read_optional(typeName, nodeName, node, data)) {
throw foeYamlException(nodeName + " - Required node not found to parse as '" + typeName +
"'");
}
}
template <typename T>
void yaml_write_required(std::string const &typeName,
std::string const &nodeName,
T const &data,
YAML::Node &node) {
try {
if (nodeName.empty()) {
node = data;
} else {
node[nodeName] = data;
}
} catch (...) {
throw foeYamlException(nodeName + " - Failed to serialize node as '" + typeName + "'");
}
}
template <typename T>
bool yaml_write_optional(std::string const &typeName,
std::string const &nodeName,
T const &defaultData,
T const &data,
YAML::Node &node) {
if (data == defaultData) {
return false;
}
yaml_write_required(typeName, nodeName, data, node);
return true;
}
#define INSTANTIATION(T) \
template <> \
FOE_YAML_EXPORT void yaml_read_required<T>(std::string const &nodeName, \
YAML::Node const &node, T &data) { \
yaml_read_required<T>(#T, nodeName, node, data); \
} \
\
template <> \
FOE_YAML_EXPORT bool yaml_read_optional<T>(std::string const &nodeName, \
YAML::Node const &node, T &data) { \
return yaml_read_optional<T>(#T, nodeName, node, data); \
} \
\
template <> \
FOE_YAML_EXPORT void yaml_write_required<T>(std::string const &nodeName, T const &data, \
YAML::Node &node) { \
yaml_write_required<T>(#T, nodeName, data, node); \
} \
\
template <> \
FOE_YAML_EXPORT bool yaml_write_optional<T>(std::string const &nodeName, T const &defaultData, \
T const &data, YAML::Node &node) { \
return yaml_write_optional<T>(#T, nodeName, defaultData, data, node); \
}
INSTANTIATION(bool)
INSTANTIATION(int8_t)
INSTANTIATION(int16_t)
INSTANTIATION(int32_t)
INSTANTIATION(int64_t)
INSTANTIATION(uint8_t)
INSTANTIATION(uint16_t)
INSTANTIATION(uint32_t)
INSTANTIATION(uint64_t)
INSTANTIATION(float)
INSTANTIATION(double)
INSTANTIATION(std::string) | 42.95 | 100 | 0.440047 | StableCoder |
415bf2b5c39322da8f662da730ba4f6f03cfff25 | 2,899 | cpp | C++ | 1/2/client2_async.cpp | Kot97/pus | 7d9de3269bc28b727111314ea920f6d30f68120a | [
"MIT"
] | null | null | null | 1/2/client2_async.cpp | Kot97/pus | 7d9de3269bc28b727111314ea920f6d30f68120a | [
"MIT"
] | 4 | 2019-04-10T18:32:55.000Z | 2019-04-10T18:44:44.000Z | 1/2/client2_async.cpp | Kot97/pus | 7d9de3269bc28b727111314ea920f6d30f68120a | [
"MIT"
] | null | null | null | /*
* Data: 2019-03-18
* Autor: Marcin Kurdziel
* Kompilacja: clang++ -std=c++14 -o client2_async client2_async.cpp -lpthread
* Zamiast clang++ można użyć g++, ale nie jest to zalecane
* Do skompilowaniu programu potrzebna jest biblioteka Boost.Asio oraz Boost.Lexical_Cast
* Uruchamianie: ./client2_async <adres IP> <numer portu> <wiadomość>
*/
#include <boost/asio/io_context.hpp>
#include <boost/asio/ip/udp.hpp>
#include <boost/lexical_cast.hpp>
#include <array>
#include <iostream>
#include <string>
#include <thread>
namespace asio = boost::asio;
void print_error(const std::string msg, const boost::system::error_code& err)
{
if(err == asio::error::operation_aborted) return;
std::cerr << msg << "(): " << err.message() << std::endl;
}
int main(int argc, char** argv)
{
if (argc != 4)
{
std::cerr << "Invocation: " << argv[0] << " <IPv4 ADDRESS> <PORT> <MESSAGE>" << std::endl;
return 1;
}
// io_context jest niezbędnym elementem, który służy do komunikacji z systemem operacyjnym
asio::io_context context;
// utworzenie i otwarcie gniazda dla protokolu UDP
asio::ip::udp::socket socket(context);
socket.open(asio::ip::udp::v4());
// utworzenie punktu końcowego komunikacji
// pierwszym argumentem konstruktora jest adres IP, drugim numer portu
asio::ip::udp::endpoint endpoint(asio::ip::make_address_v4(argv[1]),
boost::lexical_cast<unsigned short>(argv[2]));
sleep(1);
std::cout << "Sending message to " << argv[1] << ".\nWaiting for server response..." << std::endl;
sleep(2);
std::string message = argv[3];
std::array<char, 256> response;
// wysłanie wiadomości
socket.async_send_to(asio::buffer(message), endpoint, [&](const boost::system::error_code& err, std::size_t bytes)
{
if(err)
{
print_error("send_to", err);
return;
}
// odpowiedź serwera
socket.async_receive_from(asio::buffer(response), endpoint, [&](const boost::system::error_code& err, std::size_t bytes)
{
if(err)
{
print_error("receive_from", err);
return;
}
std::cout << "Server response: " << response.data() << std::endl;
socket.close();
});
});
// odpalenie obsługi handlerów na osobnym wątku
std::thread thread([&](){ context.run(); });
// jesli wolimy, by komunikacja działała w tle i nie chcemy czekać, możemy zrobić tu detach()
// tutaj możemy robić co chcemy (równolegle do obsługi komunikacji)
// ...
// jeżeli nie użyliśmy detach()
thread.join();
return 0;
}
| 32.211111 | 129 | 0.577096 | Kot97 |
415c33583b0b8e72bb472b40374ba507dc76d455 | 2,298 | cpp | C++ | gui/Application.cpp | vitalissius/iweather | 13b6469b729a627335a2d629e5a62f6726058dc0 | [
"MIT"
] | 1 | 2021-04-16T08:36:00.000Z | 2021-04-16T08:36:00.000Z | gui/Application.cpp | vitalissius/iweather | 13b6469b729a627335a2d629e5a62f6726058dc0 | [
"MIT"
] | null | null | null | gui/Application.cpp | vitalissius/iweather | 13b6469b729a627335a2d629e5a62f6726058dc0 | [
"MIT"
] | null | null | null | #include "Application.h"
bool Application::IsAlreadyRunning()
{
HANDLE mtx = CreateMutex(NULL, FALSE, TEXT("{A393562E-EF7A-459F-A920-0286403D4A9B++}"));
if (GetLastError() == ERROR_ALREADY_EXISTS)
{
static const TCHAR* message = TEXT("Application is already running");
MessageBox(NULL, message, TEXT("Info"), MB_ICONINFORMATION | MB_OK);
CloseHandle(mtx);
return true;
}
return false;
}
Application::Application(
LPCTSTR windowName,
HINSTANCE hInstance,
int cmdShow,
LRESULT(WINAPI* pWndProc)(HWND, UINT, WPARAM, LPARAM),
int width,
int height,
UINT classStyle,
UINT windowStyle,
UINT windowStyleEx,
int xPos,
int yPos)
{
static constexpr TCHAR* tcsClassName = TEXT("WeatherApp-42");
m_wcex.cbSize = sizeof(WNDCLASSEX);
m_wcex.style = classStyle;
m_wcex.lpfnWndProc = pWndProc;
m_wcex.cbClsExtra = 0;
m_wcex.cbWndExtra = 0;
m_wcex.hInstance = hInstance;
m_wcex.hIcon = NULL;
m_wcex.hCursor = LoadCursor(NULL, IDC_ARROW);
m_wcex.hbrBackground = (HBRUSH)GetStockObject(GRAY_BRUSH);// WHITE_BRUSH);
m_wcex.lpszMenuName = NULL;
m_wcex.lpszClassName = tcsClassName;
if (!RegisterClassEx(&m_wcex))
{
const auto message = (tstring(TEXT("Cannot register class: ")) + tcsClassName);
MessageBox(NULL, message.data(), TEXT("Error"), MB_ICONERROR | MB_OK);
return;
}
m_mainWnd = CreateWindowEx(windowStyleEx, tcsClassName, windowName, windowStyle,
xPos, yPos, width, height, NULL, NULL, hInstance, NULL);
if (!m_mainWnd)
{
const auto message = tstring(TEXT("Cannot create window: ")) + windowName;
MessageBox(NULL, message.data(), TEXT("Error"), MB_ICONERROR | MB_OK);
return;
}
ShowWindow(m_mainWnd, cmdShow);
UpdateWindow(m_mainWnd);
}
WPARAM Application::Run()
{
MSG msg = { 0 };
while (GetMessage(&msg, NULL, 0, 0))
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
return msg.wParam;
}
BOOL Application::SetTransparency(const int percent)
{
assert(percent <= 100 && percent >= 0);
BYTE alpha = 255 - BYTE(2.55f * percent);
return ::SetLayeredWindowAttributes(m_mainWnd, RGB(0, 0, 0), alpha, LWA_ALPHA);
}
| 26.413793 | 92 | 0.651001 | vitalissius |
415e6b07be4d2de9f9ece0a58b60f2719e71b34c | 169 | hpp | C++ | include/scene/scene.hpp | selcia-eremeev/cake | 855886acd7595d12780cb95a0bcb8a6fcee09ac6 | [
"MIT"
] | 1 | 2020-11-28T21:07:24.000Z | 2020-11-28T21:07:24.000Z | include/scene/scene.hpp | selcia-eremeev/chen | 96a2f4fbe444b26668983fb4c3f360d1a22cd2f7 | [
"MIT"
] | 9 | 2021-03-23T20:08:51.000Z | 2021-03-27T20:44:09.000Z | include/scene/scene.hpp | selcia-eremeev/cake | 855886acd7595d12780cb95a0bcb8a6fcee09ac6 | [
"MIT"
] | null | null | null | #pragma once
class Scene {
public:
virtual int Initialize(void) = 0;
virtual int Update(void) = 0;
virtual int Render(void) = 0;
virtual int Terminate(void) = 0;
}; | 18.777778 | 34 | 0.692308 | selcia-eremeev |
416185b85d800802d817b77d053182088c6fd7d9 | 1,600 | hpp | C++ | include/public/coherence/util/ListMuterator.hpp | chpatel3/coherence-cpp-extend-client | 4ea5267eae32064dff1e73339aa3fbc9347ef0f6 | [
"UPL-1.0",
"Apache-2.0"
] | 6 | 2020-07-01T21:38:30.000Z | 2021-11-03T01:35:11.000Z | include/public/coherence/util/ListMuterator.hpp | chpatel3/coherence-cpp-extend-client | 4ea5267eae32064dff1e73339aa3fbc9347ef0f6 | [
"UPL-1.0",
"Apache-2.0"
] | 1 | 2020-07-24T17:29:22.000Z | 2020-07-24T18:29:04.000Z | include/public/coherence/util/ListMuterator.hpp | chpatel3/coherence-cpp-extend-client | 4ea5267eae32064dff1e73339aa3fbc9347ef0f6 | [
"UPL-1.0",
"Apache-2.0"
] | 6 | 2020-07-10T18:40:58.000Z | 2022-02-18T01:23:40.000Z | /*
* Copyright (c) 2000, 2020, Oracle and/or its affiliates.
*
* Licensed under the Universal Permissive License v 1.0 as shown at
* http://oss.oracle.com/licenses/upl.
*/
#ifndef COH_LIST_MUTERATOR_HPP
#define COH_LIST_MUTERATOR_HPP
#include "coherence/lang.ns"
#include "coherence/util/ListIterator.hpp"
#include "coherence/util/Muterator.hpp"
COH_OPEN_NAMESPACE2(coherence,util)
/**
* Muterator is mutating iterator, that is it is capable of changing the
* list it iterates.
*
* @author mf 2008.05.05
*/
class COH_EXPORT ListMuterator
: public interface_spec<ListMuterator,
implements<ListIterator, Muterator> >
{
// ----- ListMuterator interface ----------------------------------------
public:
/**
* Insert the specified element immediately before the element to be
* returned from the next call to the next() method. A subsequent call
* to next() will not return the added element, while a call to
* previous() would return the added element.
*
* @param oh the element to add
*
* @throws UnsupportedOperationException if addition is not supported
*/
virtual void add(Object::Holder oh) = 0;
/**
* Replace the last element returned by next() or previous() with
* the specified element.
*
* @param oh the element to store
*
* @throws UnsupportedOperationException if set is not supported
*/
virtual void set(Object::Holder oh) = 0;
};
COH_CLOSE_NAMESPACE2
#endif // COH_LIST_MUTERATOR_HPP
| 27.118644 | 77 | 0.6425 | chpatel3 |
4164cad41386f4202620d706df15ab3a880cc49c | 1,792 | cpp | C++ | source/Structure/custom_plugins/plugins/HIL_server/protocol.cpp | Guiraffo/ProVANT_Simulator | ef2260204b13f39a9f83ad2ab88a9552a0699bff | [
"MIT"
] | null | null | null | source/Structure/custom_plugins/plugins/HIL_server/protocol.cpp | Guiraffo/ProVANT_Simulator | ef2260204b13f39a9f83ad2ab88a9552a0699bff | [
"MIT"
] | null | null | null | source/Structure/custom_plugins/plugins/HIL_server/protocol.cpp | Guiraffo/ProVANT_Simulator | ef2260204b13f39a9f83ad2ab88a9552a0699bff | [
"MIT"
] | null | null | null | #include <iostream>
#include "protocol.hpp"
Frame receive(Serial& serial)
{
Frame frame;
u8 header = frame.header();
u8 end = frame.end();
i32 status = 0;
u8 last = 'a';
bool fim = false;
while (!fim)
{
// std::cout << "entrei" << std::endl;
std::string byte = serial.read();
u8 b[1];
b[0] = byte[0];
switch (status)
{
case 1:
if (b[0] == last && last == header && header == end)
break;
if (b[0] != end)
frame.addByte(b[0]);
if (b[0] == end)
{
frame.addEnd();
status = 0;
// std::cout << "Frame received\n\n";
fim = true;
}
break;
case 0:
if (b[0] == header)
{
frame.addHeader();
status = 1;
}
break;
}
last = b[0];
}
return frame;
}
void print_frame(Frame frame, u8 type)
{
// std::cout << "Raw frame:" << std::endl;
// u8 *data = frame.data();
// i32 size = frame.size();
// print_buffer(data,size);
// std::cout << "\n\n";
if (frame.unbuild())
{
u8* data = frame.data();
i32 size = frame.size();
std::cout << "Decoded frame:" << std::endl;
if (type == FLOAT_FRAME)
print_float_buffer(frame);
else
print_buffer(frame.data(), frame.size());
frame.build();
std::cout << "\n\n\n";
}
else
{
std::cout << "Error: corrupted frame...\n";
}
}
void print_buffer(u8* data, i32 size)
{
for (int i = 0; i < size; i++)
std::cout << data[i];
}
void print_float_buffer(Frame frame)
{
i32 num_floats = frame.size() / sizeof(float);
for (int i = 0; i < num_floats; i++)
{
float n = frame.getFloat();
std::cout << n << std::endl;
}
}
void delay(unsigned long ms)
{
usleep(ms * 1000);
}
| 19.268817 | 60 | 0.499442 | Guiraffo |
416b26fe8e61a18d9ec0f54dbc94dfba8d727cf7 | 1,623 | cpp | C++ | engine/Engine.UI.GDI/src/ui/gdi/image/SvgDocument.cpp | Kartikeyapan598/Ghurund | bcdc5e1805bf82b3f9a0543a3bbe22681c5605ea | [
"MIT"
] | null | null | null | engine/Engine.UI.GDI/src/ui/gdi/image/SvgDocument.cpp | Kartikeyapan598/Ghurund | bcdc5e1805bf82b3f9a0543a3bbe22681c5605ea | [
"MIT"
] | 10 | 2018-03-20T21:32:16.000Z | 2018-04-23T19:42:59.000Z | engine/Engine.UI.GDI/src/ui/gdi/image/SvgDocument.cpp | Kartikeyapan598/Ghurund | bcdc5e1805bf82b3f9a0543a3bbe22681c5605ea | [
"MIT"
] | null | null | null | #include "ghuigdipch.h"
#include "SvgDocument.h"
#include "core/reflection/Property.h"
#include "core/reflection/StandardTypes.h"
#include "core/reflection/TypeBuilder.h"
#include <Shlwapi.h>
#include <wrl.h>
namespace Ghurund::UI::GDI {
const Ghurund::Core::Type& SvgDocument::GET_TYPE() {
using namespace Ghurund::Core;
static auto PROPERTY_SIZE = ReadOnlyProperty<SvgDocument, FloatSize>("Size", &getSize);
static const auto CONSTRUCTOR = Constructor<SvgDocument>();
static const Ghurund::Core::Type TYPE = TypeBuilder<SvgDocument>(Ghurund::UI::NAMESPACE_NAME, "SvgDocument")
.withProperty(PROPERTY_SIZE)
.withConstructor(CONSTRUCTOR)
.withSupertype(__super::GET_TYPE());
return TYPE;
}
const Array<ResourceFormat>& SvgDocument::GET_FORMATS() {
static const Ghurund::Core::Array<Ghurund::Core::ResourceFormat> formats = { Ghurund::Core::ResourceFormat(L"svg", true, false) };
return formats;
}
Status SvgDocument::loadInternal(
const Ghurund::Core::DirectoryPath& workingDir,
Ghurund::Core::MemoryInputStream& stream,
Ghurund::Core::LoadOption options
) {
return Status::NOT_IMPLEMENTED;
}
Status SvgDocument::saveInternal(
const Ghurund::Core::DirectoryPath& workingDir,
Ghurund::Core::MemoryOutputStream& stream,
Ghurund::Core::SaveOption options
) const {
return Status::NOT_SUPPORTED;
}
void SvgDocument::finalize() {}
Ghurund::Core::FloatSize SvgDocument::getSize() {
return { 0,0 };
}
} | 30.622642 | 138 | 0.666667 | Kartikeyapan598 |
416e48cb58930d8d513fc36c3c23b57c97bbaea6 | 194 | cpp | C++ | src/tests/globals/test_exceptions.cpp | andreasdr/tdmecpp | 62b1492e878565d5559741f849138688c0c5e91d | [
"MIT"
] | 1 | 2018-03-07T22:13:41.000Z | 2018-03-07T22:13:41.000Z | src/tests/globals/test_exceptions.cpp | andreasdr/tdmecpp | 62b1492e878565d5559741f849138688c0c5e91d | [
"MIT"
] | null | null | null | src/tests/globals/test_exceptions.cpp | andreasdr/tdmecpp | 62b1492e878565d5559741f849138688c0c5e91d | [
"MIT"
] | 1 | 2020-07-15T04:02:24.000Z | 2020-07-15T04:02:24.000Z | /**
* @version $Id: afb217bec975efb91f9ba58c54f58645b741d5d4 $
*/
#include <libtdme/globals/Exception.h>
int main(int argc, char *argv[]) {
throw TDMEGlobal::Exception("Test Exception");
}
| 19.4 | 59 | 0.716495 | andreasdr |
416f1798c4b310cc7f89a63f7bca3ad22bcd50c3 | 10,734 | cpp | C++ | src/network.cpp | USCCANA/lergm | e4ef1a516e4916b9097918d79bc1f7928fd358e0 | [
"MIT"
] | 7 | 2019-05-27T03:21:53.000Z | 2021-06-21T19:41:17.000Z | src/network.cpp | USCCANA/lergm | e4ef1a516e4916b9097918d79bc1f7928fd358e0 | [
"MIT"
] | 11 | 2019-05-03T16:24:59.000Z | 2020-07-16T04:59:11.000Z | src/network.cpp | USCCANA/lergm | e4ef1a516e4916b9097918d79bc1f7928fd358e0 | [
"MIT"
] | 1 | 2021-07-05T01:48:46.000Z | 2021-07-05T01:48:46.000Z | #include <Rcpp.h>
using namespace Rcpp;
// List induced_subnetwork(
// const List & net,
// const IntegerVector & v,
// bool check = true
// ) {
//
// List newnet;
//
// // Checking out the master edgelist
// if (!net.containsElementNamed("mel"))
// stop("No `mel`.");
//
// // Explicit conversion, hopefully is not that painful?
// ListOf< List > mel = as< ListOf< List > >(net["mel"]);
// for (unsigned int i = 0; i < mel.size(); ++i) {
//
// if (mel[i].size() == 0)
// continue;
//
// if (check && !mel[i].containsElementNamed("inl"))
// stop("No `inl` element in `net$mel`");
//
// if (check && !mel[i].containsElementNamed("outl"))
// stop("No `outl` element in `net$mel`");
//
// IntegerVector inl = mel[i]["inl"];
// if (inl.size() == 0)
// continue;
//
// IntegerVector outl = mel[i]["inl"];
//
//
// }
//
// return net2;
//
// }
//
// // // [[Rcpp::export]]
// // inline IntegerMatrix as_adjmati(const List & net, bool check = true) {
// //
// // if (check && !net.containsElementNamed("gal"))
// // stop("No network attributes `gal`");
// //
// // if (check && !net.containsElementNamed("mel"))
// // stop("No master edge list `mel`");
// //
// // List gal = net["gal"];
// // List mel = net["mel"];
// //
// // if (check && !gal.containsElementNamed("n"))
// // stop("No `n` element in in `net$gal`.");
// // unsigned int n = (unsigned int) gal["n"];
// //
// // IntegerMatrix res(n, n);
// // res.fill(0);
// //
// // unsigned int head, tail;
// //
// // // Rprintf("Entering the loop\n");
// // for (auto i = 0u; i < mel.size(); ++i) {
// //
// // // An empty object (not uncommon)
// // if (mel[i] == 0u)
// // continue;
// //
// // // Rprintf("Inside the loop\n");
// // List meli = mel.at(i);
// //
// //
// //
// // if (check && !meli.containsElementNamed("inl"))
// // stop("No `inl` element in `net$mel`");
// //
// // if (check && !meli.containsElementNamed("outl"))
// // stop("No `outl` element in `net$mel`");
// //
// // head = meli["inl"];
// // tail = meli["outl"];
// //
// // // Rprintf("in %d and out %d\n", head, tail);
// //
// // res(head - 1, tail - 1) = 1;
// //
// // }
// // return res;
// //
// // }
//
// // //' @export
// // //' @param check logical scalar.
// // //' @rdname as_adjmat
// // // [[Rcpp::export(name = "as_adjmat2")]]
// // std::vector< IntegerMatrix > as_adjmat(
// // const std::vector< List > & x,
// // bool check = true
// // ) {
// //
// // std::vector< IntegerMatrix > ans(x.size());
// // for (auto i = 0u; i < x.size(); ++i)
// // ans[i] = as_adjmati(x[i], check);
// //
// // return ans;
// //
// // }
// #define ERGMITO_DEBUG_NETWORK 1
// // [[Rcpp::export]]
// List init_network(
// int n,
// bool directed = true,
// bool hyper = false,
// bool loops = false,
// bool multiple = false,
// bool bipartite = false
// ) {
//
// if (n < 0)
// stop("`n` cannot be less than 0.");
//
// List emptylist;
//
// List g = List::create(
// /* Master edgelist:
// * This is in itself a list of length (mnext - 1) which, if different from
// * an empty list, has the following elements: inl (tail), outl (head), alt (attributes)
// *
// * See https://github.com/statnet/network/blob/525286ff257745011f35a58c193c68745f78e853/vignettes/networkVignette.Rnw#L331
// */
// _["mel"] = List(0),
//
// _["gal"] = List::create( // Graph attribute list
// _["n"] = n,
// _["mnext"] = 1, // Next number of edges (next m)
// _["directed"] = directed,
// _["hyper"] = hyper,
// _["loops"] = loops,
// _["multiple"] = multiple,
// _["bipartite"] = bipartite
// ),
// _["val"] = R_NilValue,
// _["iel"] = R_NilValue,
// _["oel"] = R_NilValue
// );
//
// // Depending if there are nodes, then
// if (n > 0) {
//
// std::vector< List > listoflists(n);
// std::vector< IntegerVector > listofInt(n);
//
// // n lists
// g["val"] = listoflists;
// g["iel"] = listofInt;
// g["oel"] = listofInt;
//
//
// } else {
//
// // n lists
// g["val"] = emptylist;
// g["iel"] = emptylist;
// g["oel"] = emptylist;
//
// }
//
// g.attr("class") = "network";
//
// return g;
//
// }
inline ListOf< List > matrix_to_networki(
const IntegerMatrix & x,
bool directed = true,
bool hyper = false,
bool loops = false,
bool multiple = false,
bool bipartite = false
) {
int n = x.nrow(), m = x.ncol();
if (n != m)
stop("Non-square matrix.");
std::vector< List > mel, val(n);
mel.reserve(x.size());
std::vector< std::vector<int> > iel(n), oel(n);
// Default lists. We do this so that we don't make that many calls during the
// for-loop.
List NA_trueList = List::create(_["na"] = true);
List NA_falseList = List::create(_["na"] = false);
int nedge = 0;
for (int j = 0; j < m; ++j) {
char name[64];
sprintf(&(name[0]), "%i", (unsigned short) j + 1u);
val.at(j) = NA_falseList;
val.at(j)["vertex.names"] = name;
int ni = n;
if (!directed)
ni = j;
for (int i = 0; i < ni; ++i) {
if (!loops && (i == j))
continue;
if (x(i, j) != 0) {
List edge = List::create(
_["inl"] = j + 1, //
_["outl"] = i + 1, // While we see from 0 to (n-1), R lives in 1 to n.
_["atl"] = ( x(i, j) == R_NaInt ) ? NA_trueList : NA_falseList
);
mel.push_back(edge);
iel.at(j).push_back(++nedge);
oel.at(i).push_back(nedge);
#ifdef ERGMITO_DEBUG_NETWORK
Rprintf("[matrix_to_network] x[%d, %d]: edge %d\n", i, j, nedge);
#endif
}
}
}
// Resizing back
mel.shrink_to_fit();
// typedef std::vector< std::vector< int > > vecvecint;
// for (vecvecint::iterator iter = iel.begin(); iter != iel.end(); ++iter) {
// std::reverse(iter->begin(), iter->end());
// }
// for (vecvecint::iterator iter = oel.begin(); iter != oel.end(); ++iter) {
// std::reverse(iter->begin(), iter->end());
// }
List network = List::create(
_["mel"] = mel,
_["gal"] = List::create(
_["n"] = n,
_["mnext"] = ++nedge, // Next number of edges (next m)
_["directed"] = directed,
_["hyper"] = hyper,
_["loops"] = loops,
_["multiple"] = multiple,
_["bipartite"] = bipartite
),
_["val"] = val,
_["iel"] = iel,
_["oel"] = oel
);
network.attr("class") = "network";
return network;
}
// [[Rcpp::export(name="matrix_to_network.", rng = false)]]
ListOf< List > matrix_to_network(
const ListOf< IntegerMatrix > & x,
const LogicalVector & directed ,
const LogicalVector & hyper ,
const LogicalVector & loops ,
const LogicalVector & multiple ,
const LogicalVector & bipartite
) {
int n = x.size();
ListOf< List > out(n);
for (int i = 0; i < n; ++i)
out[i] = matrix_to_networki(
x[i], directed[i], hyper[i], loops[i], multiple[i], bipartite[i]
);
return out;
}
//
// inline ListOf< List > add_vertex_attri(
// const ListOf< List > & x,
// const ListOf< GenericVector > & vattrs,
// const StringVector & names,
// const List & newattrs
// ) {
//
// ListOf< List > val = x;
//
// #ifdef ERGMITO_DEBUG_NETWORK
// Rprintf("[add_vertex_attr] has class?: %d\n", (int) as<List>(x).hasAttribute("class"));
// #endif
//
// // Checking lengths
// int nattrs = vattrs.size(), n = val.size();
// for (int i = 0; i < nattrs; ++i)
// if (vattrs[i].size() != n)
// stop("The length of `vattr` doesn't matches the number of vertices in the graph.");
//
// int nattrs_old = val[0].size();
// for (int i = 0; i < n; ++i) {
//
// // Appending the old attributes
// List newattrs_i = clone(newattrs);
//
// for (int j = 0; j < nattrs_old; ++j)
// newattrs_i[j] = val[i].at(j);
//
// // Adding the attributes to the ith vertex
// for (int j = 0; j < nattrs; ++j) {
// newattrs_i[j + nattrs_old] = vattrs[j].at(i);
// }
//
// #ifdef ERGMITO_DEBUG_NETWORK
// Rprintf("[add_vertex_attr] This is how the new attributes look like of i=%d:\n", i);
// print(wrap(newattrs_i));
// #endif
//
// // We need to update the names
// val[i] = newattrs_i;
//
// }
//
// // Updating the vertex attributes in x
// return val;
//
// }
//
// // [[Rcpp::export(name="add_vertex_attr.")]]
// ListOf< List > add_vertex_attr(
// const ListOf< List > & x,
// const ListOf< GenericVector > & vattrs,
// const StringVector & names,
// const ListOf< List > & oldattrs
//
// ) {
//
// int n = x.size();
// ListOf< List > res(n);
//
// // Checking the length
// if (vattrs.size() != names.size())
// stop("The number of names must match the length of a.");
//
//
// #ifdef ERGMITO_DEBUG_NETWORK
// Rprintf("[add_vertex_attr] Going OK up to basic checks. Found %d attributes to add.\n", names.size());
// #endif
//
// // Capturing names
// StringVector newnames = oldattrs.names();
//
// #ifdef ERGMITO_DEBUG_NETWORK
// Rprintf("[add_vertex_attr] Here is the lit of attributes to be added:\n");
// print(wrap(newnames));
// #endif
//
// for (StringVector::const_iterator iter = names.begin(); iter != names.end(); ++iter)
// newnames.push_back(*iter);
//
// #ifdef ERGMITO_DEBUG_NETWORK
// Rprintf("[add_vertex_attr] Creating the `newnames` object went fine.\n");
// #endif
//
// // All will have the same number of attributes
// List newattrs(newnames.size());
// newattrs.names() = newnames;
//
// #ifdef ERGMITO_DEBUG_NETWORK
// Rprintf("[add_vertex_attr] Starting with the loop.\n");
// #endif
//
// for (int i = 0; i < n; ++i) {
// List x_i = clone(as< List >(x[i]));
// // ListOf< List > val = as< ListOf< List > >(x_i["val"]);
// //
// // // Updating the value
// // add_vertex_attri(val, vattrs, names);
// // x_i["val"] = val;
// x_i["val"] = add_vertex_attri(
// as< ListOf< List > >(x_i["val"]), vattrs, names, newattrs
// );
//
// res[i] = x_i;
// }
//
// return res;
//
// }
| 26.635236 | 129 | 0.502981 | USCCANA |
416f704d6e5da8aa0be644c45a06cb28bea0ff10 | 5,221 | cpp | C++ | V-REP/programming/bluezero/bindings/java/java.cpp | ivalab/grasp_primitiveShape | 1d5ce48084e431944fed1239622f3cba97a9edf9 | [
"MIT"
] | 11 | 2020-01-12T19:50:43.000Z | 2022-01-27T20:15:24.000Z | V-REP/programming/bluezero/bindings/java/java.cpp | ivalab/grasp_primitiveShape | 1d5ce48084e431944fed1239622f3cba97a9edf9 | [
"MIT"
] | 1 | 2021-10-31T07:10:47.000Z | 2021-10-31T19:28:07.000Z | V-REP/programming/bluezero/bindings/java/java.cpp | ivalab/grasp_primitiveShape | 1d5ce48084e431944fed1239622f3cba97a9edf9 | [
"MIT"
] | 2 | 2020-10-20T01:32:11.000Z | 2021-06-04T10:31:26.000Z | extern "C"
{
#include "java.h"
#include <b0/bindings/c.h>
JNIEXPORT jlong JNICALL Java_coppelia_b0RemoteApi_b0Init(JNIEnv *env, jobject obj)
{
int argc = 1;
char *argv[1] = {"b0java"};
return b0_init(&argc, argv);
}
JNIEXPORT jlong JNICALL Java_coppelia_b0RemoteApi_b0NodeNew(JNIEnv *env, jobject obj, jstring name)
{
const char *_name=env->GetStringUTFChars(name,0);
b0_node* node=b0_node_new(_name);
env->ReleaseStringUTFChars(name,_name);
return((jlong)node);
}
JNIEXPORT void JNICALL Java_coppelia_b0RemoteApi_b0NodeDelete(JNIEnv *env, jobject obj, jlong node)
{
b0_node_delete((b0_node*)node);
}
JNIEXPORT void JNICALL Java_coppelia_b0RemoteApi_b0NodeInit(JNIEnv *env, jobject obj, jlong node)
{
b0_node_init((b0_node*)node);
}
JNIEXPORT jlong JNICALL Java_coppelia_b0RemoteApi_b0NodeTimeUsec(JNIEnv *env, jobject obj, jlong node)
{
return(b0_node_time_usec((b0_node*)node));
}
JNIEXPORT jlong JNICALL Java_coppelia_b0RemoteApi_b0NodeHardwareTimeUsec(JNIEnv *env, jobject obj, jlong node)
{
return(b0_node_hardware_time_usec((b0_node*)node));
}
JNIEXPORT jlong JNICALL Java_coppelia_b0RemoteApi_b0PublisherNewEx(JNIEnv *env, jobject obj, jlong node, jstring topicName, jint managed, jint notifyGraph)
{
const char *_topicName = env->GetStringUTFChars(topicName, 0);
b0_publisher* pub = b0_publisher_new_ex((b0_node*)node,_topicName,
managed, notifyGraph);
env->ReleaseStringUTFChars(topicName, _topicName);
return((jlong)pub);
}
JNIEXPORT void JNICALL Java_coppelia_b0RemoteApi_b0PublisherDelete(JNIEnv *env, jobject obj, jlong pub)
{
b0_publisher_delete((b0_publisher*)pub);
}
JNIEXPORT void JNICALL Java_coppelia_b0RemoteApi_b0PublisherInit(JNIEnv *env, jobject obj, jlong pub)
{
b0_publisher_init((b0_publisher*)pub);
}
JNIEXPORT void JNICALL Java_coppelia_b0RemoteApi_b0PublisherPublish(JNIEnv *env, jobject obj, jlong pub, jbyteArray data)
{
jbyte* bufferPtr=env->GetByteArrayElements(data,0);
jsize l=env->GetArrayLength(data);
b0_publisher_publish((b0_publisher*)pub, bufferPtr,l);
env->ReleaseByteArrayElements(data,bufferPtr,0);
}
JNIEXPORT void JNICALL Java_coppelia_b0RemoteApi_b0PublisherSetOption(JNIEnv *env, jobject obj, jlong pub, jlong option, jlong value)
{
b0_publisher_set_option((b0_publisher*)pub, option, value);
}
JNIEXPORT jlong JNICALL Java_coppelia_b0RemoteApi_b0SubscriberNewEx(JNIEnv *env, jobject obj, jlong node, jstring topicName, jint managed, jint notifyGraph)
{
const char *_topicName = env->GetStringUTFChars(topicName, 0);
b0_subscriber* sub = b0_subscriber_new_ex((b0_node*)node,
_topicName, 0, managed, notifyGraph);
env->ReleaseStringUTFChars(topicName, _topicName);
return((jlong)sub);
}
JNIEXPORT void JNICALL Java_coppelia_b0RemoteApi_b0SubscriberDelete(JNIEnv *env, jobject obj, jlong sub)
{
b0_subscriber_delete((b0_subscriber*)sub);
}
JNIEXPORT void JNICALL Java_coppelia_b0RemoteApi_b0SubscriberInit(JNIEnv *env, jobject obj, jlong sub)
{
b0_subscriber_init((b0_subscriber*)sub);
}
JNIEXPORT jint JNICALL Java_coppelia_b0RemoteApi_b0SubscriberPoll(JNIEnv *env, jobject obj, jlong sub, jlong timeout)
{
return(b0_subscriber_poll((b0_subscriber*)sub,(long)timeout));
}
JNIEXPORT jbyteArray JNICALL Java_coppelia_b0RemoteApi_b0SubscriberRead(JNIEnv *env, jobject obj, jlong sub)
{
jsize l;
void* data=b0_subscriber_read((b0_subscriber*)sub,(size_t*)&l);
jbyteArray jarray=env->NewByteArray(l);
env->SetByteArrayRegion(jarray,0,l,(jbyte*)data);
b0_buffer_delete(data);
return(jarray);
}
JNIEXPORT void JNICALL Java_coppelia_b0RemoteApi_b0SubscriberSetOption(JNIEnv *env, jobject obj, jlong sub, jlong option, jlong value)
{
b0_subscriber_set_option((b0_subscriber*)sub, option, value);
}
JNIEXPORT jlong JNICALL Java_coppelia_b0RemoteApi_b0ServiceClientNewEx(JNIEnv *env, jobject obj, jlong node, jstring serviceName, jint managed, jint notifyGraph)
{
const char *_serviceName = env->GetStringUTFChars(serviceName, 0);
b0_service_client* cli =b0_service_client_new_ex((b0_node*)node,
_serviceName, managed, notifyGraph);
env->ReleaseStringUTFChars(serviceName, _serviceName);
return((jlong)cli);
}
JNIEXPORT void JNICALL Java_coppelia_b0RemoteApi_b0ServiceClientDelete(JNIEnv *env, jobject
obj, jlong cli)
{
b0_service_client_delete((b0_service_client*)cli);
}
JNIEXPORT jbyteArray JNICALL Java_coppelia_b0RemoteApi_b0ServiceClientCall(JNIEnv *env, jobject obj, jlong cli, jbyteArray data)
{
jbyte* inBufferPtr = env->GetByteArrayElements(data, 0);
jsize inL = env->GetArrayLength(data);
jsize outL;
void* outData =
b0_service_client_call((b0_service_client*)cli,inBufferPtr,inL,
(size_t*)&outL);
jbyteArray jarray = env->NewByteArray(outL);
env->SetByteArrayRegion(jarray, 0, outL, (jbyte*)outData);
b0_buffer_delete(outData);
env->ReleaseByteArrayElements(data, inBufferPtr, 0);
return(jarray);
}
JNIEXPORT void JNICALL Java_coppelia_b0RemoteApi_b0ServiceClientSetOption(JNIEnv *env, jobject obj, jlong cli, jlong option, jlong value)
{
b0_service_client_set_option((b0_service_client*)cli, option, value);
}
} // extern "C"
| 35.277027 | 161 | 0.773415 | ivalab |
4170ed5207cf7980cc08796ea432ff007b24f67e | 1,494 | cpp | C++ | aff3ct/src/Tools/Algo/Draw_generator/Random_sigma_generator/Random_sigma_generator.cpp | AdrianLundell/ldpc-investigation-master-thesis | 075f5cd10dae498e4fcda2f4aabedd0e27caf122 | [
"MIT"
] | 1 | 2022-03-07T15:52:10.000Z | 2022-03-07T15:52:10.000Z | aff3ct/src/Tools/Algo/Draw_generator/Random_sigma_generator/Random_sigma_generator.cpp | AdrianLundell/ldpc-investigation-master-thesis | 075f5cd10dae498e4fcda2f4aabedd0e27caf122 | [
"MIT"
] | 6 | 2022-03-09T10:31:25.000Z | 2022-03-09T10:50:34.000Z | aff3ct/src/Tools/Algo/Draw_generator/Random_sigma_generator/Random_sigma_generator.cpp | AdrianLundell/ldpc-investigation-master-thesis | 075f5cd10dae498e4fcda2f4aabedd0e27caf122 | [
"MIT"
] | null | null | null | #include <aff3ct.hpp>
#include <aff3ct_extension.hpp>
#include <random>
#include <cmath>
using namespace aff3ct::tools;
template <typename R>
Random_sigma_generator<R>::Random_sigma_generator(const int seed)
: Draw_generator<R>()
{
this->set_seed(seed);
}
template <typename R>
void Random_sigma_generator<R>::set_seed(const int seed)
{
rd_engine.seed(seed);
}
template <typename R>
void Random_sigma_generator<R>::generate(std::vector<R> &sigmas, const R sigma_tot, const R sigma_min)
{
this->uniform_real_dist = std::uniform_real_distribution<R>((R)0.0, (R)1.0);
unsigned n_sigmas = sigmas.size();
std::vector<R> sigma_vars(n_sigmas, (R)0.0);
R sigma_vars_norm = 0.0;
for (R &sigma_var : sigma_vars)
{
sigma_var = this->uniform_real_dist(this->rd_engine);
sigma_vars_norm += sigma_var * sigma_var;
}
sigma_vars_norm = sqrt(sigma_vars_norm);
for (unsigned i = 0; i < n_sigmas; i++)
{
sigmas[i] = sigma_min + sigma_vars[i] / sigma_vars_norm * (sigma_tot - sqrt(n_sigmas) * sigma_min);
}
}
// ==================================================================================== explicit template instantiation
#include "Tools/types.h"
#ifdef AFF3CT_MULTI_PREC
template class aff3ct::tools::Random_sigma_generator<R_32>;
template class aff3ct::tools::Random_sigma_generator<R_64>;
#else
template class aff3ct::tools::Random_sigma_generator<R>;
#endif
// ==================================================================================== explicit template instantiation | 30.489796 | 119 | 0.661981 | AdrianLundell |
4170fa62dd0b625147fa723b36e7ba32cd86c255 | 3,069 | cpp | C++ | Engine/Source/Editor/Persona/Private/SAnimCompositePanel.cpp | windystrife/UnrealEngine_NVIDIAGameWork | b50e6338a7c5b26374d66306ebc7807541ff815e | [
"MIT"
] | 1 | 2022-01-29T18:36:12.000Z | 2022-01-29T18:36:12.000Z | Engine/Source/Editor/Persona/Private/SAnimCompositePanel.cpp | windystrife/UnrealEngine_NVIDIAGameWork | b50e6338a7c5b26374d66306ebc7807541ff815e | [
"MIT"
] | null | null | null | Engine/Source/Editor/Persona/Private/SAnimCompositePanel.cpp | windystrife/UnrealEngine_NVIDIAGameWork | b50e6338a7c5b26374d66306ebc7807541ff815e | [
"MIT"
] | null | null | null | // Copyright 1998-2017 Epic Games, Inc. All Rights Reserved.
#include "SAnimCompositePanel.h"
#include "Widgets/Layout/SBorder.h"
#include "Animation/EditorAnimCompositeSegment.h"
#include "SAnimSegmentsPanel.h"
#include "SAnimCompositeEditor.h"
#include "Widgets/Layout/SExpandableArea.h"
#define LOCTEXT_NAMESPACE "AnimCompositePanel"
//////////////////////////////////////////////////////////////////////////
// SAnimCompositePanel
void SAnimCompositePanel::Construct(const FArguments& InArgs)
{
SAnimTrackPanel::Construct( SAnimTrackPanel::FArguments()
.WidgetWidth(InArgs._WidgetWidth)
.ViewInputMin(InArgs._ViewInputMin)
.ViewInputMax(InArgs._ViewInputMax)
.InputMin(InArgs._InputMin)
.InputMax(InArgs._InputMax)
.OnSetInputViewRange(InArgs._OnSetInputViewRange));
Composite = InArgs._Composite;
CompositeEditor = InArgs._CompositeEditor;
this->ChildSlot
[
SNew(SVerticalBox)
+SVerticalBox::Slot()
.FillHeight(1)
[
SNew( SExpandableArea )
.AreaTitle( LOCTEXT( "CompositeLabel", "Composite" ) )
.BodyContent()
[
SAssignNew( PanelArea, SBorder )
.BorderImage( FEditorStyle::GetBrush("NoBorder") )
.Padding( FMargin(2.0f, 2.0f) )
.ColorAndOpacity( FLinearColor::White )
]
]
];
Update();
}
void SAnimCompositePanel::Update()
{
ClearSelected();
if ( Composite != NULL )
{
SAnimCompositeEditor* Editor = CompositeEditor.Pin().Get();
TSharedPtr<FTrackColorTracker> ColourTracker = MakeShareable(new FTrackColorTracker);
ColourTracker->AddColor(FLinearColor(0.9f, 0.9f, 0.9f, 0.9f));
ColourTracker->AddColor(FLinearColor(0.5f, 0.5f, 0.5f));
FLinearColor NodeColor = FLinearColor(0.f, 0.5f, 0.0f, 0.5f);
TSharedPtr<SVerticalBox> CompositeSlots;
PanelArea->SetContent(
SAssignNew( CompositeSlots, SVerticalBox )
);
TSharedRef<S2ColumnWidget> SectionTrack = Create2ColumnWidget(CompositeSlots.ToSharedRef());
SectionTrack->LeftColumn->AddSlot()
.AutoHeight()
.VAlign(VAlign_Center)
[
SNew(SAnimSegmentsPanel)
.AnimTrack(&Composite->AnimationTrack)
.NodeSelectionSet(&SelectionSet)
.ViewInputMin(ViewInputMin)
.ViewInputMax(ViewInputMax)
.ColorTracker(ColourTracker)
.NodeColor(NodeColor)
.ScrubPosition( Editor, &SAnimCompositeEditor::GetScrubValue )
.TrackMaxValue(Composite->SequenceLength)
.TrackNumDiscreteValues(Composite->GetNumberOfFrames())
.OnAnimSegmentNodeClicked( this, &SAnimCompositePanel::ShowSegmentInDetailsView )
.OnPreAnimUpdate( Editor, &SAnimCompositeEditor::PreAnimUpdate )
.OnPostAnimUpdate( Editor, &SAnimCompositeEditor::PostAnimUpdate )
];
}
}
void SAnimCompositePanel::ShowSegmentInDetailsView(int32 SegmentIndex)
{
UEditorAnimCompositeSegment *Obj = Cast<UEditorAnimCompositeSegment>(CompositeEditor.Pin()->ShowInDetailsView(UEditorAnimCompositeSegment::StaticClass()));
if(Obj != NULL)
{
Obj->InitAnimSegment(SegmentIndex);
}
}
void SAnimCompositePanel::ClearSelected()
{
SelectionSet.Empty();
CompositeEditor.Pin()->ClearDetailsView();
}
#undef LOCTEXT_NAMESPACE
| 28.155963 | 156 | 0.737374 | windystrife |
41726c393d6126f30961d7280e8c17431716d573 | 4,158 | cpp | C++ | modules/visualneuro/src/processors/groupcontroller.cpp | scivis-exhibitions/VisualNeuro | 0770bdb72360f229ef8ff51eff9c7395adb23dfd | [
"BSD-2-Clause"
] | null | null | null | modules/visualneuro/src/processors/groupcontroller.cpp | scivis-exhibitions/VisualNeuro | 0770bdb72360f229ef8ff51eff9c7395adb23dfd | [
"BSD-2-Clause"
] | null | null | null | modules/visualneuro/src/processors/groupcontroller.cpp | scivis-exhibitions/VisualNeuro | 0770bdb72360f229ef8ff51eff9c7395adb23dfd | [
"BSD-2-Clause"
] | null | null | null | /*********************************************************************************
*
* Inviwo - Interactive Visualization Workshop
*
* Copyright (c) 2019 Inviwo Foundation
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
* ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*********************************************************************************/
#include <modules/visualneuro/processors/groupcontroller.h>
namespace inviwo {
// The Class Identifier has to be globally unique. Use a reverse DNS naming scheme
const ProcessorInfo GroupController::processorInfo_{
"org.inviwo.GroupController", // Class identifier
"Group Controller", // Display name
"NoBrainer", // Category
CodeState::Experimental, // Code state
Tags::None, // Tags
};
const ProcessorInfo GroupController::getProcessorInfo() const { return processorInfo_; }
GroupController::GroupController()
: Processor()
, groupA_("groupA")
, groupB_("groupB")
, activeGroup_("activeGroup", "Active Group", {{"A", "A", 0}, {"B", "B", 1}}, 0)
, parameterSelected_("parameterSelected", "A parameter is selected", false)
, managers_{{std::make_shared<BrushingAndLinkingManager>(this),
std::make_shared<BrushingAndLinkingManager>(this)}} {
addPort(groupA_);
addPort(groupB_);
addProperty(activeGroup_);
addProperty(parameterSelected_);
groupA_.setData(managers_[0]);
groupB_.setData(managers_[1]);
}
void GroupController::process() {
if (*activeGroup_ == 0) {
groupA_.setData(managers_[0]);
} else {
groupB_.setData(managers_[1]);
}
}
void GroupController::invokeEvent(Event* event) {
if (auto brushingEvent = dynamic_cast<BrushingAndLinkingEvent*>(event)) {
auto source = event->getVisitedProcessors();
auto groupId = 0;
auto B = groupB_.getConnectedInports();
if (std::find(B.begin(), B.end(), brushingEvent->getSource()) !=
B.end()) {
groupId = 1;
}
if (dynamic_cast<FilteringEvent*>(event)) {
managers_[groupId]->setFiltered(brushingEvent->getSource(),
brushingEvent->getIndices());
event->markAsUsed();
} else if (dynamic_cast<SelectionEvent*>(event)) {
managers_[groupId]->setSelected(brushingEvent->getSource(),
brushingEvent->getIndices());
event->markAsUsed();
} else if (dynamic_cast<ColumnSelectionEvent*>(event)) {
for (auto& manager : managers_) {
manager->setSelectedColumn(brushingEvent->getSource(), brushingEvent->getIndices());
}
parameterSelected_.set(!brushingEvent->getIndices().empty());
event->markAsUsed();
}
}
Processor::invokeEvent(event);
}
} // namespace inviwo
| 41.168317 | 100 | 0.641414 | scivis-exhibitions |
41748d3f0d9bc0d48c923c8400fdd9de9c6280f3 | 5,041 | cpp | C++ | src/network/zeromq/Context.cpp | nopdotcom/opentxs | 140428ba8f1bd4c09654ebf0a1c1725f396efa8b | [
"MIT"
] | null | null | null | src/network/zeromq/Context.cpp | nopdotcom/opentxs | 140428ba8f1bd4c09654ebf0a1c1725f396efa8b | [
"MIT"
] | null | null | null | src/network/zeromq/Context.cpp | nopdotcom/opentxs | 140428ba8f1bd4c09654ebf0a1c1725f396efa8b | [
"MIT"
] | null | null | null | // Copyright (c) 2018 The Open-Transactions developers
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.
#include "stdafx.hpp"
#include "Context.hpp"
#include "opentxs/core/Data.hpp"
#include "opentxs/core/Log.hpp"
#include "opentxs/crypto/key/Ed25519.hpp"
#include "opentxs/network/zeromq/DealerSocket.hpp"
#include "opentxs/network/zeromq/PairSocket.hpp"
#include "opentxs/network/zeromq/Proxy.hpp"
#include "opentxs/network/zeromq/PublishSocket.hpp"
#include "opentxs/network/zeromq/PullSocket.hpp"
#include "opentxs/network/zeromq/PushSocket.hpp"
#include "opentxs/network/zeromq/ReplySocket.hpp"
#include "opentxs/network/zeromq/RequestSocket.hpp"
#include "opentxs/network/zeromq/RouterSocket.hpp"
#include "opentxs/network/zeromq/SubscribeSocket.hpp"
#include "PairEventListener.hpp"
#include <zmq.h>
template class opentxs::Pimpl<opentxs::network::zeromq::Context>;
#define INPROC_PREFIX "inproc://opentxs/"
#define PATH_SEPERATOR "/"
namespace opentxs::network::zeromq
{
OTZMQContext Context::Factory()
{
return OTZMQContext(new implementation::Context());
}
std::string Context::EncodePrivateZ85(const opentxs::crypto::key::Ed25519& key)
{
opentxs::OTData data = opentxs::Data::Factory();
auto retrieved = key.GetKey(data);
OT_ASSERT(retrieved);
size_t buffer_size = data->size() + data->size() / 4 + 1;
char* buffer = new char[buffer_size];
OT_ASSERT(nullptr != buffer);
char* p = nullptr;
p = zmq_z85_encode(
buffer, static_cast<const uint8_t*>(data->data()), data->size());
OT_ASSERT(nullptr != p);
std::string encoded{p};
delete[] buffer;
return encoded;
}
} // namespace opentxs::network::zeromq
namespace opentxs::network::zeromq::implementation
{
Context::Context()
: context_(zmq_ctx_new())
{
OT_ASSERT(nullptr != context_);
OT_ASSERT(1 == zmq_has("curve"));
}
Context::operator void*() const
{
OT_ASSERT(nullptr != context_)
return context_;
}
std::string Context::BuildEndpoint(
const std::string& path,
const int instance,
const int version) const
{
return std::string(INPROC_PREFIX) + std::to_string(instance) +
PATH_SEPERATOR + path + PATH_SEPERATOR + std::to_string(version);
}
std::string Context::BuildEndpoint(
const std::string& path,
const int instance,
const int version,
const std::string& suffix) const
{
return BuildEndpoint(path, instance, version) + PATH_SEPERATOR + suffix;
}
Context* Context::clone() const { return new Context; }
OTZMQDealerSocket Context::DealerSocket(
const ListenCallback& callback,
const bool client) const
{
return DealerSocket::Factory(*this, client, callback);
}
OTZMQSubscribeSocket Context::PairEventListener(
const PairEventCallback& callback,
const int instance) const
{
return OTZMQSubscribeSocket(
new class PairEventListener(*this, callback, instance));
}
OTZMQPairSocket Context::PairSocket(
const opentxs::network::zeromq::ListenCallback& callback) const
{
return PairSocket::Factory(*this, callback);
}
OTZMQPairSocket Context::PairSocket(
const opentxs::network::zeromq::ListenCallback& callback,
const opentxs::network::zeromq::PairSocket& peer) const
{
return PairSocket::Factory(callback, peer);
}
OTZMQPairSocket Context::PairSocket(
const opentxs::network::zeromq::ListenCallback& callback,
const std::string& endpoint) const
{
return PairSocket::Factory(*this, callback, endpoint);
}
OTZMQProxy Context::Proxy(
network::zeromq::Socket& frontend,
network::zeromq::Socket& backend) const
{
return opentxs::network::zeromq::Proxy::Factory(*this, frontend, backend);
}
OTZMQPublishSocket Context::PublishSocket() const
{
return PublishSocket::Factory(*this);
}
OTZMQPullSocket Context::PullSocket(const bool client) const
{
return PullSocket::Factory(*this, client);
}
OTZMQPullSocket Context::PullSocket(
const ListenCallback& callback,
const bool client) const
{
return PullSocket::Factory(*this, client, callback);
}
OTZMQPushSocket Context::PushSocket(const bool client) const
{
return PushSocket::Factory(*this, client);
}
OTZMQReplySocket Context::ReplySocket(
const ReplyCallback& callback,
const bool client) const
{
return ReplySocket::Factory(*this, client, callback);
}
OTZMQRequestSocket Context::RequestSocket() const
{
return RequestSocket::Factory(*this);
}
OTZMQRouterSocket Context::RouterSocket(
const ListenCallback& callback,
const bool client) const
{
return RouterSocket::Factory(*this, client, callback);
}
OTZMQSubscribeSocket Context::SubscribeSocket(
const ListenCallback& callback) const
{
return SubscribeSocket::Factory(*this, callback);
}
Context::~Context()
{
if (nullptr != context_) { zmq_ctx_shutdown(context_); }
}
} // namespace opentxs::network::zeromq::implementation
| 25.588832 | 79 | 0.72565 | nopdotcom |
41755df929a17b803e1c1135aec91ceed71f4fda | 1,711 | cpp | C++ | 3rd_party/occa/src/occa/internal/lang/expr/staticCastNode.cpp | RonRahaman/nekRS | ffc02bca33ece6ba3330c4ee24565b1c6b5f7242 | [
"BSD-3-Clause"
] | 312 | 2015-07-02T09:02:09.000Z | 2022-03-30T16:13:23.000Z | 3rd_party/occa/src/occa/internal/lang/expr/staticCastNode.cpp | neams-th-coe/nekRS | 5d2c8ab3d14b3fb16db35682336a1f96000698bb | [
"BSD-3-Clause"
] | 520 | 2015-07-12T18:32:38.000Z | 2022-03-31T16:15:00.000Z | 3rd_party/occa/src/occa/internal/lang/expr/staticCastNode.cpp | neams-th-coe/nekRS | 5d2c8ab3d14b3fb16db35682336a1f96000698bb | [
"BSD-3-Clause"
] | 79 | 2015-07-22T22:10:56.000Z | 2022-03-17T09:07:01.000Z | #include <occa/internal/lang/expr/staticCastNode.hpp>
namespace occa {
namespace lang {
staticCastNode::staticCastNode(token_t *token_,
const vartype_t &valueType_,
const exprNode &value_) :
exprNode(token_),
valueType(valueType_),
value(value_.clone()) {}
staticCastNode::staticCastNode(const staticCastNode &node) :
exprNode(node.token),
valueType(node.valueType),
value(node.value->clone()) {}
staticCastNode::~staticCastNode() {
delete value;
}
udim_t staticCastNode::type() const {
return exprNodeType::staticCast;
}
exprNode* staticCastNode::endNode() {
return value->endNode();
}
exprNode* staticCastNode::clone() const {
return new staticCastNode(token, valueType, *value);
}
void staticCastNode::pushChildNodes(exprNodeVector &children) {
children.push_back(value);
}
bool staticCastNode::safeReplaceExprNode(exprNode *currentNode, exprNode *newNode) {
if (currentNode == value) {
delete value;
value = newNode;
return true;
}
return false;
}
void staticCastNode::print(printer &pout) const {
// TODO: Print type without qualifiers
// Also convert [] to *
pout << "static_cast<" << valueType << ">("
<< *value << ')';
}
void staticCastNode::debugPrint(const std::string &prefix) const {
printer pout(io::stderr);
io::stderr << prefix << "|\n"
<< prefix << "|---[";
pout << valueType;
io::stderr << "] (staticCast)\n";
value->childDebugPrint(prefix);
}
}
}
| 26.734375 | 88 | 0.584454 | RonRahaman |
41785611ea0a9ff1e7ab93cacec35f0cd6fe280e | 2,703 | cpp | C++ | Source/source/mob_categories/bridge_category.cpp | ElatedEatrs/Pikifen | 1e834d5241fc631f8dfc519c17358051e867164f | [
"MIT"
] | null | null | null | Source/source/mob_categories/bridge_category.cpp | ElatedEatrs/Pikifen | 1e834d5241fc631f8dfc519c17358051e867164f | [
"MIT"
] | null | null | null | Source/source/mob_categories/bridge_category.cpp | ElatedEatrs/Pikifen | 1e834d5241fc631f8dfc519c17358051e867164f | [
"MIT"
] | null | null | null | /*
* Copyright (c) Andre 'Espyo' Silva 2013.
* The following source file belongs to the open-source project Pikifen.
* Please read the included README and LICENSE files for more information.
* Pikmin is copyright (c) Nintendo.
*
* === FILE DESCRIPTION ===
* Bridge mob category class.
*/
#include <algorithm>
#include "bridge_category.h"
#include "../mobs/bridge.h"
#include "../vars.h"
/* ----------------------------------------------------------------------------
* Creates an instance of the bridge category.
*/
bridge_category::bridge_category() :
mob_category(
MOB_CATEGORY_BRIDGES, "Bridge", "Bridges",
BRIDGES_FOLDER_PATH, al_map_rgb(224, 200, 180)
) {
}
/* ----------------------------------------------------------------------------
* Returns all types of bridge by name.
*/
void bridge_category::get_type_names(vector<string> &list) {
for(auto t = bridge_types.begin(); t != bridge_types.end(); ++t) {
list.push_back(t->first);
}
}
/* ----------------------------------------------------------------------------
* Returns a type of bridge given its name, or NULL on error.
*/
mob_type* bridge_category::get_type(const string &name) {
auto it = bridge_types.find(name);
if(it == bridge_types.end()) return NULL;
return it->second;
}
/* ----------------------------------------------------------------------------
* Creates a new, empty type of bridge.
*/
mob_type* bridge_category::create_type() {
return new bridge_type();
}
/* ----------------------------------------------------------------------------
* Registers a created type of bridge.
*/
void bridge_category::register_type(mob_type* type) {
bridge_types[type->name] = (bridge_type*) type;
}
/* ----------------------------------------------------------------------------
* Creates a bridge and adds it to the list of bridges.
*/
mob* bridge_category::create_mob(
const point &pos, mob_type* type, const float angle
) {
bridge* m = new bridge(pos, (bridge_type*) type, angle);
bridges.push_back(m);
return m;
}
/* ----------------------------------------------------------------------------
* Clears a bridge from the list of bridges.
*/
void bridge_category::erase_mob(mob* m) {
bridges.erase(
find(bridges.begin(), bridges.end(), (bridge*) m)
);
}
/* ----------------------------------------------------------------------------
* Clears the list of registered types of bridges.
*/
void bridge_category::clear_types() {
for(auto t = bridge_types.begin(); t != bridge_types.end(); ++t) {
delete t->second;
}
bridge_types.clear();
}
bridge_category::~bridge_category() { }
| 26.762376 | 79 | 0.506844 | ElatedEatrs |
417a91bc20d06a4845e0d0b668dc91a11f6323ea | 593 | cpp | C++ | Codeforces/Gym101612K.cpp | HeRaNO/OI-ICPC-Codes | 4a4639cd3e347b472520065ca6ab8caadde6906d | [
"MIT"
] | 18 | 2019-01-01T13:16:59.000Z | 2022-02-28T04:51:50.000Z | Codeforces/Gym101612K.cpp | HeRaNO/OI-ICPC-Codes | 4a4639cd3e347b472520065ca6ab8caadde6906d | [
"MIT"
] | null | null | null | Codeforces/Gym101612K.cpp | HeRaNO/OI-ICPC-Codes | 4a4639cd3e347b472520065ca6ab8caadde6906d | [
"MIT"
] | 5 | 2019-09-13T08:48:17.000Z | 2022-02-19T06:59:03.000Z | #include <bits/stdc++.h>
using namespace std;
int H[105],W[105];
void Init()
{
freopen("kotlin.in","r",stdin);
freopen("kotlin.out","w",stdout);
}
int h,w,n;
int main()
{
Init();
scanf("%d%d%d",&h,&w,&n);
for(int hi=1;hi<=(h+1)/2;++hi)
{
for(int wi=1;wi<=(w+1)/2;++wi)
{
if(hi*wi==n)
{
for(int i=0;i<hi-1;++i)H[1+i*2]=1;
for(int i=0;i<wi-1;++i)W[1+i*2]=1;
for(int i=0;i<h;++i)
{
for(int j=0;j<w;++j)
{
if(H[i]||W[j])printf("#");
else printf(".");
}
puts("");
}
return 0;
}
}
}
printf("Impossible");
return 0;
}
| 14.825 | 38 | 0.467116 | HeRaNO |
417dd5e62e8ce9a897baf68e1422681921360aea | 5,160 | cpp | C++ | mod/spawn/SpawnAnalyzer.cpp | Sysca11/TrapDoor | 77008c7dd47e835e453bbf099a8d91fd0036a011 | [
"MIT"
] | null | null | null | mod/spawn/SpawnAnalyzer.cpp | Sysca11/TrapDoor | 77008c7dd47e835e453bbf099a8d91fd0036a011 | [
"MIT"
] | null | null | null | mod/spawn/SpawnAnalyzer.cpp | Sysca11/TrapDoor | 77008c7dd47e835e453bbf099a8d91fd0036a011 | [
"MIT"
] | null | null | null | //
// Created by xhy on 2021/1/1.
//
#include "SpawnAnalyzer.h"
#include "entity/Actor.h"
#include "lib/SymHook.h"
#include "lib/mod.h"
#include "tools/Message.h"
#include "TrapdoorMod.h"
#include "tools/MsgBuilder.h"
#include <map>
namespace mod {
void SpawnAnalyzer::start(trapdoor::Actor *player) {
if (this->inAnalyzing) {
trapdoor::warning(player, "生物生成分析器在运行中");
} else {
this->gameTick = 0;
this->spawnData.clear();
inAnalyzing = true;
trapdoor::info(player, "生物生成分析器已经开始,生物生成分析器数据已经被自动清空");
}
}
void SpawnAnalyzer::end(trapdoor::Actor *player) {
if (!this->inAnalyzing) {
trapdoor::warning(player, "生物生成分析器没有在运行");
} else {
inAnalyzing = false;
trapdoor::info(player, "生物生成分析器已经停止运行");
}
}
void SpawnAnalyzer::addMobData(const SpawnAnalyzer::MobSpawnInfo &info) {
this->spawnData.push_back(info);
}
void SpawnAnalyzer::clearData(trapdoor::Actor *player) {
this->gameTick = 0;
this->spawnData.clear();
trapdoor::info(player, "数据已经清空");
}
void SpawnAnalyzer::printSimpleData(trapdoor::Actor *player, const std::string &typePatten) const {
trapdoor::MessageBuilder builder;
std::map<std::string, int> successSurface;
std::map<std::string, int> successUnderGround;
std::map<std::string, int> failSurface;
std::map<std::string, int> failUnderGround;
std::map<std::string, int> unSuccessData;
int successSNum = 0, successUNum = 0, failSNum = 0, failUNum = 0;
for (const auto &data:this->spawnData) {
if (data.isSurface) {
if (data.success) {
successSurface[data.type]++;
successSNum++;
} else {
failSurface[data.type]++;
failSNum++;
}
} else {
if (data.success) {
successUnderGround[data.type]++;
successUNum++;
} else {
failUnderGround[data.type]++;
failUNum++;
}
}
}
int successTotal = successSNum + successUNum;
int failTotal = failSNum + failUNum;
builder.textF("total %d success, %d fail (%.2f %%%%)\n", successTotal, failTotal,
successTotal * 100.0 / (successTotal + failTotal)).
text("----------Surface----------\n")
.textF("%d success %d fail (%.2f %%%%)\n", successSNum, failSNum,
successSNum * 100.0 / (successSNum + failSNum));
for (const auto &data:successSurface) {
int failNum = failSurface[data.first];
builder.text(" - ").text(data.first).text(" ").num(data.second).text("/").num(
failNum + data.second).text(
"(")
.num(data.second * 100 / (failNum + data.second)).text("%%%%)\n");
}
builder.text("----------Underground----------\n")
.textF("%d success %d fail (%.2f%%%%)\n", successUNum, failUNum,
successUNum * 100.0 / (successUNum + failUNum));
for (const auto &data:successUnderGround) {
int failNum = failUnderGround[data.first];
builder.text(" - ").text(data.first).text(" ").num(data.second).text("/").num(
failNum + data.second).text(
"(")
.num(data.second * 100 / (failNum + data.second)).text("%%%%)\n");
}
builder.send(player);
}
void SpawnAnalyzer::printSpeedGraph(trapdoor::Actor *player, size_t freq) const {
//这里本想打印速度曲线的，不想做了
}
}
using namespace SymHook;
//THook(
// bool,
// MSSYM_B1QA8spawnMobB1AA7SpawnerB2AAE11QEAAPEAVMobB2AAE15AEAVBlockSourceB2AAE29AEBUActorDefinitionIdentifierB2AAA9PEAVActorB2AAA8AEBVVec3B3AAUA3N44B1AA1Z,
// void *spawner,
// trapdoor::BlockSource *bs,
// trapdoor::ActorDefinitionIdentifier *actorId,
// trapdoor::Actor *actor,
// trapdoor::Vec3 *pos,
// bool naturalSpawn,
// bool surface,
// bool fromSpawner
//) {
// if (!naturalSpawn || fromSpawner) {
// return original(spawner, bs, actorId, actor, pos, naturalSpawn, surface, fromSpawner);
// } else {
// auto success = original(spawner, bs, actorId, actor, pos, naturalSpawn, surface, fromSpawner);
// auto modInstance = trapdoor::bdsMod->asInstance<mod::TrapdoorMod>();
// if (modInstance->getSpawnAnalyzer().isRunning()) {
// mod::SpawnAnalyzer::MobSpawnInfo info{
// modInstance->getSpawnAnalyzer().getTick(),
// actorId->getName(),
// {pos->x, pos->y, pos->z},
// surface,
// success
// };
// modInstance->getSpawnAnalyzer().addMobData(info);
// }
// return success;
// }
//}
| 36.083916 | 163 | 0.531395 | Sysca11 |
417ee9b0b9f619f74a9fce17193c873f568d2d3c | 586 | cpp | C++ | 281/A[ Word Capitalization ].cpp | mejanvijay/codeforces-jvj_iit-submissions | 2a2aac7e93ca92e75887eff92361174aa36207c8 | [
"MIT"
] | null | null | null | 281/A[ Word Capitalization ].cpp | mejanvijay/codeforces-jvj_iit-submissions | 2a2aac7e93ca92e75887eff92361174aa36207c8 | [
"MIT"
] | null | null | null | 281/A[ Word Capitalization ].cpp | mejanvijay/codeforces-jvj_iit-submissions | 2a2aac7e93ca92e75887eff92361174aa36207c8 | [
"MIT"
] | null | null | null | #include <bits/stdc++.h>
using namespace std;
#define sd(x) scanf("%d",&x)
#define su(x) scanf("%u",&x)
#define slld(x) scanf("%lld",&x)
#define sc(x) scanf("%c",&x)
#define ss(x) scanf("%s",x)
#define sf(x) scanf("%f",&x)
#define slf(x) scanf("%lf",&x)
#define ll long long int
#define mod(x,n) (x+n)%n
char S[1007];
int main()
{
// freopen("input_file_name.in","r",stdin);
// freopen("output_file_name.out","w",stdout);
ss(S);
if('a'<=S[0] && S[0]<='z')
S[0] = (char)( (int)S[0] - (int)'a' + (int)'A' );
printf("%s\n", S );
return 0;
} | 20.206897 | 68 | 0.554608 | mejanvijay |
418359219a1340b705c38263faf21121627d4974 | 1,219 | cpp | C++ | src/likelihood.cpp | PROBIC/mSWEEP | 91b2467593b6231468fdabed1455c095ec3f532a | [
"MIT"
] | 9 | 2018-06-05T16:27:09.000Z | 2020-09-18T13:15:45.000Z | src/likelihood.cpp | PROBIC/mSWEEP | 91b2467593b6231468fdabed1455c095ec3f532a | [
"MIT"
] | 10 | 2018-08-03T11:34:44.000Z | 2021-11-11T13:33:04.000Z | src/likelihood.cpp | PROBIC/mSWEEP | 91b2467593b6231468fdabed1455c095ec3f532a | [
"MIT"
] | 1 | 2020-09-15T16:40:41.000Z | 2020-09-15T16:40:41.000Z | #include "likelihood.hpp"
#include <vector>
#include <cmath>
inline double lbeta(double x, double y) {
return(std::lgamma(x) + std::lgamma(y) - std::lgamma(x + y));
}
inline double log_bin_coeff(uint16_t n, uint16_t k) {
return (std::lgamma(n + 1) - std::lgamma(k + 1) - std::lgamma(n - k + 1));
}
inline double ldbb_scaled(uint16_t k, uint16_t n, double alpha, double beta) {
return (log_bin_coeff(n, k) + lbeta(k + alpha, n - k + beta) - lbeta(n + alpha, beta));
}
void precalc_lls(const Grouping &grouping, const double bb_constants[2], Matrix<double> *ll_mat) {
const std::vector<std::array<double, 2>> &bb_params = grouping.bb_parameters(bb_constants);
uint32_t n_groups = grouping.get_n_groups();
uint16_t max_size = 0;
for (uint32_t i = 0; i < n_groups; ++i) {
max_size = (grouping.get_sizes()[i] > max_size ? grouping.get_sizes()[i] : max_size);
}
ll_mat->resize(n_groups, max_size + 1, -4.60517);
#pragma omp parallel for schedule(static)
for (uint32_t i = 0; i < n_groups; ++i) {
for (uint16_t j = 1; j <= max_size; ++j) {
(*ll_mat)(i, j) = ldbb_scaled(j, grouping.get_sizes()[i], bb_params[i][0], bb_params[i][1]) - 0.01005034; // log(0.99) = -0.01005034
}
}
}
| 34.828571 | 138 | 0.652174 | PROBIC |
418449e4d153084eb0985317d511c43b03a8bce5 | 1,773 | cc | C++ | UVa Online Judge/v104/10440.cc | mjenrungrot/algorithm | e0e8174eb133ba20931c2c7f5c67732e4cb2b703 | [
"MIT"
] | 1 | 2021-12-08T08:58:43.000Z | 2021-12-08T08:58:43.000Z | UVa Online Judge/v104/10440.cc | mjenrungrot/algorithm | e0e8174eb133ba20931c2c7f5c67732e4cb2b703 | [
"MIT"
] | null | null | null | UVa Online Judge/v104/10440.cc | mjenrungrot/algorithm | e0e8174eb133ba20931c2c7f5c67732e4cb2b703 | [
"MIT"
] | null | null | null | /*=============================================================================
# Author: Teerapat Jenrungrot - https://github.com/mjenrungrot/
# FileName: 10440.cc
# Description: UVa Online Judge - 10440
=============================================================================*/
#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int T;
cin >> T;
while (T--) {
int N, T, M;
cin >> N >> T >> M;
vector<int> ti(M);
for (int i = 0; i < M; i++) cin >> ti[i];
sort(ti.begin(), ti.end());
int curr_time = 0, n_trips = 0;
/* Move the first M%N cars
Note: We argue that if M % N > 0, it is always optimal to
move the first M % N cars together.
Let x_1 <= ... <= x_M be the time of arrivals and K = M % N
where K > 0. We'll prove by contradiction by supposing to
the contrary that the optimal solution doesn't put the first K
cars together. Note that our solution has the number of trips
equal to 1 + (M-K) / N
This implies that we put T < K cars together, and the remaining
K - T cars on the later trips. Since (M-K)%N == 0, this number of
trips will be 2 + (M-K) / N which is not optimal, making a
contradiction.
*/
if (M % N) {
curr_time = ti[M % N - 1] + 2 * T;
n_trips++;
}
// Move the remaining
for (int i = M % N + N - 1; i < M; i += N) {
curr_time = max(curr_time, ti[i]) + 2 * T;
n_trips++;
}
curr_time -= T;
cout << curr_time << " " << n_trips << endl;
}
return 0;
} | 30.568966 | 79 | 0.469261 | mjenrungrot |
4184cf2806a8bca26430c4699134a75b287ef83f | 1,650 | cpp | C++ | Codeforces/Round #690 (div3)/F.cpp | python-programmer1512/Code_of_gunwookim | e72e6724fb9ee6ccf2e1064583956fa954ba0282 | [
"MIT"
] | 4 | 2021-01-27T11:51:30.000Z | 2021-01-30T17:02:55.000Z | Codeforces/Round #690 (div3)/F.cpp | python-programmer1512/Code_of_gunwookim | e72e6724fb9ee6ccf2e1064583956fa954ba0282 | [
"MIT"
] | null | null | null | Codeforces/Round #690 (div3)/F.cpp | python-programmer1512/Code_of_gunwookim | e72e6724fb9ee6ccf2e1064583956fa954ba0282 | [
"MIT"
] | 5 | 2021-01-27T11:46:12.000Z | 2021-05-06T05:37:47.000Z | #include <bits/stdc++.h>
#define x first
#define y second
#define pb push_back
#define all(v) v.begin(),v.end()
#pragma gcc optimize("O3")
#pragma gcc optimize("Ofast")
#pragma gcc optimize("unroll-loops")
using namespace std;
const int INF = 1e9;
const int TMX = 1 << 18;
const long long llINF = 2e18;
const long long mod = 1e9+7;
const long long hashmod = 100003;
typedef long long ll;
typedef long double ld;
typedef pair <int,int> pi;
typedef pair <ll,ll> pl;
typedef vector <int> vec;
typedef vector <pi> vecpi;
typedef long long ll;
int n,m;
pi a[200005];
int sum[200005];
int t[400005];
vec rev;
bool cmp(pi x,pi y) {
if(x.y == y.y) return x.x > y.x;
return x.y < y.y;
}
void build() {
for(int i = 1;i <= m;i++) t[i] = 0;
}
void update(int x) {
for(;x <= m;x += x&-x) t[x]++;
}
int query(int x) {
int ret = 0;
for(;x;x -= x&-x) ret += t[x];
return ret;
}
int main() {
ios_base::sync_with_stdio(false); cin.tie(0);
int T; cin >> T;
while(T--) {
cin >> n;
rev.clear();
for(int i = 1;i <= n;i++) {
sum[i] = 0;
cin >> a[i].x >> a[i].y;
rev.pb(a[i].x);
rev.pb(a[i].y);
}
sort(all(rev)); rev.erase(unique(all(rev)),rev.end());
for(int i = 1;i <= n;i++) {
a[i].x = lower_bound(all(rev),a[i].x)-rev.begin()+1;
a[i].y = lower_bound(all(rev),a[i].y)-rev.begin()+1;
}
sort(a+1,a+n+1,cmp);
int ans = n;
m = rev.size();
build();
for(int i = 1;i <= n;i++) {
sum[i] += query(a[i].y)-query(a[i].x-1);
update(a[i].y);
}
build();
for(int i = n;i >= 1;i--) {
sum[i] += query(a[i].y);
update(a[i].x);
}
for(int i = 1;i <= n;i++) ans = min(ans,n-sum[i]-1);
cout << ans << '\n';
}
} | 20.625 | 56 | 0.557576 | python-programmer1512 |
4186bd60b59e47e5b527b37a9e931dc515a49965 | 5,445 | cpp | C++ | cli/cli_resources.cpp | lawlove/apitrace | d6a27295acb0a25926bf6290dd2532a7f9027864 | [
"MIT"
] | 2 | 2015-01-22T07:15:44.000Z | 2016-03-01T08:12:55.000Z | cli/cli_resources.cpp | gregory38/apitrace | 0627790166dccd8dd370fa7d9f434ed9fc027fb4 | [
"MIT"
] | null | null | null | cli/cli_resources.cpp | gregory38/apitrace | 0627790166dccd8dd370fa7d9f434ed9fc027fb4 | [
"MIT"
] | null | null | null | /*********************************************************************
*
* Copyright 2011 Intel Corporation
* All Rights Reserved.
*
* Permission is hereby granted, free of charge, to any person
* obtaining a copy of this software and associated documentation
* files (the "Software"), to deal in the Software without
* restriction, including without limitation the rights to use, copy,
* modify, merge, publish, distribute, sublicense, and/or sell copies
* of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be
* included in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*
*********************************************************************/
#include <iostream>
#include "os_string.hpp"
#include "cli_resources.hpp"
#ifdef __GLIBC__
#include <dlfcn.h>
static bool
tryLib(const os::String &path, bool verbose)
{
void *handle = dlopen(path.str(), RTLD_LAZY);
bool exists = (handle != NULL);
if (verbose) {
if (exists) {
std::cerr << "info: found " << path.str() << "\n";
} else {
std::cerr << "info: did not find " << dlerror() << "\n";
}
}
if (exists)
dlclose(handle);
return exists;
}
#endif
static bool
tryPath(const os::String &path, bool verbose)
{
bool exists = path.exists();
if (verbose) {
std::cerr << "info: " << (exists ? "found" : "did not find") << " " << path.str() << "\n";
}
return exists;
}
os::String
findProgram(const char *programFilename, bool verbose)
{
os::String programPath;
os::String processDir = os::getProcessName();
processDir.trimFilename();
programPath = processDir;
programPath.join(programFilename);
if (tryPath(programPath, verbose)) {
return programPath;
}
#ifndef _WIN32
// Try absolute install directory
programPath = APITRACE_PROGRAMS_INSTALL_DIR;
programPath.join(programFilename);
if (tryPath(programPath, verbose)) {
return programPath;
}
#endif
return "";
}
os::String
findWrapper(const char *wrapperFilename, bool verbose)
{
os::String wrapperPath;
os::String processDir = os::getProcessName();
processDir.trimFilename();
// Try relative build directory
// XXX: Just make build and install directory layout match
wrapperPath = processDir;
#if defined(CMAKE_INTDIR)
// Go from `Debug\apitrace.exe` to `wrappers\Debug\foo.dll` on MSVC builds.
wrapperPath.join("..");
wrapperPath.join("wrappers");
wrapperPath.join(CMAKE_INTDIR);
#else
wrapperPath.join("wrappers");
#endif
wrapperPath.join(wrapperFilename);
if (tryPath(wrapperPath, verbose)) {
return wrapperPath;
}
#ifdef __GLIBC__
// We want to take advantage of $LIB dynamic string token expansion in
// glibc dynamic linker to handle multilib layout for us
wrapperPath = processDir;
wrapperPath.join("../$LIB/apitrace/wrappers");
wrapperPath.join(wrapperFilename);
if (tryLib(wrapperPath, verbose)) {
return wrapperPath;
}
#endif
// Try relative install directory
wrapperPath = processDir;
#if defined(_WIN32)
wrapperPath.join("..\\lib\\wrappers");
#elif defined(__APPLE__)
wrapperPath.join("../lib/wrappers");
#else
wrapperPath.join("../lib/apitrace/wrappers");
#endif
wrapperPath.join(wrapperFilename);
if (tryPath(wrapperPath, verbose)) {
return wrapperPath;
}
#ifndef _WIN32
// Try absolute install directory
wrapperPath = APITRACE_WRAPPERS_INSTALL_DIR;
wrapperPath.join(wrapperFilename);
if (tryPath(wrapperPath, verbose)) {
return wrapperPath;
}
#endif
return "";
}
os::String
findScript(const char *scriptFilename, bool verbose)
{
os::String scriptPath;
os::String processDir = os::getProcessName();
processDir.trimFilename();
// Try relative build directory
// XXX: Just make build and install directory layout match
#if defined(APITRACE_SOURCE_DIR)
scriptPath = APITRACE_SOURCE_DIR;
scriptPath.join("scripts");
scriptPath.join(scriptFilename);
if (tryPath(scriptPath, verbose)) {
return scriptPath;
}
#endif
// Try relative install directory
scriptPath = processDir;
#if defined(_WIN32)
scriptPath.join("..\\lib\\scripts");
#elif defined(__APPLE__)
scriptPath.join("../lib/scripts");
#else
scriptPath.join("../lib/apitrace/scripts");
#endif
scriptPath.join(scriptFilename);
if (tryPath(scriptPath, verbose)) {
return scriptPath;
}
#ifndef _WIN32
// Try absolute install directory
scriptPath = APITRACE_SCRIPTS_INSTALL_DIR;
scriptPath.join(scriptFilename);
if (tryPath(scriptPath, verbose)) {
return scriptPath;
}
#endif
std::cerr << "error: cannot find " << scriptFilename << " script\n";
exit(1);
}
| 27.361809 | 98 | 0.661157 | lawlove |
4187378fd1a22a017292b15453fce89bed955fb7 | 232 | cpp | C++ | Tests/LibELF/Dynlib.cpp | r00ster91/serenity | f8387dea2689d564aff612bfd4ec5086393fac35 | [
"BSD-2-Clause"
] | 19,438 | 2019-05-20T15:11:11.000Z | 2022-03-31T23:31:32.000Z | Tests/LibELF/Dynlib.cpp | r00ster91/serenity | f8387dea2689d564aff612bfd4ec5086393fac35 | [
"BSD-2-Clause"
] | 7,882 | 2019-05-20T01:03:52.000Z | 2022-03-31T23:26:31.000Z | Tests/LibELF/Dynlib.cpp | r00ster91/serenity | f8387dea2689d564aff612bfd4ec5086393fac35 | [
"BSD-2-Clause"
] | 2,721 | 2019-05-23T00:44:57.000Z | 2022-03-31T22:49:34.000Z | /*
* Copyright (c) 2021, Rodrigo Tobar <rtobarc@gmail.com>
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#include <LibLine/Span.h>
extern "C" {
int FUNCTION();
int FUNCTION()
{
return (int)Line::Span(0, 0).beginning();
}
}
| 14.5 | 56 | 0.637931 | r00ster91 |
4187faee5ce7f90f29fa96c33890aa8efbc79847 | 30,178 | cpp | C++ | src/gameworld/gameworld/config/activityconfig/questionconfig.cpp | mage-game/metagame-xm-server | 193b67389262803fe0eae742800b1e878b5b3087 | [
"MIT"
] | 3 | 2021-12-16T13:57:28.000Z | 2022-03-26T07:50:08.000Z | src/gameworld/gameworld/config/activityconfig/questionconfig.cpp | mage-game/metagame-xm-server | 193b67389262803fe0eae742800b1e878b5b3087 | [
"MIT"
] | null | null | null | src/gameworld/gameworld/config/activityconfig/questionconfig.cpp | mage-game/metagame-xm-server | 193b67389262803fe0eae742800b1e878b5b3087 | [
"MIT"
] | 1 | 2022-03-26T07:50:11.000Z | 2022-03-26T07:50:11.000Z | #include "questionconfig.hpp"
#include "servercommon/configcommon.h"
#include "checkresourcecenter.hpp"
#include"item/itempool.h"
QuestionConfig::QuestionConfig()
{
}
QuestionConfig::~QuestionConfig()
{
}
bool QuestionConfig::Init(const std::string &path, std::string *err)
{
PugiXmlDocument document;
PUGI_XML_LOAD_AND_CHECK(document, path, "QuestionConfig", *err);
PugiXmlNode RootElement = document.document_element();
if (RootElement.empty())
{
*err = path + ": xml root node error.";
return false;
}
{
PugiXmlNode questionListElement = RootElement.child("questionlist");
if (questionListElement.empty())
{
*err = path + ": xml node error in [questionlist]";
return false;
}
PugiXmlNode questionElement = questionListElement.child("data");
if (questionElement.empty())
{
*err = path + ": xml node error in [questionlist->question]";
return false;
}
while (!questionElement.empty())
{
int question_type = QUESTION_TYPE_INVALID;
if (!PugiGetSubNodeValue(questionElement, "question_type", question_type) || question_type <= QUESTION_TYPE_INVALID || question_type >= QUESTION_TYPE_MAX)
{
*err = path + ": xml node error in [question_list->question->question_type]";
return false;
}
int question_id = 0;
if (!PugiGetSubNodeValue(questionElement, "question_id", question_id) || question_id <= 0)
{
*err = path + ": xml node error in [question_list->question->question_id]";
return false;
}
if (QUESTION_TYPE_HOTSPRING == question_type)
{
if (m_hotspring_question_map.find(question_id) != m_hotspring_question_map.end())
{
*err = path + ": xml node error in [hotspring_question_list->question->id repeat]";
return false;
}
}
else if(QUESTION_TYPE_WORLD == question_type)
{
if (m_world_question_map.find(question_id) != m_world_question_map.end())
{
*err = path + ": xml node error in [world_question_list->question->id repeat]";
return false;
}
}
else if(QUESTION_TYPE_GUILD == question_type)
{
if (m_guild_question_map.find(question_id) != m_guild_question_map.end())
{
*err = path + ": xml node error in [guild_question_list->question->id repeat]";
return false;
}
}
else
{
*err = path + ": xml node error in question_type, question_type error";
return false;
}
QuestionCfg question_cfg;
{
std::string question_str;
if (!PugiGetSubNodeValue(questionElement, "content", question_str))
{
*err = path + ": xml node error in [question_list->question->content]";
return false;
}
if (question_str.length() >= sizeof(QuestionStr))
{
*err = path + ": xml node error in [question_list->question->timu too long]";
return false;
}
memcpy(question_cfg.question_str, question_str.c_str(), (int)question_str.length());
question_cfg.question_str[question_str.length()] = '\0';
}
{
std::string answer_desc_str;
if (!PugiGetSubNodeValue(questionElement, "answer_desc_0", answer_desc_str))
{
*err = path + ": xml node error in [question_list->question->answer_desc_0]";
return false;
}
if (answer_desc_str.length() >= sizeof(QuestionStr))
{
*err = path + ": xml node error in [question_list->question->answer_desc_0 too long]";
return false;
}
memcpy(question_cfg.answer_desc_0, answer_desc_str.c_str(), (int)answer_desc_str.length());
question_cfg.answer_desc_0[answer_desc_str.length()] = '\0';
}
{
std::string answer_desc_str;
if (!PugiGetSubNodeValue(questionElement, "answer_desc_1", answer_desc_str))
{
*err = path + ": xml node error in [question_list->question->answer_desc_1]";
return false;
}
if (answer_desc_str.length() >= sizeof(QuestionStr))
{
*err = path + ": xml node error in [question_list->question->answer_desc_1 too long]";
return false;
}
memcpy(question_cfg.answer_desc_1, answer_desc_str.c_str(), (int)answer_desc_str.length());
question_cfg.answer_desc_1[answer_desc_str.length()] = '\0';
}
{
std::string answer_desc_str;
if (!PugiGetSubNodeValue(questionElement, "answer_desc_2", answer_desc_str))
{
*err = path + ": xml node error in [question_list->question->answer_desc_2]";
return false;
}
if (answer_desc_str.length() >= sizeof(QuestionStr))
{
*err = path + ": xml node error in [question_list->question->answer_desc_2 too long]";
return false;
}
memcpy(question_cfg.answer_desc_2, answer_desc_str.c_str(), (int)answer_desc_str.length());
question_cfg.answer_desc_2[answer_desc_str.length()] = '\0';
}
{
std::string answer_desc_str;
if (!PugiGetSubNodeValue(questionElement, "answer_desc_3", answer_desc_str))
{
*err = path + ": xml node error in [question_list->question->answer_desc_3]";
return false;
}
if (answer_desc_str.length() >= sizeof(QuestionStr))
{
*err = path + ": xml node error in [question_list->question->answer_desc_3 too long]";
return false;
}
memcpy(question_cfg.answer_desc_3, answer_desc_str.c_str(), (int)answer_desc_str.length());
question_cfg.answer_desc_3[answer_desc_str.length()] = '\0';
}
if (!PugiGetSubNodeValue(questionElement, "answer", question_cfg.answer) || question_cfg.answer < 0)
{
*err = path + ": xml node error in [question_list->question->id]";
return false;
}
if (QUESTION_TYPE_HOTSPRING == question_type)
{
m_hotspring_question_map[question_id] = question_cfg;
}
else if (QUESTION_TYPE_WORLD == question_type)
{
m_world_question_map[question_id] = question_cfg;
}
else if (QUESTION_TYPE_GUILD == question_type)
{
m_guild_question_map[question_id] = question_cfg;
}
questionElement = questionElement.next_sibling();
}
}
{
PugiXmlNode rewardListElement = RootElement.child("reward");
if (rewardListElement.empty())
{
*err = path + ": xml node error in [reward_list]";
return false;
}
PugiXmlNode rewardElement = rewardListElement.child("data");
if (rewardElement.empty())
{
*err = path + ": xml node error in [reward_list->reward]";
return false;
}
int last_level = 0;
while (!rewardElement.empty())
{
int level = 0;
if (!PugiGetSubNodeValue(rewardElement, "rolelevel", level) || level != last_level + 1|| last_level > MAX_ROLE_LEVEL)
{
*err = path + ": xml node error in [reward_list->reward->rolelevel]";
return false;
}
if (!PugiGetSubNodeValue(rewardElement, "exp", m_reward_list[level].exp) || m_reward_list[level].exp < 0)
{
*err = path + ": xml node error in [reward_list->reward->exp]";
return false;
}
if (!PugiGetSubNodeValue(rewardElement, "yuanli", m_reward_list[level].yuanli) || m_reward_list[level].yuanli < 0)
{
*err = path + ": xml node error in [reward_list->reward->yuanli]";
return false;
}
if (!PugiGetSubNodeValue(rewardElement, "xianhun", m_reward_list[level].xianhun) || m_reward_list[level].xianhun < 0)
{
*err = path + ": xml node error in [reward_list->reward->xianhun]";
return false;
}
if (!PugiGetSubNodeValue(rewardElement, "gold_answer_per_question", m_reward_list[level].batch_answser_cost_per_question)
|| m_reward_list[level].batch_answser_cost_per_question <= 0)
{
*err = path + ": xml node error in [reward_list->reward->gold_answer_per_question]";
return false;
}
if (!PugiGetSubNodeValue(rewardElement, "wrong_answer_percentage", m_reward_list[level].wrong_answer_percentage)
|| m_reward_list[level].wrong_answer_percentage < 0 || m_reward_list[level].wrong_answer_percentage > 100)
{
*err = path + ": xml node error in [reward_list->reward->wrong_answer_percentage]";
return false;
}
{
PugiXmlNode element = rewardElement.child("reward_item_list");
if (element.empty())
{
*err = path + ": xml node error in [reward_list->reward->reward_item]";
return false;
}
int i = 0;
PugiXmlNode item_element = element.child("reward_item");
while (!item_element.empty())
{
if (i >= MAX_ATTACHMENT_ITEM_NUM)
{
*err = path + ": xml node error in [reward_list->reward->reward_item]";
return false;
}
if (!m_reward_list[level].reward_item[i].ReadConfig(item_element))
{
if (m_reward_list[level].reward_item[i].item_id == 0) break;
*err = path + ": xml node error in [reward_list->reward->reward_item]";
return false;
}
i++;
item_element = item_element.next_sibling();
}
}
last_level = level;
rewardElement = rewardElement.next_sibling();
}
}
{
PugiXmlNode otherListElement = RootElement.child("other");
if (otherListElement.empty())
{
*err = path + ": xml node error in [other_list]";
return false;
}
PugiXmlNode otherElement = otherListElement.child("data");
if (otherElement.empty())
{
*err = path + ": xml node error in [other_list->other]";
return false;
}
if (!PugiGetSubNodeValue(otherElement, "scene_id", m_other_cfg.scene_id) || m_other_cfg.scene_id <= 0)
{
*err = path + ": xml node error in [other_list->other->scene_id]";
return false;
}
CheckResourceCenter::Instance().GetSceneCheck()->Add(m_other_cfg.scene_id);
if (!PugiGetSubNodeValue(otherElement, "realive_pos_x", m_other_cfg.m_realive_area.x) || m_other_cfg.m_realive_area.x < 0)
{
*err = path + ": xml node error in [other_list->other->realive_pos_x]";
return false;
}
if (!PugiGetSubNodeValue(otherElement, "realive_pos_y", m_other_cfg.m_realive_area.y) || m_other_cfg.m_realive_area.y < 0)
{
*err = path + ": xml node error in [other_list->other->realive_pos_y]";
return false;
}
if (!PugiGetSubNodeValue(otherElement, "mianda_card", m_other_cfg.mianda_card_id) || NULL == ITEMPOOL->GetItem(m_other_cfg.mianda_card_id))
{
*err = path + ": xml node error in [other_list->other->mianda_card_id]";
return false;
}
if (!PugiGetSubNodeValue(otherElement, "bianshen_card", m_other_cfg.bianshen_card_id) || NULL == ITEMPOOL->GetItem(m_other_cfg.bianshen_card_id))
{
*err = path + ": xml node error in [other_list->other->bianshen_card_id]";
return false;
}
if (!PugiGetSubNodeValue(otherElement, "pig_slow_down_per", m_other_cfg.pig_slow_down_per) || m_other_cfg.pig_slow_down_per < 0)
{
*err = path + ": xml node error in [other_list->other->pig_slow_down_per]";
return false;
}
if (!PugiGetSubNodeValue(otherElement, "rabbit_speed_up_per", m_other_cfg.rabbit_speed_up_per) || m_other_cfg.rabbit_speed_up_per < 0)
{
*err = path + ": xml node error in [other_list->other->rabbit_slow_dwon_per]";
return false;
}
if (!PugiGetSubNodeValue(otherElement, "bianshen_pro", m_other_cfg.bianshen_pro) || m_other_cfg.bianshen_pro < 0)
{
*err = path + ": xml node error in [other_list->other->bianshen_pro]";
return false;
}
if (!PugiGetSubNodeValue(otherElement, "rabbit_pro", m_other_cfg.rabbit_pro) || m_other_cfg.rabbit_pro < 0)
{
*err = path + ": xml node error in [other_list->other->rabbit_pro]";
return false;
}
if (!PugiGetSubNodeValue(otherElement, "mianda_pro", m_other_cfg.mianda_pro) || m_other_cfg.mianda_pro < 0)
{
*err = path + ": xml node error in [other_list->other->mianda_pro]";
return false;
}
if (!PugiGetSubNodeValue(otherElement, "activity_prepare_time", m_other_cfg.activity_prepare_time) || m_other_cfg.activity_prepare_time <= 0)
{
*err = path + ": xml node error in [other_list->other->activity_prepare_time]";
return false;
}
if (!PugiGetSubNodeValue(otherElement, "answer_prepare_time", m_other_cfg.answer_prepare_time) || m_other_cfg.answer_prepare_time <= 0)
{
*err = path + ": xml node error in [other_list->other->answer_prepare_time]";
return false;
}
if (!PugiGetSubNodeValue(otherElement, "answer_continue_time", m_other_cfg.answer_continue_time) || m_other_cfg.answer_continue_time <= 0)
{
*err = path + ": xml node error in [other_list->other->answer_continue_time]";
return false;
}
if (!PugiGetSubNodeValue(otherElement, "bianshen_continue_time", m_other_cfg.bianshen_continue_time) || m_other_cfg.bianshen_continue_time <= 0)
{
*err = path + ": xml node error in [other_list->other->bianshen_continue_time]";
return false;
}
if (!PugiGetSubNodeValue(otherElement, "total_question_count", m_other_cfg.total_question_count) || m_other_cfg.total_question_count <= 0)
{
*err = path + ": xml node error in [other_list->other->total_question_count]";
return false;
}
{
PugiXmlNode element = otherElement.child("common_reward_list");
if (element.empty())
{
*err = path + ": xml node error in [other_list->other->common_reward_list]";
return false;
}
int i = 0;
PugiXmlNode item_element = element.child("common_reward");
while (!item_element.empty())
{
if (i >= MAX_ATTACHMENT_ITEM_NUM)
{
*err = path + ": xml node error in [other_list->other->common_reward]";
return false;
}
if (!m_other_cfg.common_item[i].ReadConfig(item_element))
{
if (m_other_cfg.common_item[i].item_id == 0) break;
*err = path + ": xml node error in [other_list->other->common_reward]";
return false;
}
i++;
item_element = item_element.next_sibling();
}
}
{
PugiXmlNode element = otherElement.child("guild_rank_other_reward_list");
if (element.empty())
{
*err = path + ": xml node error in [other_list->other->guild_rank_other_reward_list]";
return false;
}
int i = 0;
PugiXmlNode item_element = element.child("guild_rank_other_reward");
while (!item_element.empty())
{
if (i >= MAX_ATTACHMENT_ITEM_NUM)
{
*err = path + ": xml node error in [other_list->other->guild_rank_other_reward]";
return false;
}
if (!m_other_cfg.guild_rank_other_reward[i].ReadConfig(item_element))
{
if (m_other_cfg.guild_rank_other_reward[i].item_id == 0) break;
*err = path + ": xml node error in [other_list->other->common_reward]";
return false;
}
i++;
item_element = item_element.next_sibling();
}
if (!PugiGetSubNodeValue(otherElement, "right_world_factor", m_other_cfg.right_world_factor) || m_other_cfg.right_world_factor < 0)
{
*err = path + ": xml node error in [other_list->other->right_world_factor]";
return false;
}
if (!PugiGetSubNodeValue(otherElement, "wrong_world_factor", m_other_cfg.wrong_world_factor) || m_other_cfg.wrong_world_factor < 0)
{
*err = path + ": xml node error in [other_list->other->wrong_world_factor]";
return false;
}
if (!PugiGetSubNodeValue(otherElement, "right_hotspring_factor", m_other_cfg.right_hotspring_factor) || m_other_cfg.right_hotspring_factor < 0)
{
*err = path + ": xml node error in [other_list->other->right_hotspring_factor]";
return false;
}
if (!PugiGetSubNodeValue(otherElement, "wrong_hotspring_factor", m_other_cfg.wrong_hotspring_factor) || m_other_cfg.wrong_hotspring_factor < 0)
{
*err = path + ": xml node error in [other_list->other->wrong_hotspring_factor]";
return false;
}
}
}
{
PugiXmlNode rankListElement = RootElement.child("rank_reward");
if (rankListElement.empty())
{
*err = path + ": xml node error in [rank_reward]";
return false;
}
PugiXmlNode rankElement = rankListElement.child("data");
if (rankElement.empty())
{
*err = path + ": xml node error in [rank_reward_list->rank_reward]";
return false;
}
int rank_last = 0;
while (!rankElement.empty())
{
int rank = 0;
if (!PugiGetSubNodeValue(rankElement, "rank", rank) || rank < 0 || rank < rank_last)
{
*err = path + ": xml node error in [rank_reward_list->scene_id]";
return false;
}
HSQuestionRankRewardCfg rank_reward_cfg;
rank_reward_cfg.rank = rank;
rank_last = rank;
{
PugiXmlNode element = rankElement.child("rank_reward_list");
if (element.empty())
{
*err = path + ": xml node error in [rank_reward_list->rank_reward_list]";
return false;
}
int i = 0;
PugiXmlNode item_element = element.child("rank_reward");
while (!item_element.empty())
{
if (i >= MAX_ATTACHMENT_ITEM_NUM)
{
*err = path + ": xml node error in [rank_reward_list->rank_reward]";
return false;
}
if (!rank_reward_cfg.rank_reward_item[i].ReadConfig(item_element))
{
if (rank_reward_cfg.rank_reward_item[i].item_id == 0) break;
*err = path + ": xml node error in [rank_reward_list->rank_reward]";
return false;
}
i++;
item_element = item_element.next_sibling();
}
}
m_question_rank_reward[rank] = rank_reward_cfg;
rankElement = rankElement.next_sibling();
}
}
{
PugiXmlNode WGQuestionElement = RootElement.child("wg_question");
if (WGQuestionElement.empty())
{
*err = path + ": xml node error in [wg_question]";
return false;
}
PugiXmlNode WGElement = WGQuestionElement.child("data");
if (WGElement.empty())
{
*err = path + ": xml node error in [wg_question]";
return false;
}
while (!WGElement.empty())
{
int question_type = QUESTION_TYPE_INVALID;
if (!PugiGetSubNodeValue(WGElement, "question_type", question_type) || question_type <= QUESTION_TYPE_INVALID || question_type >= QUESTION_TYPE_MAX)
{
*err = path + ": xml node error in [wg_question->question_type]";
return false;
}
WGQuestionCfg &cfg = m_wg_question_cfg[question_type];
cfg.question_type = question_type;
if (!PugiGetSubNodeValue(WGElement, "open_level", cfg.open_level) || cfg.open_level <= 0 || cfg.open_level > MAX_ROLE_LEVEL)
{
*err = path + ": xml node error in [wg_question->open_level]";
return false;
}
if (!PugiGetSubNodeValue(WGElement, "begin_time", cfg.begin_time) || cfg.begin_time < 0)
{
*err = path + ": xml node error in [wg_question->begin_time]";
return false;
}
if (!PugiGetSubNodeValue(WGElement, "end_time", cfg.end_time) || cfg.end_time < 0)
{
*err = path + ": xml node error in [wg_question->end_time]";
return false;
}
if (!PugiGetSubNodeValue(WGElement, "question_interval", cfg.question_interval) || cfg.question_interval < 0)
{
*err = path + ": xml node error in [wg_question->question_interval]";
return false;
}
if (!PugiGetSubNodeValue(WGElement, "answer_continue_time", cfg.answer_continue_time) || cfg.answer_continue_time < 0)
{
*err = path + ": xml node error in [wg_question->answer_continue_time]";
return false;
}
if (!PugiGetSubNodeValue(WGElement, "right_exp_reward", cfg.right_exp_reward) || cfg.right_exp_reward < 0)
{
*err = path + ": xml node error in [wg_question->right_exp_reward]";
return false;
}
if (!PugiGetSubNodeValue(WGElement, "wrong_exp_reward", cfg.wrong_exp_reward) || cfg.wrong_exp_reward < 0)
{
*err = path + ": xml node error in [wg_question->wrong_exp_reward]";
return false;
}
if (!PugiGetSubNodeValue(WGElement, "fast_reward_num", cfg.fast_reward_num) || cfg.fast_reward_num < 0)
{
*err = path + ": xml node error in [wg_question->fast_reward_num]";
return false;
}
{
PugiXmlNode element = WGElement.child("fast_reward_list");
if (element.empty())
{
*err = path + ": xml node error in [wg_question->fast_reward_list]";
return false;
}
int i = 0;
PugiXmlNode item_element = element.child("fast_reward");
while (!item_element.empty())
{
if (i >= MAX_ATTACHMENT_ITEM_NUM)
{
*err = path + ": xml node error in [wg_question->fast_reward]";
return false;
}
if (!cfg.fast_reward[i].ReadConfig(item_element))
{
if (cfg.fast_reward[i].item_id == 0) break;
*err = path + ": xml node error in [wg_question->fast_reward]";
return false;
}
i++;
item_element = item_element.next_sibling();
}
}
WGElement = WGElement.next_sibling();
}
}
{
PugiXmlNode QGuildRankElement = RootElement.child("g_rank_reward");
if (QGuildRankElement.empty())
{
*err = path + ": xml node error in [g_rank_reward]";
return false;
}
PugiXmlNode GuildRankElement = QGuildRankElement.child("data");
if (GuildRankElement.empty())
{
*err = path + ": xml node error in [g_rank_reward]";
return false;
}
while (!GuildRankElement.empty())
{
int rank = 0;
if (!PugiGetSubNodeValue(GuildRankElement, "rank", rank) || rank <= 0 || m_question_guild_rank_reward.find(rank) != m_question_guild_rank_reward.end())
{
*err = path + ": xml node error in [g_rank_reward->rank]";
return false;
}
QuestionGuildRankRewardCfg &cfg = m_question_guild_rank_reward[rank];
cfg.rank = rank;
{
PugiXmlNode element = GuildRankElement.child("rank_reward_list");
if (element.empty())
{
*err = path + ": xml node error in [g_rank_reward->rank_reward_list]";
return false;
}
int i = 0;
PugiXmlNode item_element = element.child("rank_reward");
while (!item_element.empty())
{
if (i >= MAX_ATTACHMENT_ITEM_NUM)
{
*err = path + ": xml node error in [g_rank_reward->rank_reward]";
return false;
}
if (!cfg.rank_reward[i].ReadConfig(item_element))
{
if (cfg.rank_reward[i].item_id == 0) break;
*err = path + ": xml node error in [g_rank_reward->rank_reward]";
return false;
}
i++;
item_element = item_element.next_sibling();
}
}
GuildRankElement = GuildRankElement.next_sibling();
}
}
return true;
}
int QuestionConfig::GetQuestionEnterInfo(Posi *pos)
{
if (NULL == pos) return 0;
*pos = m_other_cfg.m_realive_area;
return m_other_cfg.scene_id;
}
int QuestionConfig::RandQuestionID(int *answer, int question_type)
{
if (question_type <= QUESTION_TYPE_INVALID || question_type >= QUESTION_TYPE_MAX) return 0;
switch (question_type)
{
case QUESTION_TYPE_HOTSPRING:
{
if (m_hotspring_question_map.empty()) return 0;
std::map<int, QuestionCfg>::iterator it = m_hotspring_question_map.begin();
int rand_index = RandomNum(static_cast<int>(m_hotspring_question_map.size()));
std::advance(it, rand_index);
if (NULL != answer) *answer = it->second.answer;
return it->first;
}
break;
case QUESTION_TYPE_WORLD:
{
if (m_world_question_map.empty()) return 0;
std::map<int, QuestionCfg>::iterator it = m_world_question_map.begin();
int rand_index = RandomNum(static_cast<int>(m_world_question_map.size()));
std::advance(it, rand_index);
if (NULL != answer) *answer = it->second.answer;
return it->first;
}
break;
case QUESTION_TYPE_GUILD:
{
if (m_guild_question_map.empty()) return 0;
std::map<int, QuestionCfg>::iterator it = m_guild_question_map.begin();
int rand_index = RandomNum(static_cast<int>(m_guild_question_map.size()));
std::advance(it, rand_index);
if (NULL != answer) *answer = it->second.answer;
return it->first;
}
break;
default:
break;
}
return 0;
}
void QuestionConfig::GetQuestionStr(int question_id, QuestionStr question_str, int question_type)
{
question_str[0] = 0;
switch (question_type)
{
case QUESTION_TYPE_HOTSPRING:
{
std::map<int, QuestionCfg>::iterator it = m_hotspring_question_map.find(question_id);
if (it != m_hotspring_question_map.end())
{
F_STRNCPY(question_str, it->second.question_str, sizeof(QuestionStr));
}
}
break;
case QUESTION_TYPE_WORLD:
{
std::map<int, QuestionCfg>::iterator it = m_world_question_map.find(question_id);
if (it != m_world_question_map.end())
{
F_STRNCPY(question_str, it->second.question_str, sizeof(QuestionStr));
}
}
break;
case QUESTION_TYPE_GUILD:
{
std::map<int, QuestionCfg>::iterator it = m_guild_question_map.find(question_id);
if (it != m_guild_question_map.end())
{
F_STRNCPY(question_str, it->second.question_str, sizeof(QuestionStr));
}
}
break;
default:
break;
}
}
void QuestionConfig::GetAnswer0DescStr(int question_id, QuestionStr answer_desc_str, int question_type)
{
answer_desc_str[0] = 0;
switch (question_type)
{
case QUESTION_TYPE_HOTSPRING:
{
std::map<int, QuestionCfg>::iterator it = m_hotspring_question_map.find(question_id);
if (it != m_hotspring_question_map.end())
{
F_STRNCPY(answer_desc_str, it->second.answer_desc_0, sizeof(QuestionStr));
}
}
break;
case QUESTION_TYPE_WORLD:
{
std::map<int, QuestionCfg>::iterator it = m_world_question_map.find(question_id);
if (it != m_world_question_map.end())
{
F_STRNCPY(answer_desc_str, it->second.answer_desc_0, sizeof(QuestionStr));
}
}
break;
case QUESTION_TYPE_GUILD:
{
std::map<int, QuestionCfg>::iterator it = m_guild_question_map.find(question_id);
if (it != m_guild_question_map.end())
{
F_STRNCPY(answer_desc_str, it->second.answer_desc_0, sizeof(QuestionStr));
}
}
break;
default:
break;
}
}
void QuestionConfig::GetAnswer1DescStr(int question_id, QuestionStr answer_desc_str, int question_type)
{
answer_desc_str[0] = 0;
switch (question_type)
{
case QUESTION_TYPE_HOTSPRING:
{
std::map<int, QuestionCfg>::iterator it = m_hotspring_question_map.find(question_id);
if (it != m_hotspring_question_map.end())
{
F_STRNCPY(answer_desc_str, it->second.answer_desc_1, sizeof(QuestionStr));
}
}
break;
case QUESTION_TYPE_WORLD:
{
std::map<int, QuestionCfg>::iterator it = m_world_question_map.find(question_id);
if (it != m_world_question_map.end())
{
F_STRNCPY(answer_desc_str, it->second.answer_desc_1, sizeof(QuestionStr));
}
}
break;
case QUESTION_TYPE_GUILD:
{
std::map<int, QuestionCfg>::iterator it = m_guild_question_map.find(question_id);
if (it != m_guild_question_map.end())
{
F_STRNCPY(answer_desc_str, it->second.answer_desc_1, sizeof(QuestionStr));
}
}
break;
default:
break;
}
}
void QuestionConfig::GetAnswer2DescStr(int question_id, QuestionStr answer_desc_str, int question_type)
{
answer_desc_str[0] = 0;
switch (question_type)
{
case QUESTION_TYPE_HOTSPRING:
{
std::map<int, QuestionCfg>::iterator it = m_hotspring_question_map.find(question_id);
if (it != m_hotspring_question_map.end())
{
F_STRNCPY(answer_desc_str, it->second.answer_desc_2, sizeof(QuestionStr));
}
}
break;
case QUESTION_TYPE_WORLD:
{
std::map<int, QuestionCfg>::iterator it = m_world_question_map.find(question_id);
if (it != m_world_question_map.end())
{
F_STRNCPY(answer_desc_str, it->second.answer_desc_2, sizeof(QuestionStr));
}
}
break;
case QUESTION_TYPE_GUILD:
{
std::map<int, QuestionCfg>::iterator it = m_guild_question_map.find(question_id);
if (it != m_guild_question_map.end())
{
F_STRNCPY(answer_desc_str, it->second.answer_desc_2, sizeof(QuestionStr));
}
}
break;
default:
break;
}
}
void QuestionConfig::GetAnswer3DescStr(int question_id, QuestionStr answer_desc_str, int question_type)
{
answer_desc_str[0] = 0;
switch (question_type)
{
case QUESTION_TYPE_HOTSPRING:
{
std::map<int, QuestionCfg>::iterator it = m_hotspring_question_map.find(question_id);
if (it != m_hotspring_question_map.end())
{
F_STRNCPY(answer_desc_str, it->second.answer_desc_3, sizeof(QuestionStr));
}
}
break;
case QUESTION_TYPE_WORLD:
{
std::map<int, QuestionCfg>::iterator it = m_world_question_map.find(question_id);
if (it != m_world_question_map.end())
{
F_STRNCPY(answer_desc_str, it->second.answer_desc_3, sizeof(QuestionStr));
}
}
break;
case QUESTION_TYPE_GUILD:
{
std::map<int, QuestionCfg>::iterator it = m_guild_question_map.find(question_id);
if (it != m_guild_question_map.end())
{
F_STRNCPY(answer_desc_str, it->second.answer_desc_3, sizeof(QuestionStr));
}
}
break;
default:
break;
}
}
int QuestionConfig::GetAnswer(int question_id, int question_type)
{
switch (question_type)
{
case QUESTION_TYPE_HOTSPRING:
{
std::map<int, QuestionCfg>::iterator it = m_hotspring_question_map.find(question_id);
if (it != m_hotspring_question_map.end())
{
return it->second.answer;
}
}
break;
case QUESTION_TYPE_WORLD:
{
std::map<int, QuestionCfg>::iterator it = m_world_question_map.find(question_id);
if (it != m_world_question_map.end())
{
return it->second.answer;
}
}
break;
case QUESTION_TYPE_GUILD:
{
std::map<int, QuestionCfg>::iterator it = m_guild_question_map.find(question_id);
if (it != m_guild_question_map.end())
{
return it->second.answer;
}
}
break;
default:
break;
}
return 0;
}
int QuestionConfig::HotSpringCalcScore(int answer_time)
{
const static int LIMIT_ANSWER_TIME = 15;
const static int FULL_SCORRE_MAX_TIME = 5;
int score = 0;
if (answer_time >= LIMIT_ANSWER_TIME)
{
return score;
}
if (answer_time <= FULL_SCORRE_MAX_TIME)
{
score = 10;
}
else
{
score = LIMIT_ANSWER_TIME - answer_time;
}
return score;
}
const HSQuestionRewardCfg* QuestionConfig::GetHotSpringRewardCfg(int role_level)
{
if (0 < role_level && role_level <= MAX_ROLE_LEVEL)
{
return &m_reward_list[role_level];
}
return NULL;
}
const HSQuestionRankRewardCfg * QuestionConfig::GetHotSpringRankRewardCfg(int rank)
{
if (rank < 0) return NULL;
const std::map<int, HSQuestionRankRewardCfg>::const_iterator iter = m_question_rank_reward.find(rank);
if (m_question_rank_reward.end() == iter)
return NULL;
return &iter->second;
}
const WGQuestionCfg * QuestionConfig::GetWGQuestionCfg(int question_type)
{
if (question_type <= QUESTION_TYPE_INVALID || question_type >= QUESTION_TYPE_MAX) return NULL;
WGQuestionCfg &cfg = m_wg_question_cfg[question_type];
if (cfg.question_type != question_type)
{
return NULL;
}
return &cfg;
}
QuestionGuildRankRewardCfg * QuestionConfig::GetQuestionGuildRankReward(int rank)
{
std::map<int, QuestionGuildRankRewardCfg>::iterator iter = m_question_guild_rank_reward.find(rank);
if (iter != m_question_guild_rank_reward.end() && iter->second.rank == rank)
{
return &iter->second;
}
return NULL;
} | 27.534672 | 157 | 0.685499 | mage-game |
418d65eaae40934dffc51f5205c79d2a320ebce1 | 9,676 | hxx | C++ | opencascade/NCollection_List.hxx | valgur/OCP | 2f7d9da73a08e4ffe80883614aedacb27351134f | [
"Apache-2.0"
] | 117 | 2020-03-07T12:07:05.000Z | 2022-03-27T07:35:22.000Z | opencascade/NCollection_List.hxx | CadQuery/cpp-py-bindgen | 66e7376d3a27444393fc99acbdbef40bbc7031ae | [
"Apache-2.0"
] | 66 | 2019-12-20T16:07:36.000Z | 2022-03-15T21:56:10.000Z | opencascade/NCollection_List.hxx | CadQuery/cpp-py-bindgen | 66e7376d3a27444393fc99acbdbef40bbc7031ae | [
"Apache-2.0"
] | 76 | 2020-03-16T01:47:46.000Z | 2022-03-21T16:37:07.000Z | // Created on: 2002-04-17
// Created by: Alexander Kartomin (akm)
// Copyright (c) 2002-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#ifndef NCollection_List_HeaderFile
#define NCollection_List_HeaderFile
#include <NCollection_TListIterator.hxx>
#include <NCollection_StlIterator.hxx>
#include <Standard_NoSuchObject.hxx>
/**
* Purpose: Simple list to link items together keeping the first
* and the last one.
* Inherits BaseList, adding the data item to each node.
*/
template <class TheItemType>
class NCollection_List : public NCollection_BaseList
{
public:
//! STL-compliant typedef for value type
typedef TheItemType value_type;
public:
typedef NCollection_TListNode<TheItemType> ListNode;
typedef NCollection_TListIterator<TheItemType> Iterator;
//! Shorthand for a regular iterator type.
typedef NCollection_StlIterator<std::forward_iterator_tag, Iterator, TheItemType, false> iterator;
//! Shorthand for a constant iterator type.
typedef NCollection_StlIterator<std::forward_iterator_tag, Iterator, TheItemType, true> const_iterator;
//! Returns an iterator pointing to the first element in the list.
iterator begin() const { return Iterator (*this); }
//! Returns an iterator referring to the past-the-end element in the list.
iterator end() const { return Iterator(); }
//! Returns a const iterator pointing to the first element in the list.
const_iterator cbegin() const { return Iterator (*this); }
//! Returns a const iterator referring to the past-the-end element in the list.
const_iterator cend() const { return Iterator(); }
public:
// ---------- PUBLIC METHODS ------------
//! Empty constructor.
NCollection_List() : NCollection_BaseList(Handle(NCollection_BaseAllocator)()) {}
//! Constructor
explicit NCollection_List(const Handle(NCollection_BaseAllocator)& theAllocator) : NCollection_BaseList(theAllocator) {}
//! Copy constructor
NCollection_List (const NCollection_List& theOther) :
NCollection_BaseList(theOther.myAllocator)
{
Assign (theOther);
}
//! Size - Number of items
Standard_Integer Size (void) const
{ return Extent(); }
//! Replace this list by the items of another list (theOther parameter).
//! This method does not change the internal allocator.
NCollection_List& Assign (const NCollection_List& theOther)
{
if (this != &theOther) {
Clear();
appendList(theOther.PFirst());
}
return *this;
}
//! Replacement operator
NCollection_List& operator= (const NCollection_List& theOther)
{
return Assign (theOther);
}
//! Clear this list
void Clear (const Handle(NCollection_BaseAllocator)& theAllocator=0L)
{
PClear (ListNode::delNode);
if (!theAllocator.IsNull())
this->myAllocator = theAllocator;
}
//! First item
const TheItemType& First (void) const
{
Standard_NoSuchObject_Raise_if (IsEmpty(), "NCollection_List::First");
return ((const ListNode *) PFirst())->Value();
}
//! First item (non-const)
TheItemType& First (void)
{
Standard_NoSuchObject_Raise_if (IsEmpty(), "NCollection_List::First");
return ((ListNode *) PFirst())->ChangeValue();
}
//! Last item
const TheItemType& Last (void) const
{
Standard_NoSuchObject_Raise_if (IsEmpty(), "NCollection_List::Last");
return ((const ListNode *) PLast())->Value();
}
//! Last item (non-const)
TheItemType& Last (void)
{
Standard_NoSuchObject_Raise_if (IsEmpty(), "NCollection_List::Last");
return ((ListNode *) PLast())->ChangeValue();
}
//! Append one item at the end
TheItemType& Append (const TheItemType& theItem)
{
ListNode * pNew = new (this->myAllocator) ListNode(theItem);
PAppend(pNew);
return ((ListNode *) PLast())->ChangeValue();
}
//! Append one item at the end and output iterator
//! pointing at the appended item
void Append (const TheItemType& theItem, Iterator& theIter)
{
ListNode * pNew = new (this->myAllocator) ListNode(theItem);
PAppend(pNew, theIter);
}
//! Append another list at the end.
//! After this operation, theOther list will be cleared.
void Append (NCollection_List& theOther)
{
if (this == &theOther || theOther.Extent()<1)
return;
if (this->myAllocator == theOther.myAllocator)
{
// Then we take the list and glue it to our end -
// deallocation will bring no problem
PAppend(theOther);
}
else
{
// No - this list has different memory scope
appendList(theOther.myFirst);
theOther.Clear();
}
}
//! Prepend one item at the beginning
TheItemType& Prepend (const TheItemType& theItem)
{
ListNode * pNew = new (this->myAllocator) ListNode(theItem);
PPrepend(pNew);
return ((ListNode *) PFirst())->ChangeValue();
}
//! Prepend another list at the beginning
void Prepend (NCollection_List& theOther)
{
if (this == &theOther || theOther.Extent()<1)
return;
if (this->myAllocator == theOther.myAllocator)
{
// Then we take the list and glue it to our head -
// deallocation will bring no problem
PPrepend(theOther);
}
else
{
// No - this list has different memory scope
Iterator it(*this);
prependList(theOther.PFirst(), it);
theOther.Clear();
}
}
//! RemoveFirst item
void RemoveFirst (void)
{ PRemoveFirst (ListNode::delNode); }
//! Remove item pointed by iterator theIter;
//! theIter is then set to the next item
void Remove (Iterator& theIter)
{
PRemove (theIter, ListNode::delNode);
}
//! Remove the first occurrence of the object.
template<typename TheValueType> // instantiate this method on first call only for types defining equality operator
Standard_Boolean Remove (const TheValueType& theObject)
{
for (Iterator anIter (*this); anIter.More(); anIter.Next())
{
if (anIter.Value() == theObject)
{
Remove (anIter);
return Standard_True;
}
}
return Standard_False;
}
//! InsertBefore
TheItemType& InsertBefore (const TheItemType& theItem,
Iterator& theIter)
{
ListNode * pNew = new (this->myAllocator) ListNode(theItem);
PInsertBefore (pNew, theIter);
return pNew -> ChangeValue();
}
//! InsertBefore
void InsertBefore (NCollection_List& theOther,
Iterator& theIter)
{
if (this == &theOther)
return;
if (this->myAllocator == theOther.myAllocator)
{
// Then we take the list and glue it to our head -
// deallocation will bring no problem
PInsertBefore (theOther, theIter);
}
else
{
// No - this list has different memory scope
prependList(theOther.myFirst, theIter);
theOther.Clear();
}
}
//! InsertAfter
TheItemType& InsertAfter (const TheItemType& theItem,
Iterator& theIter)
{
ListNode * pNew = new (this->myAllocator) ListNode(theItem);
PInsertAfter (pNew, theIter);
return pNew -> ChangeValue();
}
//! InsertAfter
void InsertAfter (NCollection_List& theOther,
Iterator& theIter)
{
if (!theIter.More())
{
Append(theOther);
return;
}
if (this->myAllocator == theOther.myAllocator)
{
// Then we take the list and glue it to our head -
// deallocation will bring no problem
PInsertAfter (theOther, theIter);
}
else
{
// No - this list has different memory scope
Iterator anIter;
anIter.myPrevious = theIter.myCurrent;
anIter.myCurrent = theIter.myCurrent->Next();
prependList(theOther.PFirst(), anIter);
theOther.Clear();
}
}
//! Reverse the list
void Reverse ()
{ PReverse(); }
//! Return true if object is stored in the list.
template<typename TheValueType> // instantiate this method on first call only for types defining equality operator
Standard_Boolean Contains (const TheValueType& theObject) const
{
for (Iterator anIter (*this); anIter.More(); anIter.Next())
{
if (anIter.Value() == theObject)
{
return Standard_True;
}
}
return Standard_False;
}
//! Destructor - clears the List
virtual ~NCollection_List (void)
{ Clear(); }
private:
// ----------- PRIVATE METHODS -----------
//! append the list headed by the given ListNode
void appendList(const NCollection_ListNode * pCur) {
while (pCur) {
NCollection_ListNode * pNew =
new (this->myAllocator) ListNode(((const ListNode *)(pCur))->Value());
PAppend(pNew);
pCur = pCur->Next();
}
}
//! insert the list headed by the given ListNode before the given iterator
void prependList(const NCollection_ListNode * pCur, Iterator& theIter) {
while (pCur) {
NCollection_ListNode * pNew =
new (this->myAllocator) ListNode (((const ListNode *)(pCur))->Value());
PInsertBefore(pNew, theIter);
pCur = pCur->Next();
}
}
};
#endif
| 29.057057 | 122 | 0.661947 | valgur |
4190e58ec84187168e965aa62b83e93614d989cd | 4,234 | hpp | C++ | cfft.hpp | pkeir/ctfft | c9ffd0cc5d83836df787f034f108822cbc586b26 | [
"BSL-1.0"
] | 15 | 2015-05-29T22:11:04.000Z | 2021-08-10T02:11:33.000Z | cfft.hpp | pkeir/ctfft | c9ffd0cc5d83836df787f034f108822cbc586b26 | [
"BSL-1.0"
] | null | null | null | cfft.hpp | pkeir/ctfft | c9ffd0cc5d83836df787f034f108822cbc586b26 | [
"BSL-1.0"
] | 3 | 2015-07-22T05:17:54.000Z | 2016-09-10T06:49:23.000Z | #ifndef _CONSTFFT_HPP_
#define _CONSTFFT_HPP_
/*
Header providing FFT implementation using C++11 tuples.
Copyright Paul Keir 2012-2016
Distributed under the Boost Software License, Version 1.0.
(See accompanying file license.txt or copy at http://boost.org/LICENSE_1_0.txt)
*/
#ifndef SZ
#error Please #define SZ macro. Try 8: -DSZ=8
#define SZ 8
#endif
#include "const_complex.hpp"
#ifdef CONSTTUP
#include "const_tuple.hpp"
using ctup::tuple;
using ctup::get;
using ctup::make_tuple;
using ctup::tuple_cat;
#else
#include <tuple>
using std::tuple;
using std::get;
using std::make_tuple;
using std::tuple_cat;
#endif
#include "util.hpp"
#include "tuple_util.hpp"
using std::enable_if;
namespace tupconst {
template<size_t ...Is>
constexpr
auto iota_helper(indices<Is...>) ->
decltype(make_tuple(Is...)) {
return make_tuple(Is...);
}
template <size_t N>
constexpr
auto
iota() ->
decltype(iota_helper(mk_index_range<0,N-1>())) {
return iota_helper(mk_index_range<0,N-1>());
}
template<typename F, typename ...Ts, size_t ...Is>
constexpr
auto
map_helper(F f, tuple<Ts...> t, indices<Is...>) ->
decltype(make_tuple( f(get<Is>(t))... )) {
return make_tuple( f(get<Is>(t))... );
}
template <typename F, typename ...Ts>
constexpr
auto
map(F f, tuple<Ts...> t) ->
decltype(map_helper(f,t, mk_index_range<0,sizeof...(Ts)-1>())) {
return map_helper(f,t, mk_index_range<0,sizeof...(Ts)-1>());
}
template <typename F, typename ...Ts, typename ...Us, size_t ...Is>
constexpr
auto
zipWith_helper(F f, tuple<Ts...> t1, tuple<Us...> t2, indices<Is...>) ->
decltype(make_tuple( f(get<Is>(t1),get<Is>(t2))... )) {
return make_tuple( f(get<Is>(t1),get<Is>(t2))... );
}
template <typename F, typename ...Ts, typename ...Us>
constexpr
auto
zipWith(F f, tuple<Ts...> t1, tuple<Us...> t2) ->
decltype(zipWith_helper(f,t1,t2,mk_index_range<0,sizeof...(Ts)-1>())) {
return zipWith_helper(f,t1,t2,mk_index_range<0,sizeof...(Ts)-1>());
}
// Crashes clang 3.2 snapshot
/*
template <size_t N, typename ...Ts>
constexpr
auto
condenseN(tuple<Ts...> t) ->
decltype(select(t,mk_index_range<0,sizeof...(Ts)-1,N>())) {
return select(t,mk_index_range<0,sizeof...(Ts)-1,N>());
}*/
template <typename ...Ts>
constexpr
auto
condense2(tuple<Ts...> t) ->
decltype(select(t,mk_index_range<0,sizeof...(Ts)-1,2>())) {
return select(t,mk_index_range<0,sizeof...(Ts)-1,2>());
}
template <typename ...Ts>
constexpr
auto
condense(tuple<Ts...> t) ->
decltype(condense2(t)) { // Avoids clang problem.
return condense2(t);
}
template <typename ...Ts, typename ...Us>
constexpr
tuple<Ts...,Us...>
cat(tuple<Ts...> t1, tuple<Us...> t2) {
return tuple_cat(t1,t2);
}
template <typename T, typename ...Ts>
constexpr
tuple<Ts...,T>
cshift1(tuple<T,Ts...> t) {
return tuple_cat(tuple_tail(t),make_tuple(get<0>(t)));
}
constexpr
tuple<>
cshift1(tuple<> t) {
return t;
}
template <typename T>
constexpr
tuple<T,T> fft_helper(tuple<T,T> v, tuple<T>) {
return make_tuple(get<0>(v)+get<1>(v), get<0>(v)-get<1>(v));
}
template <typename ...Ts, typename ...Us>
constexpr
typename enable_if<sizeof...(Ts)==(2*sizeof...(Us)),tuple<Ts...>>::type
fft_helper(tuple<Ts...> v, tuple<Us...> rofu) {
typedef typename pack_head<Ts...>::type T; // T is usually cx<double>
return cat(zipWith(sum<T>,fft_helper(condense(v), condense(rofu)),
zipWith(product<T>,fft_helper(condense(cshift1(v)),
condense(rofu)),
rofu)),
zipWith(sub<T>,fft_helper(condense(v), condense(rofu)),
zipWith(product<T>,fft_helper(condense(cshift1(v)),
condense(rofu)),
rofu)));
}
template <typename ...Ts>
constexpr
typename enable_if<are_same<Ts...>::value,tuple<Ts...>>::type
fft(tuple<Ts...> v) {
typedef typename pack_head<Ts...>::type T;
return fft_helper(v,map(InitRofu<T>(sizeof...(Ts)),
iota<(sizeof...(Ts))/2>()));
}
}; // tupconst
using tupconst::fft;
using tupconst::map;
using tupconst::iota;
#endif// _CONSTFFT_HPP_
| 25.353293 | 80 | 0.623051 | pkeir |
41921f2e5367fdb20d7d1d43ea1273060186b2b5 | 873 | cxx | C++ | GRB/src/GRB/GRBShell.cxx | fermi-lat/celestialSources | aaa2a2275b767088c23fde64b407afdac3493208 | [
"BSD-3-Clause"
] | null | null | null | GRB/src/GRB/GRBShell.cxx | fermi-lat/celestialSources | aaa2a2275b767088c23fde64b407afdac3493208 | [
"BSD-3-Clause"
] | null | null | null | GRB/src/GRB/GRBShell.cxx | fermi-lat/celestialSources | aaa2a2275b767088c23fde64b407afdac3493208 | [
"BSD-3-Clause"
] | 1 | 2017-08-31T21:10:27.000Z | 2017-08-31T21:10:27.000Z | //
// GRBShell: Class that describes the a Shell
// Authors: Nicola Omodei & Johann Cohen Tanugi
//
#include "GRBShell.h"
using namespace cst;
GRBShell::GRBShell(double g, double r, double dr, double e)
{
m_g = g;
m_r = r;
m_dr = dr;
m_e = e;
m_m = e/(g*c2);
// m_t = t;
m_b=sqrt(1.0 - 1.0/(m_g*m_g));
}
GRBShell::GRBShell(double g, double r, double dr, double e, double m)
{
m_g = g;
m_r = r;
m_dr = dr;
m_e = e;
m_m = m;
// m_t = t;
m_b=sqrt(1.0 - 1.0/(m_g*m_g));
}
void GRBShell::Evolve(double t)
{
m_r += c * GetBeta() * t;
}
//////////////////////////////////////////////////
double GRBShell::GetVolume()
{
return 4.*cst::pi * m_r * m_r * m_dr;
}
double GRBShell::GetComPartDens()
{
return (m_e * cst::erg2meV)/(m_g*cst::mpc2)/GetComovingVolume(); //1/cm^3
}
| 9.593407 | 75 | 0.515464 | fermi-lat |
4193a341964e17f06953f7280fd295ef959b8d0d | 2,489 | cpp | C++ | Problems/240_Search_a_2D_Matrix_II/main.cpp | camelboat/LeetCode_Archive | c29d263e068752a9ad355925f326b56f672bb584 | [
"MIT"
] | 3 | 2019-09-21T16:25:44.000Z | 2021-08-29T20:43:57.000Z | Problems/240_Search_a_2D_Matrix_II/main.cpp | camelboat/LeetCode_Archive | c29d263e068752a9ad355925f326b56f672bb584 | [
"MIT"
] | null | null | null | Problems/240_Search_a_2D_Matrix_II/main.cpp | camelboat/LeetCode_Archive | c29d263e068752a9ad355925f326b56f672bb584 | [
"MIT"
] | null | null | null | #include <iostream>
#include <vector>
using namespace std;
//// Search Space Reduction
class Solution {
public:
bool searchMatrix(vector<vector<int>>& matrix, int target) {
if (matrix.size() == 0 || matrix[0].size() == 0) return false;
int pt_row = matrix.size()-1;
int pt_col = 0;
while (pt_row >= 0 && pt_col < matrix[0].size())
{
int cur = matrix[pt_row][pt_col];
if (cur == target) return true;
if (cur < target) pt_col++;
if (cur > target) pt_row--;
}
return false;
}
};
//// can use binary search for both row and col at the same time
//// can also use divide-and-conquer
class Solution {
public:
bool searchMatrix(vector<vector<int>>& matrix, int target) {
if (matrix.size() == 0 || matrix[0].size() == 0) return false;
return searchMatrix_helper(matrix, 0, 0, matrix[0].size()-1, matrix.size()-1, target);
}
bool searchMatrix_helper(vector<vector<int>>& matrix, int left, int top, int right, int bottom, int target)
{
if (left > right || top > bottom) return false;
if (target > matrix[bottom][right] || target < matrix[top][left]) return false;
int mid = left + (right-left)/2;
int row = top;
while (row <= bottom && matrix[row][mid] <= target)
{
if (matrix[row][mid] == target) return true;
row++;
}
return (searchMatrix_helper(matrix, left, row, mid-1, bottom, target) ||
searchMatrix_helper(matrix, mid+1, top, right, row-1, target));
}
};
//// for each row, use binary search
class Solution {
public:
bool searchMatrix(vector<vector<int>>& matrix, int target) {
if (matrix.size() == 0 || matrix[0].size() == 0) return false;
int col = matrix[0].size();
for (int i = 0; i < matrix.size(); ++i)
{
if (target >= matrix[i][0] && target <= matrix[i][col-1])
{
if (searchRow(matrix[i], target)) return true;
}
}
return false;
}
bool searchRow(vector<int>& row, int target)
{
int left = 0;
int right = row.size();
while (left <= right)
{
int mid = (left+right)/2;
if (row[mid] == target) return true;
else if (row[mid] > target) right = mid-1;
else if (row[mid] < target) left = mid+1;
}
return false;
}
}; | 30.728395 | 111 | 0.534753 | camelboat |
419a0aab494e915da7083289a2e14825469aaaf4 | 140 | cpp | C++ | Controller/CPU-related/Intel/Core/Core.cpp | st-gb/CPUinfoAndControl | 5e93d4a195b4692d147bb05cfef534e38d7f8b64 | [
"MIT"
] | null | null | null | Controller/CPU-related/Intel/Core/Core.cpp | st-gb/CPUinfoAndControl | 5e93d4a195b4692d147bb05cfef534e38d7f8b64 | [
"MIT"
] | null | null | null | Controller/CPU-related/Intel/Core/Core.cpp | st-gb/CPUinfoAndControl | 5e93d4a195b4692d147bb05cfef534e38d7f8b64 | [
"MIT"
] | 1 | 2021-07-16T21:01:26.000Z | 2021-07-16T21:01:26.000Z | /*
* Core.cpp
*
* Created on: 28.09.2010
* Author: sgebauer
*/
#include <stdint.h> //uint32_t
uint32_t g_dwValue1, g_dwValue2 ;
| 14 | 33 | 0.628571 | st-gb |
419cfbb44ec521a586e22a8dae862991ef30b0e4 | 2,685 | cpp | C++ | base/system_console.cpp | clarfonthey/laf | 305592194e3d89dfe6d16648bf84576a2f7b05a5 | [
"MIT"
] | 3 | 2019-01-08T18:41:03.000Z | 2021-02-25T11:13:00.000Z | base/system_console.cpp | clarfonthey/laf | 305592194e3d89dfe6d16648bf84576a2f7b05a5 | [
"MIT"
] | null | null | null | base/system_console.cpp | clarfonthey/laf | 305592194e3d89dfe6d16648bf84576a2f7b05a5 | [
"MIT"
] | null | null | null | // LAF Base Library
// Copyright (c) 2001-2016 David Capello
//
// This file is released under the terms of the MIT license.
// Read LICENSE.txt for more information.
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include "base/system_console.h"
#ifdef _WIN32 // Windows needs some adjustments to the console if the
// process is linked with /subsystem:windows. These
// adjustments are not great but are good enough.
// See system_console.h for more information.
#include <cstdio>
#include <iostream>
#include <windows.h>
#include <io.h>
namespace base {
static bool withConsole = false;
SystemConsole::SystemConsole()
{
// If some output handle (stdout/stderr) is not attached to a
// console, we can attach the process to the parent process console.
bool unknownOut = (::GetFileType(::GetStdHandle(STD_OUTPUT_HANDLE)) == FILE_TYPE_UNKNOWN);
bool unknownErr = (::GetFileType(::GetStdHandle(STD_ERROR_HANDLE)) == FILE_TYPE_UNKNOWN);
if (unknownOut || unknownErr) {
// AttachConsole() can fails if the parent console doesn't have a
// console, which is the most common, i.e. when the user
// double-click a shortcut to start the program.
if (::AttachConsole(ATTACH_PARENT_PROCESS)) {
// In this case we're attached to the parent process
// (e.g. cmd.exe) console.
withConsole = true;
}
}
if (withConsole) {
// Here we redirect stdout/stderr to use the parent console's ones.
if (unknownOut) std::freopen("CONOUT$", "w", stdout);
if (unknownErr) std::freopen("CONOUT$", "w", stderr);
// Synchronize C++'s cout/cerr streams with C's stdout/stderr.
std::ios::sync_with_stdio();
}
}
SystemConsole::~SystemConsole()
{
if (withConsole) {
::FreeConsole();
withConsole = false;
}
}
void SystemConsole::prepareShell()
{
if (withConsole)
::FreeConsole();
// In this case, for a better user experience, here we create a new
// console so he can write text in a synchronized way with the
// console. (The parent console stdin is not reliable for
// interactive command input in the current state, without doing
// this the input from the cmd.exe would be executed by cmd.exe and
// by our app.)
withConsole = true;
::AllocConsole();
::AttachConsole(::GetCurrentProcessId());
std::freopen("CONIN$", "r", stdin);
std::freopen("CONOUT$", "w", stdout);
std::freopen("CONOUT$", "w", stderr);
std::ios::sync_with_stdio();
}
}
#else // On Unix-like systems the console works just fine
namespace base {
SystemConsole::SystemConsole() { }
SystemConsole::~SystemConsole() { }
void SystemConsole::prepareShell() { }
}
#endif
| 27.680412 | 92 | 0.681937 | clarfonthey |
419d97d9f391360f1af8676673c13f39926ea178 | 9,174 | cc | C++ | components/viz/service/frame_sinks/video_capture/interprocess_frame_pool.cc | mghgroup/Glide-Browser | 6a4c1eaa6632ec55014fee87781c6bbbb92a2af5 | [
"BSD-3-Clause-No-Nuclear-License-2014",
"BSD-3-Clause"
] | null | null | null | components/viz/service/frame_sinks/video_capture/interprocess_frame_pool.cc | mghgroup/Glide-Browser | 6a4c1eaa6632ec55014fee87781c6bbbb92a2af5 | [
"BSD-3-Clause-No-Nuclear-License-2014",
"BSD-3-Clause"
] | null | null | null | components/viz/service/frame_sinks/video_capture/interprocess_frame_pool.cc | mghgroup/Glide-Browser | 6a4c1eaa6632ec55014fee87781c6bbbb92a2af5 | [
"BSD-3-Clause-No-Nuclear-License-2014",
"BSD-3-Clause"
] | 2 | 2021-01-05T23:43:46.000Z | 2021-01-07T23:36:34.000Z | // Copyright 2017 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "components/viz/service/frame_sinks/video_capture/interprocess_frame_pool.h"
#include <algorithm>
#include "base/bind.h"
#include "base/bind_helpers.h"
#include "base/logging.h"
using media::VideoFrame;
using media::VideoPixelFormat;
namespace viz {
// static
constexpr base::TimeDelta InterprocessFramePool::kMinLoggingPeriod;
InterprocessFramePool::InterprocessFramePool(int capacity)
: capacity_(std::max(capacity, 0)) {
DCHECK_GT(capacity_, 0u);
}
InterprocessFramePool::~InterprocessFramePool() = default;
scoped_refptr<VideoFrame> InterprocessFramePool::ReserveVideoFrame(
VideoPixelFormat format,
const gfx::Size& size) {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
const size_t bytes_required = VideoFrame::AllocationSize(format, size);
// Look for an available buffer that's large enough. If one is found, wrap it
// in a VideoFrame and return it.
for (auto it = available_buffers_.rbegin(); it != available_buffers_.rend();
++it) {
if (it->mapping.size() < bytes_required) {
continue;
}
// The buffer will possibly be rewritten, so the marked frame may be lost.
if (it->mapping.memory() == marked_frame_buffer_) {
ClearFrameMarking();
}
PooledBuffer taken = std::move(*it);
available_buffers_.erase(it.base() - 1);
return WrapBuffer(std::move(taken), format, size);
}
// Look for the largest available buffer, reallocate it, wrap it in a
// VideoFrame and return it.
while (!available_buffers_.empty()) {
const auto it =
std::max_element(available_buffers_.rbegin(), available_buffers_.rend(),
[](const PooledBuffer& a, const PooledBuffer& b) {
return a.mapping.size() < b.mapping.size();
});
if (it->mapping.memory() == marked_frame_buffer_)
marked_frame_buffer_ = nullptr;
available_buffers_.erase(it.base() - 1); // Release before allocating more.
PooledBuffer reallocated =
base::ReadOnlySharedMemoryRegion::Create(bytes_required);
if (!reallocated.IsValid()) {
LOG_IF(WARNING, CanLogSharedMemoryFailure())
<< "Failed to re-allocate " << bytes_required << " bytes.";
continue; // Try again after freeing the next-largest buffer.
}
return WrapBuffer(std::move(reallocated), format, size);
}
// There are no available buffers. If the pool is at max capacity, punt.
// Otherwise, allocate a new buffer, wrap it in a VideoFrame and return it.
if (utilized_buffers_.size() >= capacity_) {
return nullptr;
}
PooledBuffer additional =
base::ReadOnlySharedMemoryRegion::Create(bytes_required);
if (!additional.IsValid()) {
LOG_IF(WARNING, CanLogSharedMemoryFailure())
<< "Failed to allocate " << bytes_required << " bytes.";
return nullptr;
}
return WrapBuffer(std::move(additional), format, size);
}
void InterprocessFramePool::MarkFrame(const media::VideoFrame& frame) {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
marked_frame_buffer_ = frame.data(0);
marked_frame_size_ = frame.coded_size();
marked_frame_color_space_ = frame.ColorSpace();
marked_frame_pixel_format_ = frame.format();
}
void InterprocessFramePool::ClearFrameMarking() {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
marked_frame_buffer_ = nullptr;
}
bool InterprocessFramePool::HasMarkedFrameWithSize(
const gfx::Size& size) const {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
return marked_frame_buffer_ != nullptr && marked_frame_size_ == size;
}
scoped_refptr<VideoFrame>
InterprocessFramePool::ResurrectOrDuplicateContentFromMarkedFrame() {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
if (!marked_frame_buffer_)
return nullptr;
const auto it =
std::find_if(available_buffers_.rbegin(), available_buffers_.rend(),
[this](const PooledBuffer& candidate) {
return candidate.mapping.memory() == marked_frame_buffer_;
});
// If the buffer is available, use it directly.
if (it != available_buffers_.rend()) {
// Wrap the buffer in a VideoFrame and return it.
PooledBuffer resurrected = std::move(*it);
available_buffers_.erase(it.base() - 1);
auto frame = WrapBuffer(std::move(resurrected), marked_frame_pixel_format_,
marked_frame_size_);
frame->set_color_space(marked_frame_color_space_);
return frame;
}
// Buffer is currently in use. Reserve a new buffer and copy the contents
// over.
auto frame =
ReserveVideoFrame(marked_frame_pixel_format_, marked_frame_size_);
// The call to ReserverVideoFrame should not have cleared
// |marked_frame_buffer_|, because that buffer is currently in use.
DCHECK(marked_frame_buffer_);
if (!frame)
return nullptr;
#if DCHECK_IS_ON()
// Sanity check that |marked_frame_buffer_| indeed corresponds to a buffer in
// |utilized_buffers_|. If MarkFrame() was erroneously called with a frame
// that did not belong to this pool or was otherwise tampered with, this might
// not be the case.
const auto source_it = std::find_if(
utilized_buffers_.rbegin(), utilized_buffers_.rend(),
[this](const std::pair<const media::VideoFrame*,
base::ReadOnlySharedMemoryRegion>& candidate) {
return candidate.first->data(0) == marked_frame_buffer_;
});
DCHECK(source_it != utilized_buffers_.rend());
#endif // DCHECK_IS_ON()
// Copy the contents over.
const size_t num_bytes_to_copy = VideoFrame::AllocationSize(
marked_frame_pixel_format_, marked_frame_size_);
memcpy(frame->data(0), marked_frame_buffer_, num_bytes_to_copy);
frame->set_color_space(marked_frame_color_space_);
return frame;
}
base::ReadOnlySharedMemoryRegion InterprocessFramePool::CloneHandleForDelivery(
const VideoFrame* frame) {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
const auto it = utilized_buffers_.find(frame);
DCHECK(it != utilized_buffers_.end());
return it->second.Duplicate();
}
float InterprocessFramePool::GetUtilization() const {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
return static_cast<float>(utilized_buffers_.size()) / capacity_;
}
scoped_refptr<VideoFrame> InterprocessFramePool::WrapBuffer(
PooledBuffer pooled_buffer,
VideoPixelFormat format,
const gfx::Size& size) {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
DCHECK(pooled_buffer.IsValid());
// Create the VideoFrame wrapper. The two components of |pooled_buffer| are
// split: The shared memory handle is moved off to the side (in a
// |utilized_buffers_| map entry), while the writable mapping is transferred
// to the VideoFrame. When the VideoFrame goes out-of-scope, a destruction
// observer will re-assemble the PooledBuffer from these two components and
// return it to the |available_buffers_| pool.
//
// The VideoFrame could be held, externally, beyond the lifetime of this
// InterprocessFramePool. However, this is safe because 1) the use of a
// WeakPtr cancels the callback that would return the buffer back to the pool,
// and 2) the mapped memory remains valid until the
// WritableSharedMemoryMapping goes out-of-scope (when the OnceClosure is
// destroyed).
scoped_refptr<VideoFrame> frame = VideoFrame::WrapExternalData(
format, size, gfx::Rect(size), size,
static_cast<uint8_t*>(pooled_buffer.mapping.memory()),
pooled_buffer.mapping.size(), base::TimeDelta());
DCHECK(frame);
// Sanity-check the assumption being made for SetMarkedBuffer():
DCHECK_EQ(frame->data(0), pooled_buffer.mapping.memory());
utilized_buffers_.emplace(frame.get(), std::move(pooled_buffer.region));
frame->AddDestructionObserver(
base::BindOnce(&InterprocessFramePool::OnFrameWrapperDestroyed,
weak_factory_.GetWeakPtr(), base::Unretained(frame.get()),
std::move(pooled_buffer.mapping)));
return frame;
}
void InterprocessFramePool::OnFrameWrapperDestroyed(
const VideoFrame* frame,
base::WritableSharedMemoryMapping mapping) {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
DCHECK(mapping.IsValid());
// Return the buffer to the pool by moving the PooledBuffer back into
// |available_buffers_|.
const auto it = utilized_buffers_.find(frame);
DCHECK(it != utilized_buffers_.end());
available_buffers_.emplace_back(
PooledBuffer{std::move(it->second), std::move(mapping)});
DCHECK(available_buffers_.back().IsValid());
utilized_buffers_.erase(it);
DCHECK_LE(available_buffers_.size() + utilized_buffers_.size(), capacity_);
}
bool InterprocessFramePool::CanLogSharedMemoryFailure() {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
const base::TimeTicks now = base::TimeTicks::Now();
if ((now - last_fail_log_time_) >= kMinLoggingPeriod) {
last_fail_log_time_ = now;
return true;
}
return false;
}
} // namespace viz
| 37.909091 | 85 | 0.722368 | mghgroup |
419fae4e9f3affd25518ec83360040d838e314aa | 632 | cpp | C++ | src/web.cpp | HellRok/Taylor | aa9d901b4db77395a0bde896500016353adcd73b | [
"MIT"
] | 40 | 2021-05-25T04:21:49.000Z | 2022-02-19T05:05:45.000Z | src/web.cpp | HellRok/Taylor | aa9d901b4db77395a0bde896500016353adcd73b | [
"MIT"
] | 4 | 2021-09-17T06:52:35.000Z | 2021-12-29T23:07:18.000Z | src/web.cpp | HellRok/Taylor | aa9d901b4db77395a0bde896500016353adcd73b | [
"MIT"
] | 1 | 2021-12-23T00:59:27.000Z | 2021-12-23T00:59:27.000Z | #ifdef __EMSCRIPTEN__
#include "mruby.h"
#include <emscripten/emscripten.h>
mrb_state *main_loop_mrb{};
mrb_value main_loop_self{};
char *main_loop_method{};
void real_main_loop() {
mrb_funcall(main_loop_mrb, main_loop_self, main_loop_method, 0);
}
mrb_value mrb_set_main_loop(mrb_state *mrb, mrb_value self) {
mrb_get_args(mrb, "z", &main_loop_method);
main_loop_mrb = mrb;
main_loop_self = self;
emscripten_set_main_loop(real_main_loop, 0, 1);
return mrb_nil_value();
}
void append_web(mrb_state *mrb) {
mrb_define_method(mrb, mrb->kernel_module, "set_main_loop", mrb_set_main_loop, MRB_ARGS_REQ(1));
}
#endif
| 23.407407 | 98 | 0.765823 | HellRok |
41a7485c074fb927c65eb887073c4456c636a288 | 8,939 | hpp | C++ | include/TMPro/KerningTable.hpp | marksteward/BeatSaber-Quest-Codegen | a76f063f71cef207a9f048ad7613835f554911a7 | [
"Unlicense"
] | null | null | null | include/TMPro/KerningTable.hpp | marksteward/BeatSaber-Quest-Codegen | a76f063f71cef207a9f048ad7613835f554911a7 | [
"Unlicense"
] | null | null | null | include/TMPro/KerningTable.hpp | marksteward/BeatSaber-Quest-Codegen | a76f063f71cef207a9f048ad7613835f554911a7 | [
"Unlicense"
] | null | null | null | // Autogenerated from CppHeaderCreator
// Created by Sc2ad
// =========================================================================
#pragma once
// Begin includes
#include "extern/beatsaber-hook/shared/utils/typedefs.h"
#include "extern/beatsaber-hook/shared/utils/byref.hpp"
#include "extern/beatsaber-hook/shared/utils/il2cpp-utils-methods.hpp"
#include "extern/beatsaber-hook/shared/utils/il2cpp-utils-properties.hpp"
#include "extern/beatsaber-hook/shared/utils/il2cpp-utils-fields.hpp"
#include "extern/beatsaber-hook/shared/utils/utils.h"
// Completed includes
// Begin forward declares
// Forward declaring namespace: TMPro
namespace TMPro {
// Forward declaring type: KerningPair
class KerningPair;
// Forward declaring type: GlyphValueRecord_Legacy
struct GlyphValueRecord_Legacy;
}
// Forward declaring namespace: System::Collections::Generic
namespace System::Collections::Generic {
// Forward declaring type: List`1<T>
template<typename T>
class List_1;
}
// Completed forward declares
// Type namespace: TMPro
namespace TMPro {
// Size: 0x18
#pragma pack(push, 1)
// Autogenerated type: TMPro.KerningTable
// [TokenAttribute] Offset: FFFFFFFF
class KerningTable : public ::Il2CppObject {
public:
// Nested type: TMPro::KerningTable::$$c__DisplayClass3_0
class $$c__DisplayClass3_0;
// Nested type: TMPro::KerningTable::$$c__DisplayClass4_0
class $$c__DisplayClass4_0;
// Nested type: TMPro::KerningTable::$$c__DisplayClass5_0
class $$c__DisplayClass5_0;
// Nested type: TMPro::KerningTable::$$c
class $$c;
// public System.Collections.Generic.List`1<TMPro.KerningPair> kerningPairs
// Size: 0x8
// Offset: 0x10
System::Collections::Generic::List_1<TMPro::KerningPair*>* kerningPairs;
// Field size check
static_assert(sizeof(System::Collections::Generic::List_1<TMPro::KerningPair*>*) == 0x8);
// Creating value type constructor for type: KerningTable
KerningTable(System::Collections::Generic::List_1<TMPro::KerningPair*>* kerningPairs_ = {}) noexcept : kerningPairs{kerningPairs_} {}
// Creating conversion operator: operator System::Collections::Generic::List_1<TMPro::KerningPair*>*
constexpr operator System::Collections::Generic::List_1<TMPro::KerningPair*>*() const noexcept {
return kerningPairs;
}
// Get instance field: public System.Collections.Generic.List`1<TMPro.KerningPair> kerningPairs
System::Collections::Generic::List_1<TMPro::KerningPair*>* _get_kerningPairs();
// Set instance field: public System.Collections.Generic.List`1<TMPro.KerningPair> kerningPairs
void _set_kerningPairs(System::Collections::Generic::List_1<TMPro::KerningPair*>* value);
// public System.Void AddKerningPair()
// Offset: 0xFF12D8
void AddKerningPair();
// public System.Int32 AddKerningPair(System.UInt32 first, System.UInt32 second, System.Single offset)
// Offset: 0xFF1400
int AddKerningPair(uint first, uint second, float offset);
// public System.Int32 AddGlyphPairAdjustmentRecord(System.UInt32 first, TMPro.GlyphValueRecord_Legacy firstAdjustments, System.UInt32 second, TMPro.GlyphValueRecord_Legacy secondAdjustments)
// Offset: 0xFF1540
int AddGlyphPairAdjustmentRecord(uint first, TMPro::GlyphValueRecord_Legacy firstAdjustments, uint second, TMPro::GlyphValueRecord_Legacy secondAdjustments);
// public System.Void RemoveKerningPair(System.Int32 left, System.Int32 right)
// Offset: 0xFF16C0
void RemoveKerningPair(int left, int right);
// public System.Void RemoveKerningPair(System.Int32 index)
// Offset: 0xFF17C4
void RemoveKerningPair(int index);
// public System.Void SortKerningPairs()
// Offset: 0xFF182C
void SortKerningPairs();
// public System.Void .ctor()
// Offset: 0xFF1264
// Implemented from: System.Object
// Base method: System.Void Object::.ctor()
template<::il2cpp_utils::CreationType creationType = ::il2cpp_utils::CreationType::Temporary>
static KerningTable* New_ctor() {
static auto ___internal__logger = ::Logger::get().WithContext("TMPro::KerningTable::.ctor");
return THROW_UNLESS((::il2cpp_utils::New<KerningTable*, creationType>()));
}
}; // TMPro.KerningTable
#pragma pack(pop)
static check_size<sizeof(KerningTable), 16 + sizeof(System::Collections::Generic::List_1<TMPro::KerningPair*>*)> __TMPro_KerningTableSizeCheck;
static_assert(sizeof(KerningTable) == 0x18);
}
DEFINE_IL2CPP_ARG_TYPE(TMPro::KerningTable*, "TMPro", "KerningTable");
#include "extern/beatsaber-hook/shared/utils/il2cpp-utils-methods.hpp"
// Writing MetadataGetter for method: TMPro::KerningTable::AddKerningPair
// Il2CppName: AddKerningPair
template<>
struct ::il2cpp_utils::il2cpp_type_check::MetadataGetter<static_cast<void (TMPro::KerningTable::*)()>(&TMPro::KerningTable::AddKerningPair)> {
static const MethodInfo* get() {
return ::il2cpp_utils::FindMethod(classof(TMPro::KerningTable*), "AddKerningPair", std::vector<Il2CppClass*>(), ::std::vector<const Il2CppType*>{});
}
};
// Writing MetadataGetter for method: TMPro::KerningTable::AddKerningPair
// Il2CppName: AddKerningPair
template<>
struct ::il2cpp_utils::il2cpp_type_check::MetadataGetter<static_cast<int (TMPro::KerningTable::*)(uint, uint, float)>(&TMPro::KerningTable::AddKerningPair)> {
static const MethodInfo* get() {
static auto* first = &::il2cpp_utils::GetClassFromName("System", "UInt32")->byval_arg;
static auto* second = &::il2cpp_utils::GetClassFromName("System", "UInt32")->byval_arg;
static auto* offset = &::il2cpp_utils::GetClassFromName("System", "Single")->byval_arg;
return ::il2cpp_utils::FindMethod(classof(TMPro::KerningTable*), "AddKerningPair", std::vector<Il2CppClass*>(), ::std::vector<const Il2CppType*>{first, second, offset});
}
};
// Writing MetadataGetter for method: TMPro::KerningTable::AddGlyphPairAdjustmentRecord
// Il2CppName: AddGlyphPairAdjustmentRecord
template<>
struct ::il2cpp_utils::il2cpp_type_check::MetadataGetter<static_cast<int (TMPro::KerningTable::*)(uint, TMPro::GlyphValueRecord_Legacy, uint, TMPro::GlyphValueRecord_Legacy)>(&TMPro::KerningTable::AddGlyphPairAdjustmentRecord)> {
static const MethodInfo* get() {
static auto* first = &::il2cpp_utils::GetClassFromName("System", "UInt32")->byval_arg;
static auto* firstAdjustments = &::il2cpp_utils::GetClassFromName("TMPro", "GlyphValueRecord_Legacy")->byval_arg;
static auto* second = &::il2cpp_utils::GetClassFromName("System", "UInt32")->byval_arg;
static auto* secondAdjustments = &::il2cpp_utils::GetClassFromName("TMPro", "GlyphValueRecord_Legacy")->byval_arg;
return ::il2cpp_utils::FindMethod(classof(TMPro::KerningTable*), "AddGlyphPairAdjustmentRecord", std::vector<Il2CppClass*>(), ::std::vector<const Il2CppType*>{first, firstAdjustments, second, secondAdjustments});
}
};
// Writing MetadataGetter for method: TMPro::KerningTable::RemoveKerningPair
// Il2CppName: RemoveKerningPair
template<>
struct ::il2cpp_utils::il2cpp_type_check::MetadataGetter<static_cast<void (TMPro::KerningTable::*)(int, int)>(&TMPro::KerningTable::RemoveKerningPair)> {
static const MethodInfo* get() {
static auto* left = &::il2cpp_utils::GetClassFromName("System", "Int32")->byval_arg;
static auto* right = &::il2cpp_utils::GetClassFromName("System", "Int32")->byval_arg;
return ::il2cpp_utils::FindMethod(classof(TMPro::KerningTable*), "RemoveKerningPair", std::vector<Il2CppClass*>(), ::std::vector<const Il2CppType*>{left, right});
}
};
// Writing MetadataGetter for method: TMPro::KerningTable::RemoveKerningPair
// Il2CppName: RemoveKerningPair
template<>
struct ::il2cpp_utils::il2cpp_type_check::MetadataGetter<static_cast<void (TMPro::KerningTable::*)(int)>(&TMPro::KerningTable::RemoveKerningPair)> {
static const MethodInfo* get() {
static auto* index = &::il2cpp_utils::GetClassFromName("System", "Int32")->byval_arg;
return ::il2cpp_utils::FindMethod(classof(TMPro::KerningTable*), "RemoveKerningPair", std::vector<Il2CppClass*>(), ::std::vector<const Il2CppType*>{index});
}
};
// Writing MetadataGetter for method: TMPro::KerningTable::SortKerningPairs
// Il2CppName: SortKerningPairs
template<>
struct ::il2cpp_utils::il2cpp_type_check::MetadataGetter<static_cast<void (TMPro::KerningTable::*)()>(&TMPro::KerningTable::SortKerningPairs)> {
static const MethodInfo* get() {
return ::il2cpp_utils::FindMethod(classof(TMPro::KerningTable*), "SortKerningPairs", std::vector<Il2CppClass*>(), ::std::vector<const Il2CppType*>{});
}
};
// Writing MetadataGetter for method: TMPro::KerningTable::New_ctor
// Il2CppName: .ctor
// Cannot get method pointer of value based method overload from template for constructor!
// Try using FindMethod instead!
| 57.301282 | 230 | 0.731066 | marksteward |
41a9fa8ef0ce7b23231d9a4810ac4aebb7d09393 | 96,719 | cpp | C++ | scripts/dp88_misc.cpp | mpforums/RenSharp | 5b3fb8bff2a1772a82a4148bcf3e1265a11aa097 | [
"Apache-2.0"
] | 1 | 2021-10-04T02:34:33.000Z | 2021-10-04T02:34:33.000Z | scripts/dp88_misc.cpp | TheUnstoppable/RenSharp | 2a123c6018c18f3fc73501737d600e291ac3afa7 | [
"Apache-2.0"
] | 9 | 2019-07-03T19:19:59.000Z | 2020-03-02T22:00:21.000Z | scripts/dp88_misc.cpp | TheUnstoppable/RenSharp | 2a123c6018c18f3fc73501737d600e291ac3afa7 | [
"Apache-2.0"
] | 2 | 2019-08-14T08:37:36.000Z | 2020-09-29T06:44:26.000Z | /* Renegade Scripts.dll
Copyright 2017 Tiberian Technologies
This file is part of the Renegade scripts.dll
The Renegade scripts.dll is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free
Software Foundation; either version 2, or (at your option) any later
version. See the file COPYING for more details.
In addition, an exemption is given to allow Run Time Dynamic Linking of this code with any closed source module that does not contain code covered by this licence.
Only the source code to the module(s) containing the licenced code has to be released.
*/
#include "general.h"
#include "dp88_misc.h"
#include "dp88_custom_timer_defines.h"
#include "definition.h"
#include "VehicleGameObj.h"
#include "SoldierGameObj.h"
#include "SoldierGameObjDef.h"
#include "GameObjManager.h"
#include "ScriptZoneGameObj.h"
#include "RenderObjClass.h"
#include "cPlayer.h"
#include "cTeam.h"
/*------------------------
Random weather script
--------------------------*/
void dp88_randomWeather::Created ( GameObject* obj )
{
// Start timer
float updateInterval = (float)Commands->Get_Random_Int ( Get_Int_Parameter ( "update_interval_min" ), Get_Int_Parameter ( "update_interval_max" )+1 );
Commands->Start_Timer ( obj, this, updateInterval, TIMER_RANDOMWEATHER );
}
void dp88_randomWeather::Timer_Expired ( GameObject* obj, int number )
{
// Decide if we should change the weather at all
if ( Commands->Get_Random_Int ( 0,101 ) <= Get_Int_Parameter ( "probability_change" ) )
{
// Time to change the weather!
/********************
Fog section (start / end / time)
********************/
float fog_start = (float)Commands->Get_Random_Int ( Get_Int_Parameter ( "fog_start_distance_min" ), Get_Int_Parameter ( "fog_start_distance_max" )+1 );
float fog_end = (float)Commands->Get_Random_Int ( Get_Int_Parameter ( "fog_end_distance_min" ), Get_Int_Parameter ( "fog_end_distance_max" )+1 );
// Check start <= end
if ( fog_start > fog_end )
fog_end = fog_start;
Commands->Set_Fog_Range ( fog_start, fog_end, 2.0f );
/********************
Precipitation section (density / time / unknown)
********************/
int precipitation_type = Commands->Get_Random_Int ( 1, 101 ); // 1 to 100
float precipitation_density = (float)(Commands->Get_Random_Int ( (int)(Get_Float_Parameter ( "precipitation_density_min" ) *100.0f), (int)((Get_Float_Parameter ( "precipitation_density_max" ) *100.0f)+1.0f) ) / 100.0f );
if ( precipitation_density > 0.0f && Get_Int_Parameter ( "precipitation_probability_snow" ) >= precipitation_type )
{
// Set snow
Commands->Set_Snow(precipitation_density, 2.0f, true);
Commands->Set_Rain(0.0f, 2.0f, true);
Commands->Set_Ash(0.0f, 2.0f, true);
}
else if ( precipitation_density > 0.0f && Get_Int_Parameter ( "precipitation_probability_snow" ) + Get_Int_Parameter ( "precipitation_probability_rain" ) >= precipitation_type )
{
// Set rain
Commands->Set_Snow(0.0f, 2.0f, true);
Commands->Set_Rain(precipitation_density, 2.0f, true);
Commands->Set_Ash(0.0f, 2.0f, true);
}
else if ( precipitation_density > 0.0f && Get_Int_Parameter ( "precipitation_probability_snow" ) + Get_Int_Parameter ( "precipitation_probability_rain" )+ Get_Int_Parameter ( "precipitation_probability_volcanic_ash" ) >= precipitation_type )
{
// Set volcanic ash
Commands->Set_Snow(0.0f, 2.0f, true);
Commands->Set_Rain(0.0f, 2.0f, true);
Commands->Set_Ash(precipitation_density, 2.0f, true);
}
else
{
// Set none
Commands->Set_Rain(0.0f, 2.0f, true);
Commands->Set_Snow(0.0f, 2.0f, true);
Commands->Set_Ash(0.0f, 2.0f, true);
}
/********************
Lightning section (intensity / start / end / heading / distribution / time)
********************/
int lightning_type = Commands->Get_Random_Int ( 1, 101 ); // 1 to 100
float lightning_intensity = (float)(Commands->Get_Random_Int ( (int)(Get_Float_Parameter ( "lighting_intensity_min" ) *100.0f), (int)((Get_Float_Parameter ( "lighting_intensity_max" ) *100.0f)+1.0f) ) / 100.0f );
float lightning_start = (float)(Commands->Get_Random_Int ( (int)(Get_Float_Parameter ( "lighting_start_distance_min" ) *100.0f), (int)((Get_Float_Parameter ( "lighting_start_distance_max" ) *100.0f)+1.0f) ) / 100.0f );
float lightning_end = (float)(Commands->Get_Random_Int ( (int)(Get_Float_Parameter ( "lighting_end_distance_min" ) *100.0f), (int)((Get_Float_Parameter ( "lighting_end_distance_max" ) *100.0f)+1.0f) ) / 100.0f );
float lightning_heading = (float)Commands->Get_Random_Int ( Get_Int_Parameter ( "lighting_heading_min" ), Get_Int_Parameter ( "lighting_heading_max" ) +1 );
float lightning_distribution = (float)(Commands->Get_Random_Int ( (int)(Get_Float_Parameter ( "lighting_distribution_min" ) *100.0f), (int)((Get_Float_Parameter ( "lighting_distribution_max" ) *100.0f)+1.0f) ) / 100.0f );
// Check ranges of variables
if ( lightning_intensity > 1.0f ) lightning_intensity = 1.0f;
if ( lightning_start > 1.0f ) lightning_start = 1.0f;
if ( lightning_end > 1.0f ) lightning_end = 1.0f;
if ( lightning_distribution > 1.0f ) lightning_distribution = 1.0f;
// Check start <= end
if ( lightning_start > lightning_end )
lightning_end = lightning_start;
if ( Get_Int_Parameter ( "lighting_probability_normal" ) >= lightning_type )
{
// Set lightning normal
Commands->Set_Lightning ( lightning_intensity, lightning_start, lightning_end, lightning_heading, lightning_distribution, 2.0f );
Commands->Set_War_Blitz ( 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 2.0f );
}
else if ( Get_Int_Parameter ( "lighting_probability_normal" ) + Get_Int_Parameter ( "lighting_probability_war_blitz" ) >= lightning_type )
{
// Set lightning war blitz
Commands->Set_Lightning ( 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 2.0f );
Commands->Set_War_Blitz ( lightning_intensity, lightning_start, lightning_end, lightning_heading, lightning_distribution, 2.0f );
}
else
{
// Set none
Commands->Set_Lightning ( 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 2.0f );
Commands->Set_War_Blitz ( 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 2.0f );
}
/********************
Wind section (heading / strength / variability / time)
********************/
float wind_heading = (float)Commands->Get_Random_Int ( Get_Int_Parameter ( "wind_heading_min" ), Get_Int_Parameter ( "wind_heading_max" ) +1 );
float wind_strength = (float)(Commands->Get_Random_Int ( (int)(Get_Float_Parameter ( "wind_speed_min" ) *100.0f), (int)((Get_Float_Parameter ( "wind_speed_max" ) *100.0f)+1.0f) ) / 100.0f );
float wind_variability = (float)(Commands->Get_Random_Int ( (int)(Get_Float_Parameter ( "wind_variability_min" ) *100.0f), (int)((Get_Float_Parameter ( "wind_variability_max" ) *100.0f)+1.0f) ) / 100.0f );
// Check ranges of variables
if ( wind_variability > 1.0f ) wind_variability = 1.0f;
Commands->Set_Wind ( wind_heading, wind_strength, wind_variability, 2.0f );
}
// Restart timer
float updateInterval = (float)Commands->Get_Random_Int ( Get_Int_Parameter ( "update_interval_min" ), Get_Int_Parameter ( "update_interval_max" )+1 );
Commands->Start_Timer ( obj, this, updateInterval, TIMER_RANDOMWEATHER );
}
ScriptRegistrant<dp88_randomWeather> dp88_randomWeather_Registrant(
"dp88_randomWeather",
"update_interval_min=20:int,"
"update_interval_max=50:int,"
"probability_change=20:int,"
"fog_start_distance_min=20:int,"
"fog_start_distance_max=40:int,"
"fog_end_distance_min=80:int,"
"fog_end_distance_max=100:int,"
"precipitation_probability_snow=0:int,"
"precipitation_probability_rain=70:int,"
"precipitation_probability_volcanic_ash=0:int,"
"precipitation_density_min=0.0:float,"
"precipitation_density_max=20.0:float,"
"lighting_probability_normal=20:int,"
"lighting_probability_war_blitz=5:int,"
"lighting_intensity_min=0.2:float,"
"lighting_intensity_max=0.8:float,"
"lighting_start_distance_min=0.2:float,"
"lighting_start_distance_max=0.8:float,"
"lighting_end_distance_min=0.4:float,"
"lighting_end_distance_max=1.0:float,"
"lighting_heading_min=0:int,"
"lighting_heading_max=359:int,"
"lighting_distribution_min=0.1:float,"
"lighting_distribution_max=1.0:float,"
"wind_heading_min=0:int,"
"wind_heading_max=359:int,"
"wind_speed_min=0.0:float,"
"wind_speed_max=8.0:float,"
"wind_variability_min=0.0:float,"
"wind_variability_max=1.0:float"
);
/*------------------------
Unit sounds script
--------------------------*/
void dp88_unitSounds::Created ( GameObject* obj )
{
Update_Network_Object(obj);
healAmount = 0;
if ( strcmp ( Get_Parameter ( "createdSound" ), "null" ) != 0 && Is_Valid_Preset ( Get_Parameter ( "createdSound" ) ) )
Commands->Create_3D_Sound_At_Bone( Get_Parameter ( "createdSound" ), obj, "origin" );
if ( strcmp ( Get_Parameter ( "damagedSound" ), "null" ) != 0 && Is_Valid_Preset ( Get_Parameter ( "damagedSound" ) ) )
damagedEnabled = true;
else
damagedEnabled = false;
if ( strcmp ( Get_Parameter ( "heavilyDamagedSound" ), "null" ) != 0 && Is_Valid_Preset ( Get_Parameter ( "heavilyDamagedSound" ) ) )
heavilyDamagedEnabled = true;
else
heavilyDamagedEnabled = false;
if ( strcmp ( Get_Parameter ( "healedSound" ), "null" ) != 0 && Is_Valid_Preset ( Get_Parameter ( "healedSound" ) ) )
healedEnabled = true;
else
healedEnabled = false;
if ( strcmp ( Get_Parameter ( "fallingDamageSound" ), "null" ) != 0 && Is_Valid_Preset ( Get_Parameter ( "fallingDamageSound" ) ) )
fallingDamageEnabled = true;
else
fallingDamageEnabled = false;
}
void dp88_unitSounds::Damaged( GameObject *obj, GameObject *damager, float amount )
{
// Bail out if damager == null or damager == obj
if ( damager == NULL || Commands->Get_ID ( damager ) == Commands->Get_ID ( obj ) )
return;
if ( amount > 0 && heavilyDamagedEnabled && amount > Get_Int_Parameter ( "heavilyDamagedSoundMinDamageAmount" ) )
{
if ( Commands->Get_Random_Int ( 0,101 ) <= Get_Int_Parameter ( "heavilyDamagedSoundProbability" ) )
{
heavilyDamagedEnabled = false;
Commands->Create_3D_Sound_At_Bone( Get_Parameter ( "heavilyDamagedSound" ), obj, "origin" );
Commands->Start_Timer ( obj, this, (float)Get_Int_Parameter( "heavilyDamagedSoundMinInterval" ), 2 );
}
}
else if ( amount > 0 && damagedEnabled )
{
if ( Commands->Get_Random_Int ( 0,101 ) <= Get_Int_Parameter ( "damagedSoundProbability" ) )
{
damagedEnabled = false;
Commands->Create_3D_Sound_At_Bone( Get_Parameter ( "damagedSound" ), obj, "origin" );
Commands->Start_Timer ( obj, this, (float)Get_Int_Parameter( "damagedSoundMinInterval" ), 1 );
}
}
else if ( amount < 0 && healedEnabled )
{
healAmount += (int)-amount;
// Send delayed custom to decrement heal amount
Commands->Send_Custom_Event ( obj, obj, CUSTOM_UNITSOUNDS_HEALDECREMENT, (int)-amount, (float)Get_Int_Parameter ( "healedSoundCheckTime" ) );
if ( healAmount >= Get_Int_Parameter ( "healedSoundMinHealAmount" ) )
{
healedEnabled = false;
Commands->Create_3D_Sound_At_Bone( Get_Parameter ( "healedSound" ), obj, "origin" );
Commands->Start_Timer ( obj, this, (float)Get_Int_Parameter( "healedSoundMinInterval" ), 3 );
}
}
}
void dp88_unitSounds::Killed ( GameObject *obj, GameObject *killer )
{
if ( strcmp ( Get_Parameter ( "killedSound" ), "null" ) != 0 && Is_Valid_Preset ( Get_Parameter ( "killedSound" ) ) )
Commands->Create_3D_Sound_At_Bone( Get_Parameter ( "killedSound" ), obj, "origin" );
}
void dp88_unitSounds::Custom ( GameObject* obj, int type, int param, GameObject* sender )
{
if ( type == CUSTOM_EVENT_FALLING_DAMAGE && fallingDamageEnabled )
{
fallingDamageEnabled = false;
Commands->Create_3D_Sound_At_Bone( Get_Parameter ( "fallingDamageSound" ), obj, "origin" );
Commands->Start_Timer ( obj, this, (float)Get_Int_Parameter( "fallingDamageSoundMinInterval" ), 4 );
}
else if ( type == CUSTOM_UNITSOUNDS_HEALDECREMENT )
healAmount -= param;
}
void dp88_unitSounds::Timer_Expired ( GameObject* obj, int number )
{
if ( number == 1 )
damagedEnabled = true;
else if ( number == 2 )
heavilyDamagedEnabled = true;
else if ( number == 3 )
healedEnabled = true;
else if ( number == 4 )
fallingDamageEnabled = true;
}
ScriptRegistrant<dp88_unitSounds> dp88_unitSounds_Registrant(
"dp88_unitSounds",
"createdSound=null:string,"
"damagedSound=null:string,"
"damagedSoundProbability=15:int,"
"damagedSoundMinInterval=5:int,"
"heavilyDamagedSound=null:string,"
"heavilyDamagedSoundMinDamageAmount=40:int,"
"heavilyDamagedSoundProbability=15:int,"
"heavilyDamagedSoundMinInterval=5:int,"
"healedSound=null:string,"
"healedSoundMinHealAmount=45:int,"
"healedSoundCheckTime=15:int,"
"healedSoundMinInterval=30:int,"
"fallingDamageSound=null:string,"
"fallingDamageSoundMinInterval=5:int,"
"killedSound=null:string"
);
/*------------------------
Unique Infantry Controller
--------------------------*/
void dp88_uniqueInfantry_controller::Created ( GameObject* obj )
{
infantry_preset = new char[strlen(Get_Parameter("infantry_preset"))+1];
strcpy ( infantry_preset, Get_Parameter("infantry_preset") );
team_id = Get_Int_Parameter("team_id");
max_count = Get_Int_Parameter("max_count");
percent_chance = Get_Int_Parameter("percent_chance");
// Die if infantry_preset is not valid
if ( !Is_Valid_Preset(infantry_preset) )
{
Console_Output("dp88_uniqueInfantry_controller: %s is not a valid infantry preset! Destroying script...\n", infantry_preset );
Destroy_Script();
}
else
{
hookid = 0;
InstallHook();
}
}
void dp88_uniqueInfantry_controller::Destroyed ( GameObject* obj )
{
if ( infantry_preset != NULL )
delete [] infantry_preset;
}
void dp88_uniqueInfantry_controller::ObjectCreateHook ( GameObject *obj )
{
if ( Commands->Is_A_Star(obj)
&& Get_Object_Type(obj) == team_id
&& Get_Object_Count(team_id,infantry_preset) < max_count
&& Commands->Get_Random_Int(0,100) < percent_chance )
{
Change_Character(obj,infantry_preset);
}
}
ScriptRegistrant<dp88_uniqueInfantry_controller> dp88_uniqueInfantry_controller_Registrant(
"dp88_uniqueInfantry_controller",
"infantry_preset:string,"
"team_id:int,"
"max_count=1:int,"
"percent_chance=20:int"
);
// -------------------------------------------------------------------------------------------------
// Damage animation script
// -------------------------------------------------------------------------------------------------
void dp88_damageAnimation::Created ( GameObject* obj )
{
loopAnimation = (Get_Int_Parameter ( "loopAnimation" ) == 1);
m_pLoopedAnimCtrl = new LoopedAnimationController(obj); // Can also do single-iteration loops :)
/* Load settings */
damageLevelBoundaries[0] = 100;
damageLevelStartFrames[0] = Get_Int_Parameter("healthy_startFrame");
damageLevelEndFrames[0] = Get_Int_Parameter("healthy_endFrame");
damageLevelLowPowerStartFrames[0] = Get_Int_Parameter("healthy_startFrame_lowPower");
damageLevelLowPowerEndFrames[0] = Get_Int_Parameter("healthy_endFrame_lowPower");
damageLevelBoundaries[1] = Get_Int_Parameter("damageBoundary1");
damageLevelStartFrames[1] = Get_Int_Parameter("damageBoundary1_startFrame");
damageLevelEndFrames[1] = Get_Int_Parameter("damageBoundary1_endFrame");
damageLevelLowPowerStartFrames[1] = Get_Int_Parameter("damageBoundary1_startFrame_lowPower");
damageLevelLowPowerEndFrames[1] = Get_Int_Parameter("damageBoundary1_endFrame_lowPower");
damageLevelBoundaries[2] = Get_Int_Parameter("damageBoundary2");
damageLevelStartFrames[2] = Get_Int_Parameter("damageBoundary2_startFrame");
damageLevelEndFrames[2] = Get_Int_Parameter("damageBoundary2_endFrame");
damageLevelLowPowerStartFrames[2] = Get_Int_Parameter("damageBoundary2_startFrame_lowPower");
damageLevelLowPowerEndFrames[2] = Get_Int_Parameter("damageBoundary2_endFrame_lowPower");
damageLevelBoundaries[3] = Get_Int_Parameter("damageBoundary3");
damageLevelStartFrames[3] = Get_Int_Parameter("damageBoundary3_startFrame");
damageLevelEndFrames[3] = Get_Int_Parameter("damageBoundary3_endFrame");
damageLevelLowPowerStartFrames[3] = Get_Int_Parameter("damageBoundary3_startFrame_lowPower");
damageLevelLowPowerEndFrames[3] = Get_Int_Parameter("damageBoundary3_endFrame_lowPower");
damageLevelBoundaries[4] = Get_Int_Parameter("damageBoundary4");
damageLevelStartFrames[4] = Get_Int_Parameter("damageBoundary4_startFrame");
damageLevelEndFrames[4] = Get_Int_Parameter("damageBoundary4_endFrame");
damageLevelLowPowerStartFrames[4] = Get_Int_Parameter("damageBoundary4_startFrame_lowPower");
damageLevelLowPowerEndFrames[4] = Get_Int_Parameter("damageBoundary4_endFrame_lowPower");
damageLevelBoundaries[5] = Get_Int_Parameter("damageBoundary5");
damageLevelStartFrames[5] = Get_Int_Parameter("damageBoundary5_startFrame");
damageLevelEndFrames[5] = Get_Int_Parameter("damageBoundary5_endFrame");
damageLevelLowPowerStartFrames[5] = Get_Int_Parameter("damageBoundary5_startFrame_lowPower");
damageLevelLowPowerEndFrames[5] = Get_Int_Parameter("damageBoundary5_endFrame_lowPower");
m_bUseDestroyedMode = (Get_Parameter_Count() < 33) ? false : 0 != Get_Int_Parameter("useDestroyedMode");
m_bIsDestroyed = false;
/* Set default level */
currentDamageLevel = 0;
basePowerState = Is_Base_Powered(Get_Object_Type(obj));
SetDamageAnimation(obj);
/* If any of the damage levels have a different set of frames for the low power state
then start the timer to check power state regularly */
for ( int i = 0; i < 6; i++ )
{
if ( damageLevelBoundaries[i] >= 0 && damageLevelLowPowerStartFrames[i] >= 0
&& (damageLevelLowPowerStartFrames[i] != damageLevelStartFrames[i]
|| damageLevelLowPowerEndFrames[i] != damageLevelEndFrames[i])
)
{
Commands->Start_Timer(obj, this, 1.0f, TIMER_CHECK_BASE_POWER_STATE );
break;
}
}
}
// -------------------------------------------------------------------------------------------------
void dp88_damageAnimation::Detach ( GameObject* obj )
{
ScriptImpClass::Detach(obj);
if (m_pLoopedAnimCtrl)
{
delete m_pLoopedAnimCtrl;
}
}
// -------------------------------------------------------------------------------------------------
void dp88_damageAnimation::Damaged( GameObject *obj, GameObject *damager, float amount )
{
if ( amount >= 0 )
{
while ( currentDamageLevel < 5 && damageLevelBoundaries[currentDamageLevel+1] >= 0
&& ((Get_Hitpoints(obj)/Get_Max_Hitpoints(obj))*100.0f) < damageLevelBoundaries[currentDamageLevel+1] )
{
currentDamageLevel++;
basePowerState = Is_Base_Powered(Get_Object_Type(obj));
SetDamageAnimation(obj);
if ( m_bUseDestroyedMode && (currentDamageLevel == 5 || damageLevelBoundaries[currentDamageLevel+1] <= 0) )
m_bIsDestroyed = true;
}
}
// Repairs make the damage level go backwards, unless we're fully destroyed and not at 100% health
if ( amount <= 0 && (!m_bIsDestroyed || Get_Hitpoints(obj) == Get_Max_Hitpoints(obj)) )
{
while ( currentDamageLevel > 0
&& ((Get_Hitpoints(obj)/Get_Max_Hitpoints(obj))*100.0f) > damageLevelBoundaries[currentDamageLevel] )
{
currentDamageLevel--;
basePowerState = Is_Base_Powered(Get_Object_Type(obj));
SetDamageAnimation(obj);
}
}
}
// -------------------------------------------------------------------------------------------------
void dp88_damageAnimation::Timer_Expired ( GameObject* obj, int number )
{
if ( number == TIMER_CHECK_BASE_POWER_STATE )
{
if ( Is_Base_Powered(Get_Object_Type(obj)) != basePowerState )
{
basePowerState = !basePowerState;
SetDamageAnimation(obj);
}
// Restart timer
Commands->Start_Timer(obj, this, 1.0f, TIMER_CHECK_BASE_POWER_STATE );
}
}
// -------------------------------------------------------------------------------------------------
void dp88_damageAnimation::SetDamageAnimation ( GameObject* obj )
{
int wakeup_param = Get_Parameter_Index("wakeObjects");
bool WakeObjects = wakeup_param < Get_Parameter_Count() ? Get_Bool_Parameter(wakeup_param) : false;
if (WakeObjects)
{
Wake_Up_Objects_In_Box(obj,"WAKEBOX");
}
if ( basePowerState || damageLevelLowPowerStartFrames[currentDamageLevel] < 0 )
m_pLoopedAnimCtrl->PlayAnimation ( Get_Parameter("animationName"), damageLevelStartFrames[currentDamageLevel], damageLevelEndFrames[currentDamageLevel], (loopAnimation)?0:1 );
else
m_pLoopedAnimCtrl->PlayAnimation ( Get_Parameter("animationName"), damageLevelLowPowerStartFrames[currentDamageLevel], damageLevelLowPowerEndFrames[currentDamageLevel], (loopAnimation)?0:1 );
}
// -------------------------------------------------------------------------------------------------
ScriptRegistrant<dp88_damageAnimation> dp88_damageAnimation_Registrant(
"dp88_damageAnimation",
"animationName=object.object:string,"
"loopAnimation=1:int,"
"healthy_startFrame=0:int,"
"healthy_endFrame=0:int,"
"healthy_startFrame_lowPower=-1:int,"
"healthy_endFrame_lowPower=-1:int,"
"damageBoundary1=-1:int,"
"damageBoundary1_startFrame=0:int,"
"damageBoundary1_endFrame=0:int,"
"damageBoundary1_startFrame_lowPower=-1:int,"
"damageBoundary1_endFrame_lowPower=-1:int,"
"damageBoundary2=-1:int,"
"damageBoundary2_startFrame=0:int,"
"damageBoundary2_endFrame=0:int,"
"damageBoundary2_startFrame_lowPower=-1:int,"
"damageBoundary2_endFrame_lowPower=-1:int,"
"damageBoundary3=-1:int,"
"damageBoundary3_startFrame=0:int,"
"damageBoundary3_endFrame=0:int,"
"damageBoundary3_startFrame_lowPower=-1:int,"
"damageBoundary3_endFrame_lowPower=-1:int,"
"damageBoundary4=-1:int,"
"damageBoundary4_startFrame=0:int,"
"damageBoundary4_endFrame=0:int,"
"damageBoundary4_startFrame_lowPower=-1:int,"
"damageBoundary4_endFrame_lowPower=-1:int,"
"damageBoundary5=-1:int,"
"damageBoundary5_startFrame=0:int,"
"damageBoundary5_endFrame=0:int,"
"damageBoundary5_startFrame_lowPower=-1:int,"
"damageBoundary5_endFrame_lowPower=-1:int,"
"wakeObjects=0:int,"
"useDestroyedMode=0:int"
);
// -------------------------------------------------------------------------------------------------
/*------------------------
Object Annoucements script
--------------------------*/
void dp88_objectAnnouncements::Created ( GameObject* obj )
{
lastAnnouncementTime = 0;
minimumAnnounceInterval = Get_Int_Parameter("minimumAnnounceInterval");
/* By default we set all sound IDs to 0 */
team0_underAttackSoundId = 0;
team1_underAttackSoundId = 0;
team0_destroyedSoundId = 0;
team1_destroyedSoundId = 0;
/* Get string IDs and for each one determine if it has a valid sound
attached to it */
unsigned long soundId;
team0_underAttackStringId = (Is_Valid_String_ID(Get_Int_Parameter("team0_underAttackStringId"))) ? Get_Int_Parameter("team0_underAttackStringId") : 0;
if ( team0_underAttackStringId && (soundId = Get_String_Sound_ID(team0_underAttackStringId)) != 0 && Is_Valid_Preset_ID(soundId) && Find_Definition(soundId)->Get_Class_ID() == 0x5000 )
team0_underAttackSoundId = soundId;
team1_underAttackStringId = (Is_Valid_String_ID(Get_Int_Parameter("team1_underAttackStringId"))) ? Get_Int_Parameter("team1_underAttackStringId") : 0;
if ( team1_underAttackStringId && (soundId = Get_String_Sound_ID(team1_underAttackStringId)) != 0 && Is_Valid_Preset_ID(soundId) && Find_Definition(soundId)->Get_Class_ID() == 0x5000 )
team1_underAttackSoundId = soundId;
team0_destroyedStringId = (Is_Valid_String_ID(Get_Int_Parameter("team0_destroyedStringId"))) ? Get_Int_Parameter("team0_destroyedStringId") : 0;
if ( team0_destroyedStringId && (soundId = Get_String_Sound_ID(team0_destroyedStringId)) != 0 && Is_Valid_Preset_ID(soundId) && Find_Definition(soundId)->Get_Class_ID() == 0x5000 )
team0_destroyedSoundId = soundId;
team1_destroyedStringId = (Is_Valid_String_ID(Get_Int_Parameter("team1_destroyedStringId"))) ? Get_Int_Parameter("team1_destroyedStringId") : 0;
if ( team1_destroyedStringId && (soundId = Get_String_Sound_ID(team1_destroyedStringId)) != 0 && Is_Valid_Preset_ID(soundId) && Find_Definition(soundId)->Get_Class_ID() == 0x5000 )
team1_destroyedSoundId = soundId;
}
void dp88_objectAnnouncements::Damaged( GameObject *obj, GameObject *damager, float amount )
{
/* If damage has been done and it is more than minimumAnnounceInterval seconds since the last
announcement was made then trigger the under attack announcement */
if ( amount > 0 && time(NULL) - lastAnnouncementTime > minimumAnnounceInterval )
{
// Don't trigger above 95% health to avoid lots of annoying announcements when it takes a tiny
// bit of damage from an explosion
if ( 0.95f < (Commands->Get_Health(obj)+Commands->Get_Shield_Strength(obj))/(Commands->Get_Max_Health(obj)+Commands->Get_Max_Shield_Strength(obj)) )
return;
lastAnnouncementTime = time(NULL);
/* Send messages to teams */
if ( team0_underAttackStringId )
{
const char *str = Get_Translated_String(team0_underAttackStringId);
Send_Message_Team(0,255,255,255,str);
delete[] str;
if ( team0_underAttackSoundId )
Create_2D_Sound_Team(Get_Definition_Name(team0_underAttackSoundId),0);
}
if ( team1_underAttackStringId )
{
const char *str = Get_Translated_String(team1_underAttackStringId);
Send_Message_Team(1,255,255,255,str);
delete[] str;
if ( team1_underAttackSoundId )
Create_2D_Sound_Team(Get_Definition_Name(team1_underAttackSoundId),1);
}
}
}
void dp88_objectAnnouncements::Killed ( GameObject *obj, GameObject *killer )
{
/* Send messages to teams */
if ( team0_destroyedStringId )
{
const char *str = Get_Translated_String(team0_destroyedStringId);
Send_Message_Team(0,255,255,255,str);
delete[] str;
if ( team0_destroyedSoundId )
Create_2D_Sound_Team(Get_Definition_Name(team0_destroyedSoundId),0);
}
if ( team1_destroyedStringId )
{
const char *str = Get_Translated_String(team1_destroyedStringId);
Send_Message_Team(1,255,255,255,str);
delete[] str;
if ( team1_destroyedSoundId )
Create_2D_Sound_Team(Get_Definition_Name(team1_destroyedSoundId),1);
}
}
ScriptRegistrant<dp88_objectAnnouncements> dp88_objectAnnouncements_Registrant(
"dp88_objectAnnouncements",
"minimumAnnounceInterval=20:int,"
"team0_underAttackStringId=0:int,"
"team1_underAttackStringId=0:int,"
"team0_destroyedStringId=0:int,"
"team1_destroyedStringId=0:int,"
);
/*------------------------
Chrono Tank Script
--------------------------*/
void dp88_chronoTank::Created ( GameObject* obj )
{
state = CT_STATE_CHARGED;
object_id = Commands->Get_ID(obj);
driver_id = NULL;
shifted_vehicle_object_id = NULL;
// Can only be used on vehicles
if ( !obj->As_VehicleGameObj() )
{
Console_Output ( "[%d:%s:%s] Critical Error: This script can only be used on vehicles! Destroying script...\n", Commands->Get_ID(obj), Commands->Get_Preset_Name(obj), this->Get_Name() );
Destroy_Script();
return;
}
// Check the shifted vehicle preset is valid
if ( !Is_Valid_Preset(Get_Parameter("shifted_vehicle_preset")) )
{
Console_Output ( "[%d:%s:%s] Critical Error: A vehicle preset with the name '%s' was not found. Destroying script...\n", Commands->Get_ID(obj), Commands->Get_Preset_Name(obj), this->Get_Name(), Get_Parameter("shifted_vehicle_preset") );
Destroy_Script();
}
}
void dp88_chronoTank::Killed ( GameObject *obj, GameObject *killer )
{
if ( shifted_vehicle_object_id != NULL )
{
Commands->Destroy_Object(Commands->Find_Object(shifted_vehicle_object_id));
shifted_vehicle_object_id = NULL;
}
}
void dp88_chronoTank::Custom( GameObject *obj, int type, int param, GameObject *sender )
{
// Look for vehicle entry
if ( type == CUSTOM_EVENT_VEHICLE_ENTERED && driver_id == NULL )
{
driver_id = Commands->Get_ID(sender);
InstallHook( Get_Parameter("shift_keyhook"), sender );
}
// Look for vehicle exit (ignore when leaving due to chronoshift)
else if ( type == CUSTOM_EVENT_VEHICLE_EXITED && Commands->Get_ID(sender) == driver_id && state != CT_STATE_SHIFTED_OUT_PENDING_CLEANUP_1 )
{
driver_id = NULL;
RemoveHook();
}
}
void dp88_chronoTank::Timer_Expired( GameObject *obj, int number )
{
// Timer to advance to the next stage of the chronoshift process
if ( number == TIMER_CHRONOTANK_ADVANCE_STATE )
{
// Chronoshift device has recharged, set state and send message to driver
if ( state == CT_STATE_CHARGING )
{
state = CT_STATE_CHARGED;
if ( driver_id != NULL )
Send_Message_Player(Commands->Find_Object(driver_id),255,255,255,"The chronoshift device is now fully charged and ready for use");
}
// Shift out sequence has completed
else if ( state == CT_STATE_SHIFTING_OUT )
Shift_Out_Complete(obj);
// Shift out sequence is ready for cleanup
else if ( state == CT_STATE_SHIFTED_OUT_PENDING_CLEANUP_1 || state == CT_STATE_SHIFTED_OUT_PENDING_CLEANUP_2 )
Shift_Out_Cleanup(obj);
// Chronoshift time has expired
else if ( state == CT_STATE_SHIFTED_OUT )
Shift_In_Begin(obj);
// Shift in sequence has completed
else if ( state == CT_STATE_SHIFTING_IN )
Shift_In_Complete(obj);
// Shift in sequence is ready for cleanup
else if ( state == CT_STATE_SHIFTED_IN_PENDING_CLEANUP_1 || state == CT_STATE_SHIFTED_IN_PENDING_CLEANUP_2 )
Shift_In_Cleanup(obj);
}
// Timer to apply random interference actions
else if ( number == TIMER_CHRONOTANK_RANDOM_INTERFERENCE && shifted_vehicle_object_id != NULL && state == CT_STATE_SHIFTED_OUT )
{
// Get shifted vehicle
GameObject* shifted_vehicle = Commands->Find_Object(shifted_vehicle_object_id);
// Alter heading
if ( Get_Int_Parameter("shift_heading_fluctuation_degrees_max") > 0 )
{
float heading = Commands->Get_Facing (shifted_vehicle);
Console_Output ( "Heading was %.2f\n", heading );
heading += Commands->Get_Random_Int(Get_Int_Parameter("shift_heading_fluctuation_degrees_max")*-1,Get_Int_Parameter("shift_heading_fluctuation_degrees_max"));
heading = (heading<0) ? heading+360 : ((heading>360) ? heading-360 : heading);
Console_Output ( "Heading is now %.2f\n", heading );
Commands->Set_Facing(shifted_vehicle, heading);
}
// Alter velocity - move x% of velocity from a random axis to another random axis
float velocity_fluctuation_percent_max = Get_Float_Parameter("shift_velocity_fluctuation_percent_max");
if (velocity_fluctuation_percent_max > 0 )
{
Vector3 velocity = Get_Velocity (shifted_vehicle);
Console_Output ( "Velocity was %.2f, %.2f, %.2f\n", velocity.X, velocity.Y, velocity.Z );
float avgVelocity = (abs(velocity.X) + abs(velocity.Y) + abs(velocity.Z))/3.0f;
float percentChange = Commands->Get_Random(0.0f,velocity_fluctuation_percent_max);
float velocityChange = avgVelocity * (percentChange/100.0f);
// Pick a random axis to apply the changes to
int subAxis = Commands->Get_Random_Int(1,3);
int plusAxis = Commands->Get_Random_Int(1,3);
while (plusAxis == subAxis)
plusAxis = Commands->Get_Random_Int(1,3);
Console_Output ( "Subtracting %.2f%% velocity (%.2f) from axis %d\n", percentChange, velocityChange*-1.0f, subAxis );
Console_Output ( "Adding %.2f%% velocity (%.2f) to axis %d\n", percentChange, velocityChange, plusAxis );
// Apply the velocity changes
if ( plusAxis == 1 )
velocity.X -= velocityChange;
else if ( plusAxis == 2 )
velocity.Y -= velocityChange;
else if ( plusAxis == 3 )
velocity.Z -= velocityChange;
if ( subAxis == 1 )
velocity.X += velocityChange;
else if ( subAxis == 2 )
velocity.Y += velocityChange;
else if ( subAxis == 3 )
velocity.Z += velocityChange;
// Set new velocity
Console_Output ( "Velocity is now %.2f, %.2f, %.2f\n", velocity.X, velocity.Y, velocity.Z );
Set_Velocity(shifted_vehicle, velocity);
}
// Start timer again for the next set of interference actions
Commands->Start_Timer(obj,this,1.00f,TIMER_CHRONOTANK_RANDOM_INTERFERENCE);
}
}
void dp88_chronoTank::KeyHook()
{
GameObject* obj = Commands->Find_Object(object_id);
if ( state == CT_STATE_CHARGED )
Shift_Out_Begin(obj);
else if ( state == CT_STATE_CHARGING )
Send_Message_Player(Commands->Find_Object(driver_id),255,255,255,"The chronoshift device has not finished recharging yet");
}
void dp88_chronoTank::Shift_Out_Begin(GameObject* obj)
{
if ( state != CT_STATE_CHARGED )
return;
// Set new state
state = CT_STATE_SHIFTING_OUT;
// Lock the vehicle in it's current location and prevent the driver getting out
obj->As_VehicleGameObj()->Set_Immovable(true);
Commands->Enable_Vehicle_Transitions(obj,false);
// Create the shifted out vehicle in a safe location (pre-creation reduces the transition delay)
GameObject* shifted_vehicle = Commands->Create_Object ( Get_Parameter("shifted_vehicle_preset"), Vector3(0.0f,0.0f,500.0f) );
shifted_vehicle_object_id = Commands->Get_ID(shifted_vehicle);
// Start timer to advance to next stage (shift out complete)
Commands->Start_Timer(obj,this,Get_Float_Parameter("shift_out_time"),TIMER_CHRONOTANK_ADVANCE_STATE);
/* Create shift out effect if the preset provided is valid */
if ( Is_Valid_Preset(Get_Parameter("shift_out_effect_preset")) )
{
// Create effect object
GameObject* effect_object = Commands->Create_Object ( Get_Parameter("shift_out_effect_preset"), Commands->Get_Position(obj) );
// Attach script to clean up effect
StringClass params(true);
params.Format ( "%.2f,%d", Get_Float_Parameter("shift_out_effect_time"), 983142 );
Commands->Attach_Script ( effect_object, "JFW_Destroy_Self_Timer", params.Peek_Buffer() );
}
}
void dp88_chronoTank::Shift_Out_Complete(GameObject* obj)
{
// Enable vehicle transitions to allow the driver out
Commands->Enable_Vehicle_Transitions(obj,true);
// Transition the driver out of this vehicle
Soldier_Transition_Vehicle(Commands->Find_Object(driver_id));
// Set state and start timer to advance to next state (cleanup step 1) on next engine tick
state = CT_STATE_SHIFTED_OUT_PENDING_CLEANUP_1;
Commands->Start_Timer(obj,this,5.2f,TIMER_CHRONOTANK_ADVANCE_STATE);
}
void dp88_chronoTank::Shift_Out_Cleanup(GameObject* obj)
{
// Cleanup step 1
if ( state == CT_STATE_SHIFTED_OUT_PENDING_CLEANUP_1 )
{
// Get shifted vehicle
GameObject* shifted_vehicle = Commands->Find_Object(shifted_vehicle_object_id);
// Make the shifted vehicle invisible to base defences
Commands->Set_Is_Visible(shifted_vehicle,false);
// Move the shifted vehicle to this location
Set_Transform(shifted_vehicle, Get_Transform(obj) );
// Move the driver to where the shifted vehicle is
Commands->Set_Position(Commands->Find_Object(driver_id),Commands->Get_Position(obj));
// Move this vehicle to a safe place out of harms way and make it invisible
Commands->Set_Position(obj,Vector3(0.0f,0.0f,500.0f));
Commands->Set_Is_Rendered ( obj, false );
// Set state and start timer to advance to next state (cleanup step 2) on next engine tick
state = CT_STATE_SHIFTED_OUT_PENDING_CLEANUP_2;
Commands->Start_Timer(obj,this,5.4f,TIMER_CHRONOTANK_ADVANCE_STATE);
}
// Cleanup step 2
else
{
// Get shifted vehicle
GameObject* shifted_vehicle = Commands->Find_Object(shifted_vehicle_object_id);
// Move the driver to where the shifted vehicle is (make sure they don't walk off...)
Commands->Set_Position(Commands->Find_Object(driver_id),Commands->Get_Position(shifted_vehicle));
// Transition the driver into the shifted vehicle
ActionParamsStruct params;
params.Set_Basic((long)0,100,39);
GameObject* driver = Commands->Find_Object(driver_id);
if ( driver )
Commands->Action_Enter_Exit(driver,params);
// Set state and start timer to advance to next stage (shift in)
state = CT_STATE_SHIFTED_OUT;
Commands->Start_Timer(obj,this,Get_Float_Parameter("shift_duration"),TIMER_CHRONOTANK_ADVANCE_STATE);
// Begin timer for random interference actions
Commands->Start_Timer(obj,this,1.5f,TIMER_CHRONOTANK_RANDOM_INTERFERENCE);
}
}
void dp88_chronoTank::Shift_In_Begin(GameObject* obj)
{
// Set new state
state = CT_STATE_SHIFTING_IN;
// Get shifted vehicle
GameObject* shifted_vehicle = Commands->Find_Object(shifted_vehicle_object_id);
// Lock the shifted vehicle in position
shifted_vehicle->As_VehicleGameObj()->Set_Immovable(true);
// Start timer to advance to next stage (shift in complete)
Commands->Start_Timer(obj,this,Get_Float_Parameter("shift_in_time"),TIMER_CHRONOTANK_ADVANCE_STATE);
/* Create shift in effect if the preset provided is valid */
if ( Is_Valid_Preset(Get_Parameter("shift_in_effect_preset")) )
{
// Create effect object
GameObject* effect_object = Commands->Create_Object ( Get_Parameter("shift_in_effect_preset"), Commands->Get_Position(shifted_vehicle) );
// Attach script to clean up effect
StringClass params(true);
params.Format ( "%.2f,%d", Get_Float_Parameter("shift_in_effect_time"), 983142 );
Commands->Attach_Script ( effect_object, "JFW_Destroy_Self_Timer", params.Peek_Buffer() );
}
}
void dp88_chronoTank::Shift_In_Complete(GameObject* obj)
{
// Get shifted vehicle
GameObject* shifted_vehicle = Commands->Find_Object(shifted_vehicle_object_id);
// Move this vehicle to the location of the shifted vehicle
Set_Transform(obj, Get_Transform(shifted_vehicle) );
// Make this vehicle visible again
Commands->Set_Is_Rendered(obj, true);
// Destroy the shifted vehicle
Commands->Destroy_Object(Commands->Find_Object(shifted_vehicle_object_id));
shifted_vehicle_object_id = NULL;
// Set state
state = CT_STATE_SHIFTED_IN_PENDING_CLEANUP_1;
// Start timer to advance to next state (cleanup) on next engine tick
Commands->Start_Timer(obj,this,5.01f,TIMER_CHRONOTANK_ADVANCE_STATE);
}
void dp88_chronoTank::Shift_In_Cleanup(GameObject* obj)
{
// Cleanup step 1
if ( state == CT_STATE_SHIFTED_IN_PENDING_CLEANUP_1 )
{
// Move driver to location of this vehicle
Commands->Set_Position(Commands->Find_Object(driver_id),Commands->Get_Position(obj));
// Set state and start timer to advance to next state (cleanup step 2) on next engine tick
state = CT_STATE_SHIFTED_IN_PENDING_CLEANUP_2;
Commands->Start_Timer(obj,this,5.4f,TIMER_CHRONOTANK_ADVANCE_STATE);
}
// Cleanup step 2
else
{
// Transition the driver into this vehicle
ActionParamsStruct params;
params.Set_Basic((long)0,100,39);
GameObject* driver = Commands->Find_Object(driver_id);
if ( driver )
Commands->Action_Enter_Exit(driver,params);
// Allow this vehicle to be mobile again
obj->As_VehicleGameObj()->Set_Immovable(false);
// Set state and start timer to advance to next stage (charged)
state = CT_STATE_CHARGING;
Commands->Start_Timer(obj,this,Get_Float_Parameter("recharge_time"),TIMER_CHRONOTANK_ADVANCE_STATE);
}
}
ScriptRegistrant<dp88_chronoTank> dp88_chronoTank_Registrant(
"dp88_chronoTank",
"shift_keyhook:string,"
"shift_duration:int,"
"recharge_time:int,"
"shifted_vehicle_preset:string,"
"shift_out_time:float,"
"shift_out_effect_preset:string,"
"shift_out_effect_time:float,"
"shift_in_time:float,"
"shift_in_effect_preset:string,"
"shift_in_effect_time:float,"
"shift_heading_fluctuation_degrees_max=10:int,"
"shift_velocity_fluctuation_percent_max=10:float"
);
/*------------------------
Spawn Vehicle Part script
--------------------------*/
void dp88_spawnVehiclePart::Created ( GameObject* obj )
{
partObjectId = NULL;
/* Start a timer to spawn the vehicle part. We can't do this immediatly because
it seems to cause issues with double initializations of scripts... */
Commands->Start_Timer ( obj, this, 0.01f, TIMER_SPAWNVEHICLEPART );
}
void dp88_spawnVehiclePart::Timer_Expired( GameObject *obj, int number )
{
/* Part spawn timer */
if ( number == TIMER_SPAWNVEHICLEPART && partObjectId == NULL )
{
/* Spawn the vehicle part and get it's ID */
GameObject* part = Commands->Create_Object_At_Bone ( obj, Get_Parameter("Vehicle_Part_Preset"), Get_Parameter("Spawn_At_Bone") );
Commands->Attach_To_Object_Bone ( part, obj, Get_Parameter ( "Spawn_At_Bone" ) );
partObjectId = Commands->Get_ID(part);
/* Unless this is a decorative part start the timer again to attach the health and
veterancy link scripts. We don't do this immediately as it causes a lovely crash... */
if ( Get_Int_Parameter("IsDecorative") == 0 )
Commands->Start_Timer ( obj, this, 0.01f, TIMER_SPAWNVEHICLEPART );
}
/* Link health & veterancy script attach timer */
else if ( number == TIMER_SPAWNVEHICLEPART )
{
GameObject* part = Commands->Find_Object(partObjectId);
if ( part )
{
Attach_Script_Once_V ( part, "dp88_linkHealth", "%d", Commands->Get_ID(obj) );
Attach_Script_Once_V ( part, "dp88_linkVetPoints", "%d", Commands->Get_ID(obj) );
}
}
}
void dp88_spawnVehiclePart::Killed ( GameObject* obj, GameObject *killer )
{
if ( partObjectId != NULL && Commands->Find_Object(partObjectId) )
Commands->Destroy_Object ( Commands->Find_Object (partObjectId) );
partObjectId = NULL;
}
void dp88_spawnVehiclePart::Destroyed ( GameObject* obj )
{
if ( partObjectId != NULL && Commands->Find_Object(partObjectId) )
Commands->Destroy_Object ( Commands->Find_Object (partObjectId) );
partObjectId = NULL;
}
ScriptRegistrant<dp88_spawnVehiclePart> dp88_spawnVehiclePart_Registrant(
"dp88_spawnVehiclePart",
"Vehicle_Part_Preset:string,"
"Spawn_At_Bone:string,"
"IsDecorative=0:int"
);
/*------------------------
Custom Points script
--------------------------*/
void dp88_customPoints::Created ( GameObject* obj )
{
// Preload values since converting strings to floats every time we take
// damage is very inefficient
m_killPoints = Get_Float_Parameter("killPoints");
m_damagePoints = Get_Float_Parameter("damagePoints");
m_repairPoints = Get_Float_Parameter("repairPoints");
m_killMoney = Get_Float_Parameter("killMoney");
m_damageMoney = Get_Float_Parameter("damageMoney");
m_repairMoney = Get_Float_Parameter("repairMoney");
}
// -------------------------------------------------------------------------------------------------
void dp88_customPoints::Damaged ( GameObject *obj, GameObject *damager, float amount )
{
// Abort if there is no damager, or the unit damaged itself, or the damager is not
// a star
if ( !damager || damager == obj || !Commands->Is_A_Star(damager) )
return;
/* Damaged or repaired? Then convert amount into it's absolute value for
calculating points granted */
bool bRepair = (amount < 0);
amount = abs(amount);
float points = ((bRepair) ? m_repairPoints : m_damagePoints) * amount;
float money = ((bRepair) ? m_repairMoney : m_damageMoney) * amount;
// Is this player an APB spy?
bool bSpy = Is_Spy(damager);
// Repaired other team or damaged own team? That would be negative points and no
// money for you then... unless your spy, then the logic is inverted...
if ( bSpy ^ ((Get_Object_Type(obj) == Get_Object_Type(damager)) != bRepair) )
{
points *= -1.0f;
money = 0.0f;
}
// Give the damager their points and money
GivePointsAndMoney ( damager, points, money );
}
// -------------------------------------------------------------------------------------------------
void dp88_customPoints::Killed ( GameObject* obj, GameObject *killer )
{
// Abort if there is no killer, or the unit killed itself, or the killer is not
// a star
if ( !killer || killer == obj || !Commands->Is_A_Star(killer) )
return;
// Killed own teammate? That would be negative points and no cash for you then...
if ( Get_Object_Type(obj) == Get_Object_Type(killer) )
{
GivePointsAndMoney ( killer, m_killPoints*-1.0f, 0.0f );
}
else
{
// Give the killer their points and money
GivePointsAndMoney ( killer, m_killPoints, m_killMoney );
}
}
// -------------------------------------------------------------------------------------------------
void dp88_customPoints::GivePointsAndMoney ( GameObject* obj, float points, float money )
{
int playerId = Get_Player_ID(obj);
if ( playerId >= 0 )
{
if ( cPlayer* player = Find_Player(playerId) )
{
player->Set_Score(player->Get_Score()+points);
player->Increment_Money(money);
}
}
int team = Get_Object_Type(obj);
Set_Team_Score(team, Get_Team_Score(team) + points);
}
// -------------------------------------------------------------------------------------------------
ScriptRegistrant<dp88_customPoints> dp88_customPoints_Registrant(
"dp88_customPoints",
"killPoints:float,"
"damagePoints:float,"
"repairPoints:float,"
"killMoney:float,"
"damageMoney:float,"
"repairMoney:float"
);
/*------------------------
Conquest Controller
--------------------------*/
void dp88_conquestController_ObjectCreateHook(void *data,GameObject *obj)
{
Set_Death_Points(obj, 0);
Set_Damage_Points(obj, 0);
}
// -------------------------------------------------------------------------------------------------
void dp88_conquestController::Created ( GameObject* pSelf )
{
m_scoringMode = (unsigned char)Get_Int_Parameter("ScoringMode");
m_targets[0] = Get_Int_Parameter("TargetScoreTeam0");
m_targets[1] = Get_Int_Parameter("TargetScoreTeam1");
m_points[0] = ( m_scoringMode == MODE_DEFAULT ) ? 0 : m_targets[0];
m_points[1] = ( m_scoringMode == MODE_DEFAULT ) ? 0 : m_targets[1];
// Do game intro after 30 seconds, giving people time to load up
Commands->Start_Timer( pSelf, this, 30.0f, TIMER_CONQUEST_DOINTRO );
// First set scores for all existing objects
SLNode<BaseGameObj> *x = GameObjManager::GameObjList.Head();
while (x)
{
ScriptableGameObj* o = x->Data()->As_ScriptableGameObj();
Set_Death_Points(o, 0);
Set_Damage_Points(o, 0);
x = x->Next();
}
// And now hook all new objects
ObjectCreateHookStruct* h = new ObjectCreateHookStruct();
h->data = this;
h->hook = dp88_conquestController_ObjectCreateHook;
m_objectCreateHookId = AddObjectCreateHook(h);
}
// -------------------------------------------------------------------------------------------------
void dp88_conquestController::Destroyed(GameObject* pSelf)
{
RemoveObjectCreateHook(m_objectCreateHookId);
}
// -------------------------------------------------------------------------------------------------
void dp88_conquestController::Timer_Expired ( GameObject* pSelf, int number )
{
if ( number == TIMER_CONQUEST_DOINTRO )
{
// Show intro
int stringId = Get_String_ID_By_Desc(Get_Parameter("IntroString"));
if ( stringId != 0 )
{
DisplayMessage(StringClass(Get_Translated_String(stringId)));
}
// Start scores timer if interval > 0
int scoreInterval = Get_Int_Parameter("ScoreInterval");
if ( scoreInterval > 0 )
Commands->Start_Timer( pSelf, this, (float)scoreInterval, TIMER_CONQUEST_DOSCORES );
}
else if ( number == TIMER_CONQUEST_DOSCORES )
{
// Show scores
int winningTeam = GetWinningTeamID();
int stringId = 0;
if ( 2 != winningTeam )
stringId = Get_String_ID_By_Desc(Get_Parameter(((0==winningTeam)?"ScoreStringTeam0":"ScoreStringTeam1")));
if ( 0 == stringId )
stringId = Get_String_ID_By_Desc(Get_Parameter("ScoreString"));
if ( stringId != 0 )
{
DisplayMessage(StringClass(Get_Translated_String(stringId)));
}
else
{
if ( m_scoringMode == MODE_DEDUCTION )
DisplayMessage(StringClass("Scores are currently: %TEAM0%: %TEAM0SCORE%, %TEAM1%: %TEAM1SCORE%"));
else
DisplayMessage(StringClass("Scores are currently: %TEAM0%: (%TEAM0SCORE%/%TEAM0TARGET%), %TEAM1%: (%TEAM1SCORE%/%TEAM1TARGET%)"));
}
Commands->Start_Timer( pSelf, this, (float)Get_Int_Parameter("ScoreInterval"), TIMER_CONQUEST_DOSCORES );
}
}
// -------------------------------------------------------------------------------------------------
void dp88_conquestController::Custom ( GameObject* pSelf, int type, int param, GameObject* pSender )
{
if ( type == CUSTOM_CONQUEST_GIVEPOINTS_T0 || type == CUSTOM_CONQUEST_GIVEPOINTS_T1 )
{
int team = (type==CUSTOM_CONQUEST_GIVEPOINTS_T0) ? 0 : 1;
int otherteam = (team==0) ? 1 : 0;
// In normal scoring mode grant <param> points to the earning team
if ( m_scoringMode == MODE_DEFAULT )
{
m_points[team] += param;
// Have we won?
if ( m_points[team] >= m_targets[team] )
{
BaseControllerClass::Find_Base(otherteam)->Set_Base_Destroyed(true);
}
}
// In deduction scoring mode deduct <param> points from the opposing team
else if ( m_scoringMode == MODE_DEDUCTION )
{
m_points[otherteam] -= param;
// Have they lost?
if ( m_points[otherteam] < 0 )
{
BaseControllerClass::Find_Base(otherteam)->Set_Base_Destroyed(true);
}
}
// Update the scores
Set_Team_Score(0, (float)m_points[0]);
Set_Team_Score(1, (float)m_points[1]);
}
}
// -------------------------------------------------------------------------------------------------
int dp88_conquestController::GetWinningTeamID()
{
if ( m_scoringMode == MODE_DEFAULT )
{
// In default mode the "winner" is the team with the least points left to earn
int team0_togo = m_targets[0]-m_points[0];
int team1_togo = m_targets[1]-m_points[1];
if ( team0_togo == team1_togo )
return 2;
return ( team1_togo < team0_togo ) ? 1 : 0;
}
else if ( m_scoringMode == MODE_DEDUCTION )
{
// In deduction mode the "winner" is the team with the most points remaining
if ( m_points[0] == m_points[1] )
return 2;
return ( m_points[0] > m_points[1] ) ? 0 : 1;
}
return 2;
}
// -------------------------------------------------------------------------------------------------
int dp88_conquestController::GetLosingTeamID()
{
return (GetWinningTeamID() == 0) ? 1 : 0;
}
// -------------------------------------------------------------------------------------------------
void dp88_conquestController::DisplayMessage(StringClass message)
{
message.Replace("%TEAM0%", Get_Team_Name(0), false);
message.Replace("%TEAM1%", Get_Team_Name(1), false);
int winningTeam = GetWinningTeamID();
message.Replace("%WINNINGTEAM%", ((2==winningTeam) ? "Neither" : Get_Team_Name(winningTeam)), false);
message.Replace("%LOSINGTEAM%", ((2==winningTeam) ? "Neither" : Get_Team_Name(GetLosingTeamID())), false);
message.Replace("%TEAM0TARGET%", StringClass::getFormattedString("%d",m_targets[0]), false);
message.Replace("%TEAM1TARGET%", StringClass::getFormattedString("%d",m_targets[1]), false);
message.Replace("%TEAM0SCORE%", StringClass::getFormattedString("%d",m_points[0]), false);
message.Replace("%TEAM1SCORE%", StringClass::getFormattedString("%d",m_points[1]), false);
if ( m_scoringMode == MODE_DEFAULT )
{
message.Replace("%TEAM0SCORENEEDED%", StringClass::getFormattedString("%d",m_targets[0]-m_points[0]), false);
message.Replace("%TEAM1SCORENEEDED%", StringClass::getFormattedString("%d",m_targets[1]-m_points[1]), false);
}
else if ( m_scoringMode == MODE_DEDUCTION )
{
message.Replace("%TEAM0SCORENEEDED%", StringClass::getFormattedString("%d",m_points[1]), false);
message.Replace("%TEAM1SCORENEEDED%", StringClass::getFormattedString("%d",m_points[0]), false);
}
Send_Message(50,200,50,message);
}
// -------------------------------------------------------------------------------------------------
ScriptRegistrant<dp88_conquestController> dp88_conquestController_Registrant(
"dp88_conquestController",
"ScoringMode=0:int,"
"TargetScoreTeam0=100:int,"
"TargetScoreTeam1=100:int,"
"IntroString:string,"
"ScoreInterval=60:int,"
"ScoreString:string,"
"ScoreStringTeam0:string,"
"ScoreStringTeam1:string"
);
/*------------------------
Conquest Control Zone
--------------------------*/
void dp88_conquestControlZone::Created ( GameObject* pObj )
{
// Find the controller
GameObject* pController = Find_Object_With_Script("dp88_conquestController");
if ( !pController )
{
Console_Output ( "[%d:%s:%s] Critical Error: Conquest controller object not found. Destroying script...\n", Commands->Get_ID(pObj), Commands->Get_Preset_Name(pObj), this->Get_Name() );
Destroy_Script();
return;
}
m_controllerID = Commands->Get_ID(pController);
// Validate zone preset
if ( !Is_Valid_Preset(Get_Parameter("ZonePreset")) )
{
Console_Output ( "[%d:%s:%s] Critical Error: A script zone preset with the name '%s' was not found. Destroying script...\n", Commands->Get_ID(pObj), Commands->Get_Preset_Name(pObj), this->Get_Name(), Get_Parameter("ZonePreset") );
Destroy_Script();
return;
}
// Determine the size and rotation for the control zone
Vector3 position;
Vector3::Add ( Commands->Get_Position(pObj), Get_Vector3_Parameter("ZoneOffset"), &position );
Vector3 size = Get_Vector3_Parameter("ZoneSize");
Matrix3 rotation(true);
rotation.Rotate_Z(DEG2RAD(Commands->Get_Facing(pObj)));
// Define the bounding box and create the zone
OBBoxClass zoneBoundingBox ( position, size, rotation );
GameObject* pZone = Create_Zone(Get_Parameter("ZonePreset"), zoneBoundingBox );
m_zoneID = Commands->Get_ID(pZone);
// Load settings
m_captureTime = Get_Int_Parameter("CaptureTime");
m_bAllowMajorityCapture = (Get_Int_Parameter("AllowMajorityCapture") > 0);
m_multiCaptureCap = Get_Int_Parameter("MultiCaptureCap");
m_multiCaptureMultiplier = Get_Float_Parameter("MultiCaptureMultiplier");
m_nAnimTransitionFrames = Get_Int_Parameter("CaptureAnimTransitionFrames");
if ( m_captureTime <= 0 || m_multiCaptureCap <= 0 || m_multiCaptureMultiplier <= 0.0f || m_nAnimTransitionFrames < 0 )
{
Console_Output ( "[%d:%s:%s] Critical Error: Invaild script parameters. Destroying script...\n", Commands->Get_ID(pObj), Commands->Get_Preset_Name(pObj), this->Get_Name() );
Destroy_Script();
return;
}
// Read AI objective priorities
m_aiPriority_soldier = Get_Int_Parameter("AIObjective_Priority_Soldier");
m_aiPriority_lvehicle = Get_Int_Parameter("AIObjective_Priority_Light_Vehicle");
m_aiPriority_hvehicle = Get_Int_Parameter("AIObjective_Priority_Heavy_Vehicle");
m_aiPriority_aircraft = Get_Int_Parameter("AIObjective_Priority_Aircraft");
// Determine starting team and, if not neutral, start the tick timer to grant points per tick
int team = (unsigned char)Get_Object_Type(pObj);
if (0 == team || 1 == team)
{
ChangeOwner(pObj, team);
Commands->Start_Timer( pObj, this, (float)Get_Int_Parameter("TickInterval"), TIMER_CONQUEST_TICK );
m_bTickRunning = true;
}
else
{
// Force correct neutral team
ChangeOwner(pObj, 2);
m_bTickRunning = false;
}
// Start the think timer to track players in the zone and update ownership accordingly
Commands->Start_Timer( pObj, this, 1.0f, TIMER_CONQUEST_THINK );
}
// -------------------------------------------------------------------------------------------------
void dp88_conquestControlZone::Timer_Expired ( GameObject* pObj, int number )
{
ScriptZoneGameObj* pZone = (ScriptZoneGameObj*)Commands->Find_Object(m_zoneID);
if ( !pZone || !((GameObject*)pZone)->As_ScriptZoneGameObj() ) // Sanity checking
return;
if ( number == TIMER_CONQUEST_THINK )
{
// Count the objects inside the zone - not we don't simply use Get_Object_Count_In_Zone because
// we don't want to count vehicles *and* their drivers... but we do want to allow AI units to
// contribute. Also ignore dead units...
int nPlayers[2] = {0};
for (SLNode<SmartGameObj> *z = GameObjManager::SmartGameObjList.Head();z;z = z->Next())
{
SmartGameObj* o = z->Data();
int team = Get_Object_Type(o);
if ( Commands->Get_Health(o) == 0 || team < 0 || team > 2 || !pZone->Inside_Me(o) )
continue;
// Only AI-enabled vehicles count
if ( o->As_VehicleGameObj() && !((VehicleGameObj*)o)->Get_Action()->Is_Acting() )
continue;
nPlayers[team]++;
}
// Check which team currently controls the area inside the zone (and can therefore capture it)
int capturingTeam = -1;
if ( nPlayers[0] != nPlayers[1] )
{
if ( nPlayers[0] > nPlayers[1] && (nPlayers[1] == 0 || m_bAllowMajorityCapture) )
capturingTeam = 0;
else if ( nPlayers[1] > nPlayers[0] && (nPlayers[0] == 0 || m_bAllowMajorityCapture) )
capturingTeam = 1;
}
// Increment the capture progress for the team in control of the area inside the zone
if ( capturingTeam != -1 )
IncrementCaptureProgress ( pObj, capturingTeam, nPlayers[capturingTeam]-nPlayers[(capturingTeam==0)?1:0] );
// Otherwise revert to previous state if partially captured and nobody is in the zone (don't
// trigger this if there are players in the zone but they don't currently qualify to capture it,
// avoids losing capture progress whilst fending off enemy attackers)
else if ( (nPlayers[0] == 0 && nPlayers[1] == 0) && m_captureState != 0.0f && abs(m_captureState) != m_captureTime )
{
int team = Get_Object_Type(pObj);
int targetState = (team==2) ? 0 : ((team==0) ? (m_captureTime*-1) : m_captureTime);
if ( targetState > m_captureState )
{
m_captureState += 1.0f;
if ( m_captureState > targetState )
m_captureState = (float)targetState;
}
else
{
m_captureState -= 1.0f;
if ( m_captureState < targetState )
m_captureState = (float)targetState;
}
UpdateAnimationFrame(pObj);
}
// Restart timer
Commands->Start_Timer( pObj, this, 1.0f, TIMER_CONQUEST_THINK );
}
else if ( number == TIMER_CONQUEST_TICK )
{
int team = Get_Object_Type(pObj);
if ( team != 2 )
{
GameObject* pController = Commands->Find_Object(m_controllerID);
if ( !pController )
return;
// Grant points to owning team
int custom = (team==0) ? CUSTOM_CONQUEST_GIVEPOINTS_T0 : CUSTOM_CONQUEST_GIVEPOINTS_T1;
Commands->Send_Custom_Event ( pObj, pController, custom, Get_Int_Parameter("TickPoints"), 0.0f);
Commands->Start_Timer( pObj, this, (float)Get_Int_Parameter("TickInterval"), TIMER_CONQUEST_TICK );
}
else
m_bTickRunning = false;
}
}
// -------------------------------------------------------------------------------------------------
void dp88_conquestControlZone::IncrementCaptureProgress( GameObject* pObj, int team, int nPlayers )
{
// If the team already fully controls the zone then don't do anything
int targetState = (team==0) ? (m_captureTime*-1) : m_captureTime;
if ( m_captureState == targetState || nPlayers == 0 )
return;
// Apply multi capture cap and work out the additional progress to be applied
nPlayers = min(nPlayers,m_multiCaptureCap);
float progress = 1.0f + ((nPlayers-1)*m_multiCaptureMultiplier);
float oldCaptureState = m_captureState;
// Apply progress
if ( team == 0 )
{
m_captureState -= progress;
if ( m_captureState < targetState )
m_captureState = (float)targetState;
}
else
{
m_captureState += progress;
if ( m_captureState > targetState )
m_captureState = (float)targetState;
}
// Have we taken control of the zone?
if ( m_captureState == targetState && Get_Object_Type(pObj) != team )
{
// Send control taken message
ChangeOwner(pObj, team);
int stringId = Get_String_ID_By_Desc(Get_Parameter("CapturedString"));
if ( stringId != 0 )
{
DisplayMessage(pObj, StringClass(Get_Translated_String(stringId)));
}
else
{
DisplayMessage(pObj, StringClass("A conquest zone has been captured by %OWNINGTEAM%"));
}
// \todo Give capture points
if ( !m_bTickRunning )
Commands->Start_Timer( pObj, this, (float)Get_Int_Parameter("TickInterval"), TIMER_CONQUEST_TICK );
}
// Has the zone become neutral?
else if ( (m_captureState == 0.0f || (team == 0 && m_captureState < 0.0f) || (team == 1 && m_captureState > 0.0f))
&& Get_Object_Type(pObj) != 2 )
{
// Send neutral message
ChangeOwner(pObj, 2);
int stringId = Get_String_ID_By_Desc(Get_Parameter("NeutralString"));
if ( stringId != 0 )
{
DisplayMessage(pObj, StringClass(Get_Translated_String(stringId)));
}
else
{
DisplayMessage(pObj, StringClass("A conquest zone has become neutral"));
}
}
// Display warning message to owning team if it has just started being captured
if ( oldCaptureState == targetState*-1 )
{
int stringId = Get_String_ID_By_Desc(Get_Parameter("CapturingString"));
if ( stringId != 0 )
{
DisplayMessage(pObj, StringClass(Get_Translated_String(stringId)), (team==0)?1:0);
}
}
UpdateAnimationFrame(pObj);
}
// -------------------------------------------------------------------------------------------------
void dp88_conquestControlZone::UpdateAnimationFrame( GameObject* pObj )
{
int animFrame = 1+m_nAnimTransitionFrames; // Neutral frame
int teamFrames = (int)floor((1+m_nAnimTransitionFrames) * (abs(m_captureState)/m_captureTime));
animFrame += (m_captureState<0) ? (teamFrames*-1) : teamFrames;
Commands->Set_Animation_Frame(pObj, Get_Parameter("CaptureAnim"), animFrame);
}
// -------------------------------------------------------------------------------------------------
void dp88_conquestControlZone::ChangeOwner(GameObject* pObj, int team)
{
// Get parameters for objectives
bool bAddObjectives = (0 < m_aiPriority_soldier || 0 < m_aiPriority_lvehicle || 0 < m_aiPriority_hvehicle || 0 < m_aiPriority_aircraft);
Vector3 size = Get_Vector3_Parameter("ZoneSize");
int distance = (int)(min(size.X, size.Y)*0.75f);
// Remove old objective scripts
if (bAddObjectives)
{
Remove_Script(pObj,"dp88_AI_Objective");
}
if (0 == team || 1 == team)
{
Set_Object_Type(pObj, team);
m_captureState = (float)((team==0) ? (m_captureTime*-1) : m_captureTime);
if (bAddObjectives)
{
Attach_Script_V(pObj, "dp88_AI_Objective", "%d,2,%d,%d,%d,%d,%d", team, distance, m_aiPriority_soldier, m_aiPriority_lvehicle, m_aiPriority_hvehicle, m_aiPriority_aircraft ); // Defensive
Attach_Script_V(pObj, "dp88_AI_Objective", "%d,1,%d,%d,%d,%d,%d", (team==0)?1:0, distance, m_aiPriority_soldier, m_aiPriority_lvehicle, m_aiPriority_hvehicle, m_aiPriority_aircraft ); // Offensive
}
}
else
{
Set_Object_Type(pObj, 2);
m_captureState = 0.0f;
if (bAddObjectives)
{
Attach_Script_V(pObj, "dp88_AI_Objective", "0,1,%d,%d,%d,%d,%d", distance, m_aiPriority_soldier, m_aiPriority_lvehicle, m_aiPriority_hvehicle, m_aiPriority_aircraft ); // Defensive
Attach_Script_V(pObj, "dp88_AI_Objective", "1,1,%d,%d,%d,%d,%d", distance, m_aiPriority_soldier, m_aiPriority_lvehicle, m_aiPriority_hvehicle, m_aiPriority_aircraft ); // Offensive
}
}
UpdateAnimationFrame(pObj);
}
// -------------------------------------------------------------------------------------------------
void dp88_conquestControlZone::DisplayMessage(GameObject* pObj, StringClass message, int sendtoteam)
{
int team = Get_Object_Type(pObj);
message.Replace("%OWNINGTEAM%", ((team==2)?"Neither":Get_Team_Name(team)), false);
message.Replace("%OTHERTEAM%", ((team==2)?"Neither":Get_Team_Name((team==0)?1:0)), false);
message.Replace("%CAPTUREPOINTS%", StringClass::getFormattedString("%d",Get_Int_Parameter("CapturePoints")), false);
message.Replace("%TICKPOINTS%", StringClass::getFormattedString("%d",Get_Int_Parameter("TickPoints")), false);
message.Replace("%TICKINTERVAL%", StringClass::getFormattedString("%d",Get_Int_Parameter("TickInterval")), false);
message.Replace("%ZONENAME%", Get_Translated_Preset_Name(pObj), false);
if (2 == sendtoteam)
Send_Message(50,200,50,message);
else
Send_Message_Team(team, 50,200,50,message);
}
// -------------------------------------------------------------------------------------------------
ScriptRegistrant<dp88_conquestControlZone> dp88_conquestControlZone_Registrant(
"dp88_conquestControlZone",
"ZoneSize:vector3,"
"ZoneOffset:vector3,"
"ZonePreset=Script_Zone_All:string,"
"CapturePoints=5:int,"
"CapturePointsFirstTeamOnly=1:int,"
"TickPoints=1:int,"
"TickInterval=3:int,"
"CaptureTime=20:int,"
"MultiCaptureCap=3:int,"
"MultiCaptureMultiplier=0.5:float,"
"AllowMajorityCapture=1:int,"
"CaptureAnim:string,"
"CaptureAnimTransitionFrames=0:int"
"CapturingString:string,"
"NeutralString:string,"
"CapturedString:string,"
"AIObjective_Priority_Soldier=0:int,"
"AIObjective_Priority_Light_Vehicle=0:int,"
"AIObjective_Priority_Heavy_Vehicle=0:int,"
"AIObjective_Priority_Aircraft=0:int"
);
/*------------------------
Conquest Control Object
--------------------------*/
void dp88_conquestControlObject::Created ( GameObject* pObj )
{
// Find the controller
GameObject* pController = Find_Object_With_Script("dp88_conquestController");
if ( !pController )
{
Console_Output ( "[%d:%s:%s] Critical Error: Conquest controller object not found. Destroying script...\n", Commands->Get_ID(pObj), Commands->Get_Preset_Name(pObj), this->Get_Name() );
Destroy_Script();
return;
}
m_controllerID = Commands->Get_ID(pController);
// Always run the tick timer since we don't track the ownership state in a think timer
Commands->Start_Timer( pObj, this, (float)Get_Int_Parameter("TickInterval"), TIMER_CONQUEST_TICK );
}
// -------------------------------------------------------------------------------------------------
void dp88_conquestControlObject::Timer_Expired ( GameObject* pObj, int number )
{
if ( number == TIMER_CONQUEST_TICK )
{
int team = Get_Object_Type(pObj);
if ( team == 0 || team == 1 )
{
GameObject* pController = Commands->Find_Object(m_controllerID);
if ( !pController )
return;
// Grant points to owning team
int custom = (team==0) ? CUSTOM_CONQUEST_GIVEPOINTS_T0 : CUSTOM_CONQUEST_GIVEPOINTS_T1;
Commands->Send_Custom_Event ( pObj, pController, custom, Get_Int_Parameter("TickPoints"), 0.0f);
}
// Always run the tick timer since we don't track the ownership state in a think timer
Commands->Start_Timer( pObj, this, (float)Get_Int_Parameter("TickInterval"), TIMER_CONQUEST_TICK );
}
}
// -------------------------------------------------------------------------------------------------
ScriptRegistrant<dp88_conquestControlObject> dp88_conquestControlObject_Registrant(
"dp88_conquestControlObject",
"TickPoints=1:int,"
"TickInterval=3:int"
);
/*------------------------
Radar Invisibility
--------------------------*/
void dp88_radarInvisibility::Created ( GameObject* pObj )
{
PhysicalGameObj* phys = pObj->As_PhysicalGameObj();
if ( !phys )
{
Console_Output ( "[%d:%s:%s] Critical Error: This script is only compatible with physical game objects. Destroying script...\n", Commands->Get_ID(pObj), Commands->Get_Preset_Name(pObj), this->Get_Name() );
Destroy_Script();
return;
}
// Disable the radar blip for this object
m_originalRadarMode = phys->Get_Radar_Blip_Shape_Type();
phys->Set_Radar_Blip_Shape_Type(RADAR_BLIP_SHAPE_NONE);
// If this is a vehicle then setup the passenger data structures
if ( VehicleGameObj* pVehicle = pObj->As_VehicleGameObj() )
{
m_nSeats = pVehicle->Get_Definition().Get_Seat_Count();
m_pPassengerIds = new int[m_nSeats];
m_pPassengerRadarModes = new int[m_nSeats];
for ( int i = 0; i < m_nSeats; ++i )
m_pPassengerIds[i] = NULL;
}
}
// -------------------------------------------------------------------------------------------------
void dp88_radarInvisibility::Custom ( GameObject* pObj, int type, int param, GameObject* pSender )
{
if ( type == CUSTOM_EVENT_VEHICLE_ENTERED )
{
HidePassengerBlip(pObj->As_VehicleGameObj(), pSender->As_SoldierGameObj());
}
else if ( type == CUSTOM_EVENT_VEHICLE_EXITED )
{
RestorePassengerBlip(pSender->As_SoldierGameObj());
}
}
// -------------------------------------------------------------------------------------------------
void dp88_radarInvisibility::HidePassengerBlip ( VehicleGameObj* pVehicle, SoldierGameObj* pSoldier )
{
if ( !pVehicle || !pSoldier || !m_pPassengerIds || !pSoldier->As_PhysicalGameObj() )
return;
for ( int i = 0; i < m_nSeats; ++i )
{
if ( pVehicle->Get_Occupant(i) == pSoldier )
{
m_pPassengerIds[i] = Commands->Get_ID(pSoldier);
m_pPassengerRadarModes[i] = pSoldier->As_PhysicalGameObj()->Get_Radar_Blip_Shape_Type();
pSoldier->As_PhysicalGameObj()->Set_Radar_Blip_Shape_Type(RADAR_BLIP_SHAPE_NONE);
}
}
}
// -------------------------------------------------------------------------------------------------
void dp88_radarInvisibility::RestorePassengerBlip ( SoldierGameObj* pSoldier )
{
if ( !pSoldier || !m_pPassengerIds || !pSoldier->As_PhysicalGameObj() )
return;
int soldierId = Commands->Get_ID(pSoldier);
for ( int i = 0; i < m_nSeats; ++i )
{
if ( m_pPassengerIds[i] == soldierId )
{
pSoldier->As_PhysicalGameObj()->Set_Radar_Blip_Shape_Type(m_pPassengerRadarModes[i]);
m_pPassengerIds[i] = NULL;
}
}
}
// -------------------------------------------------------------------------------------------------
void dp88_radarInvisibility::Detach ( GameObject* pObj )
{
if ( Exe != EXE_LEVELEDIT ) // Don't trigger this code in LevelEdit
{
if ( PhysicalGameObj* phys = pObj->As_PhysicalGameObj() )
phys->Set_Radar_Blip_Shape_Type(m_originalRadarMode);
for ( int i = 0; i < m_nSeats; ++i )
{
if ( m_pPassengerIds[i] != NULL )
{
if ( GameObject* pSoldier = Commands->Find_Object(m_pPassengerIds[i]) )
RestorePassengerBlip( pSoldier->As_SoldierGameObj() );
}
}
}
delete [] m_pPassengerIds;
delete [] m_pPassengerRadarModes;
// Prevent a crash if Detach is somehow called twice (can apparently happen?!?)
m_pPassengerIds = NULL;
m_pPassengerRadarModes = NULL;
m_nSeats = 0;
ScriptImpClass::Detach(pObj);
}
// -------------------------------------------------------------------------------------------------
ScriptRegistrant<dp88_radarInvisibility> dp88_radarInvisibility_Registrant(
"dp88_radarInvisibility",
""
);
void dp88_turretSound::Created ( GameObject* pObj )
{
if ( VehicleGameObj* vObj = pObj->As_VehicleGameObj() )
{
m_nMinDifferential = Get_Float_Parameter("Min_Differential_Rad");
m_lastFacing = Get_Turret_Facing(vObj->Peek_Model());
m_nSoundId = -1;
Commands->Start_Timer(pObj, this, 0.5f, TIMER_TURRETSOUND );
}
else
{
Console_Output ( "[%d:%s:%s] Critical Error: This script is only compatible with vehicle game objects. Destroying script...\n", Commands->Get_ID(pObj), Commands->Get_Preset_Name(pObj), this->Get_Name() );
Destroy_Script();
}
}
// -------------------------------------------------------------------------------------------------
void dp88_turretSound::Timer_Expired ( GameObject* pObj, int number )
{
if ( number == TIMER_TURRETSOUND )
{
if ( VehicleGameObj* vObj = pObj->As_VehicleGameObj() )
{
float newFacing = Get_Turret_Facing(vObj->Peek_Model());
// Check if we are rotating - ignore tiny rotation amounts
bool bRotating = ( abs(newFacing-m_lastFacing) > m_nMinDifferential );
if ( m_nSoundId == -1 && bRotating)
Play_Sound(pObj);
else if ( m_nSoundId != -1 && !bRotating )
Stop_Sound(pObj);
m_lastFacing = newFacing;
}
// Restart timer to check for rotation
Commands->Start_Timer(pObj, this, 0.5f, TIMER_TURRETSOUND );
}
}
// -------------------------------------------------------------------------------------------------
void dp88_turretSound::Custom ( GameObject* pObj, int type, int param, GameObject* pSender )
{
if (type == CUSTOM_EVENT_SOUND_ENDED && param == m_nSoundId)
{
// We will allow the timer to stop the sound if necessary, since this might trigger
// on the same engine tick, thus checking our facing against the previous timer
// facing could produce a false-positive for "stopped rotating"
Play_Sound(pObj);
}
}
// -------------------------------------------------------------------------------------------------
float dp88_turretSound::Get_Turret_Facing ( RenderObjClass* pRenderObj )
{
if ( pRenderObj )
{
Matrix3D vehicleTransform = pRenderObj->Get_Transform();
Matrix3D transform = pRenderObj->Get_Bone_Transform("turret");
return abs(vehicleTransform.Get_Z_Rotation()-transform.Get_Z_Rotation());
}
return 0.0f;
}
// -------------------------------------------------------------------------------------------------
void dp88_turretSound::Play_Sound ( GameObject* pObj )
{
m_nSoundId = Commands->Create_3D_Sound_At_Bone(Get_Parameter("Sound_Preset"), pObj, "turret");
Commands->Monitor_Sound(pObj, m_nSoundId);
}
// -------------------------------------------------------------------------------------------------
void dp88_turretSound::Stop_Sound ( GameObject* pObj )
{
Commands->Stop_Sound(m_nSoundId,true);
m_nSoundId = -1;
}
// -------------------------------------------------------------------------------------------------
ScriptRegistrant<dp88_turretSound> dp88_turretSound_Registrant(
"dp88_turretSound",
"Sound_Preset:string,"
"Min_Differential_Rad=0.25:float"
);
// -------------------------------------------------------------------------------------------------
// Teleportation script
// -------------------------------------------------------------------------------------------------
void dp88_teleport::Created ( GameObject* pObj )
{
m_nObjectID = Get_Int_Parameter("ObjectID"); // Don't check object ID right now, it might be created later
m_bUseBone = strlen(Get_Parameter("Bone")) > 0;
m_offset = Get_Vector3_Parameter("Offset");
m_bTeleportInfantry = (Get_Int_Parameter("Teleport_Infantry") == 1);
m_bTeleportVehicles = (Get_Int_Parameter("Teleport_Vehicles") == 1);
}
// -------------------------------------------------------------------------------------------------
void dp88_teleport::Entered ( GameObject* pObj, GameObject* pEnterer )
{
if ( (m_bTeleportInfantry && pEnterer->As_SoldierGameObj()) || (m_bTeleportVehicles && pEnterer->As_VehicleGameObj()) )
{
Vector3 location = m_offset;
if ( m_nObjectID != 0 )
{
GameObject* pTarget = Commands->Find_Object(m_nObjectID);
if ( !pTarget )
return;
location = ( m_bUseBone ) ? Commands->Get_Bone_Position(pTarget,Get_Parameter("bone")) : Commands->Get_Position(pTarget);
location.X += m_offset.X;
location.Y += m_offset.Y;
location.Z += m_offset.Z;
}
Commands->Set_Position(pEnterer, location);
}
}
// -------------------------------------------------------------------------------------------------
void dp88_teleport::Custom ( GameObject* pObj, int type, int param, GameObject* pSender )
{
if ( type == CUSTOM_EVENT_POWERUP_GRANTED )
Entered ( pObj, pSender );
}
// -------------------------------------------------------------------------------------------------
void dp88_teleport::Poked ( GameObject* pObj, GameObject* pPoker )
{
Entered ( pObj, pPoker );
}
// -------------------------------------------------------------------------------------------------
ScriptRegistrant<dp88_teleport> dp88_teleport_Registrant(
"dp88_teleport",
"ObjectID=0:int,"
"Bone:string,"
"Offset:vector3,"
"Teleport_Infantry=1:int,"
"Teleport_Vehicles=1:int"
);
// -------------------------------------------------------------------------------------------------
// Ammo Animation script
// -------------------------------------------------------------------------------------------------
void dp88_Ammo_Animation::Created ( GameObject* pObj )
{
m_strAnimation = Get_Parameter("Animation");
m_nFrames = Get_Int_Parameter("Animation_Frames");
m_bUseTotal = (Get_Int_Parameter("Use_Total_Ammo")!=0);
if ( m_strAnimation == NULL || strlen(m_strAnimation) == 0 )
{
Console_Output ( "[%d:%s:%s] Critical Error: No animation has been specified! Destroying script...\n", Commands->Get_ID(pObj), Commands->Get_Preset_Name(pObj), this->Get_Name() );
Destroy_Script();
return;
}
if ( Get_Current_Max_Bullets(pObj) <= 0 || (m_bUseTotal && Get_Current_Clip_Max_Bullets(pObj) <= 0) )
{
Console_Output ( "[%d:%s:%s] Critical Error: This script cannot be used on a weapon with infinite animation! Destroying script...\n", Commands->Get_ID(pObj), Commands->Get_Preset_Name(pObj), this->Get_Name() );
Destroy_Script();
return;
}
// If an animation model is specified then create it now...
if ( strlen ( Get_Parameter("Animation_Model") ) > 0 )
{
if ( GameObject* pAmmoAnimObj = Commands->Create_Object ( "Invisible_Object", Commands->Get_Position(pObj) ) )
{
m_ammoAnimObjId = Commands->Get_ID(pAmmoAnimObj);
Commands->Set_Model ( pAmmoAnimObj, Get_Parameter("Animation_Model") );
Commands->Attach_To_Object_Bone ( pAmmoAnimObj, pObj, Get_Parameter("Animation_Model_Bone") );
}
}
m_nBullets = -1; // Animation frame update on first timer tick (unless infinite ammo)
Commands->Start_Timer(pObj, this, 0.1f, TIMER_AMMO_ANIMATION);
}
// -------------------------------------------------------------------------------------------------
void dp88_Ammo_Animation::Timer_Expired ( GameObject* pObj, int number )
{
if ( number == TIMER_AMMO_ANIMATION )
{
int nBullets = (m_bUseTotal) ? Get_Current_Total_Bullets(pObj) : Get_Current_Bullets(pObj);
if ( nBullets != m_nBullets )
{
m_nBullets = nBullets;
UpdateAnimationFrame(pObj);
}
Commands->Start_Timer(pObj, this, 0.1f, TIMER_AMMO_ANIMATION);
}
}
// -------------------------------------------------------------------------------------------------
void dp88_Ammo_Animation::UpdateAnimationFrame ( GameObject* pObj )
{
GameObject* pAnimObj = ( m_ammoAnimObjId != NULL ) ? Commands->Find_Object(m_ammoAnimObjId) : pObj;
int maxBullets = (m_bUseTotal) ? Get_Current_Total_Max_Bullets(pObj) : Get_Current_Max_Bullets(pObj);
int frame = (int)floor(((m_nFrames-1)*(1.0f-(float)m_nBullets/maxBullets)));
Commands->Set_Animation_Frame(pAnimObj, m_strAnimation, frame);
Update_Network_Object(pObj);
}
// -------------------------------------------------------------------------------------------------
ScriptRegistrant<dp88_Ammo_Animation> dp88_Ammo_Animation_Registrant(
"dp88_Ammo_Animation",
"Animation:string,"
"Animation_Frames:int,"
"Use_Total_Ammo:int,"
"Animation_Model:string,"
"Animation_Model_Bone:string"
);
// -------------------------------------------------------------------------------------------------
// Camo Controller
// -------------------------------------------------------------------------------------------------
void dp88_Camo_Controller::Created ( GameObject* pObj )
{
m_camoVariant = Get_Parameter("Camouflage");
}
// -------------------------------------------------------------------------------------------------
ScriptRegistrant<dp88_Camo_Controller> dp88_Camo_Controller_Registrant(
"dp88_Camo_Controller",
"Camouflage:string"
);
// -------------------------------------------------------------------------------------------------
// Camo Object
// -------------------------------------------------------------------------------------------------
void dp88_Camo_Object::Created ( GameObject* pObj )
{
if ( GameObject* pController = Find_Object_With_Script("dp88_Camo_Controller") )
{
if ( dp88_Camo_Controller* pControllerScript = (dp88_Camo_Controller*)Find_Script_On_Object(pController, "dp88_Camo_Controller") )
{
if ( strcmp(Get_Parameter("Camouflage"),pControllerScript->GetCamoVariant()) == 0 )
Commands->Set_Model(pObj, Get_Parameter("Model"));
}
}
Destroy_Script();
}
// -------------------------------------------------------------------------------------------------
ScriptRegistrant<dp88_Camo_Object> dp88_Camo_Object_Registrant(
"dp88_Camo_Object",
"Camouflage:string,"
"Model:string"
);
// -------------------------------------------------------------------------------------------------
// Create Object with Cinematic
// -------------------------------------------------------------------------------------------------
// Copied from sh_factory.cpp - these should really move into a header...
enum
{
CINEMATIC_SET_SLOT = 10000,
CINEMATIC_START = 99000
};
// -------------------------------------------------------------------------------------------------
void dp88_Create_Object_Cinematic::Created ( GameObject* pObj )
{
if ( 0 == Get_Int_Parameter("Trigger_Custom") )
{
Create_Object(pObj, pObj);
Destroy_Script();
}
}
// -------------------------------------------------------------------------------------------------
void dp88_Create_Object_Cinematic::Custom ( GameObject* pObj, int type, int param, GameObject* pSender )
{
if ( type == Get_Int_Parameter("Trigger_Custom") )
{
GameObject* pOwner = (param >0 ) ? Commands->Find_Object(param) : NULL;
if ( NULL == pOwner )
pOwner = pSender;
Create_Object(pObj, pOwner);
}
}
// -------------------------------------------------------------------------------------------------
void dp88_Create_Object_Cinematic::Create_Object ( GameObject* pobj, GameObject* pOwner )
{
// Mostly cloned from SH_CinematicVehicleFactoryBypass::PurchaseMonitor()
Vector3 position = Commands->Get_Position(pOwner);
position += Get_Vector3_Parameter("Offset");
float facing = Commands->Get_Facing(pOwner);
// create cinematic
char cinematic_params[128];
sprintf_s(cinematic_params, "%s,1", Get_Parameter("Cinematic"));
auto cinematic = Commands->Create_Object("Invisible_Object", position);
Commands->Set_Facing(cinematic, facing);
Commands->Attach_Script(cinematic, "JFW_Cinematic", cinematic_params);
// create vehicle at delivery site
GameObject* vehicle = Commands->Create_Object(Get_Parameter("Preset"), position);
Commands->Set_Facing(vehicle, facing);
Commands->Attach_Script(vehicle, "SH_CinematicVehicleDeliveryCallback", "");
// load vehicle and purchaser into cinematic, start it
Commands->Send_Custom_Event(pOwner, cinematic, CINEMATIC_SET_SLOT + 0, Commands->Get_ID(vehicle), 0);
Commands->Send_Custom_Event(pOwner, cinematic, CINEMATIC_SET_SLOT + 1, Commands->Get_ID(pOwner), 0);
Commands->Send_Custom_Event(pOwner, cinematic, CINEMATIC_START, 0, 0);
}
// -------------------------------------------------------------------------------------------------
ScriptRegistrant<dp88_Create_Object_Cinematic> dp88_Create_Object_Cinematic_Registrant(
"dp88_Create_Object_Cinematic",
"Preset:string,"
"Cinematic:string,"
"Trigger_Custom:int,"
"Offset:vector3"
);
// -------------------------------------------------------------------------------------------------
// Set Team On Custom
// -------------------------------------------------------------------------------------------------
void dp88_Set_Team_On_Custom::Custom ( GameObject* pObj, int type, int param, GameObject* pSender )
{
if ( type == Get_Int_Parameter("Message") )
{
if ( param >= 0 && param <= 2 && param != Get_Object_Type(pObj) )
{
if ( Find_Script_On_Object(pObj, "dp88_buildingScripts_controller") != NULL )
{
Commands->Send_Custom_Event(pObj, pObj, CUSTOM_BUILDINGSCRIPTS_BUILDINGCAPTURED, param, 0.0f);
}
else
{
Set_Object_Type(pObj, param);
}
}
}
}
// -------------------------------------------------------------------------------------------------
ScriptRegistrant<dp88_Set_Team_On_Custom> dp88_Set_Team_On_Custom_Registrant(
"dp88_Set_Team_On_Custom",
"Message:int"
);
// -------------------------------------------------------------------------------------------------
// Health regeneration script
// -------------------------------------------------------------------------------------------------
void dp88_RegenerateHitpoints::Created(GameObject *obj)
{
m_mode = (Get_Parameter_Count() >= 8) ? Get_Int_Parameter("Mode") : MODE_HEALTH + MODE_ARMOUR;
m_amount = Get_Float_Parameter("Hitpoints");
m_maxPercent = Get_Int_Parameter("Max_Percent")/100.0f;
m_interval = (float)Get_Int_Parameter("Interval");
m_lastDamage = time(NULL);
m_lastDamageTimeout = Get_Int_Parameter("Damage_Timeout");
m_warheadId = -1;
const char* warhead = Get_Parameter("Warhead");
if (Is_Valid_Warhead_Type(warhead))
m_warheadId = ArmorWarheadManager::Get_Warhead_Type(warhead);
Commands->Start_Timer(obj, this, m_interval, TIMER_MISC_TICK);
}
// -------------------------------------------------------------------------------------------------
bool dp88_RegenerateHitpoints::IsModeEnabled(int mode)
{
return (m_mode & mode) == mode;
}
// -------------------------------------------------------------------------------------------------
void dp88_RegenerateHitpoints::Timer_Expired(GameObject *obj, int number)
{
// Only process this if we are not dead and are not inside the combat timeout
if (Commands->Get_Health(obj) > 0.0f && m_amount > 0 && m_lastDamageTimeout <= time(NULL)-m_lastDamage )
{
// Repair self
RegenObject(obj, IsModeEnabled(MODE_HEALTH), IsModeEnabled(MODE_ARMOUR));
// Handle soldier-specific modes (piloted / occupied vehicle)
if (obj->As_SoldierGameObj())
{
GameObject* vehicle = Get_Vehicle(obj);
if (NULL != vehicle)
{
GameObject* driver = Get_Vehicle_Driver(vehicle);
bool bIsPilot = NULL != driver && driver->Get_ID() == obj->Get_ID();
// Repair piloted vehicle
if (bIsPilot)
{
RegenObject(vehicle, IsModeEnabled(MODE_PILOTED_HEALTH), IsModeEnabled(MODE_PILOTED_ARMOUR));
}
// Repair occupied vehicle
else
{
RegenObject(vehicle, IsModeEnabled(MODE_OCCUPIED_HEALTH), IsModeEnabled(MODE_OCCUPIED_ARMOUR));
}
}
}
// Handle vehicle-specific modes (driver / passengers)
if (obj->As_VehicleGameObj())
{
// Repair driver
RegenObject(Get_Vehicle_Driver(obj), IsModeEnabled(MODE_DRIVER_HEALTH), IsModeEnabled(MODE_DRIVER_ARMOUR));
// Repair passengers
bool bPassengersHealth = IsModeEnabled(MODE_PASSENGERS_HEALTH);
bool bPassengersArmour = IsModeEnabled(MODE_PASSENGERS_ARMOUR);
if (bPassengersHealth || bPassengersArmour)
{
int seats = Get_Vehicle_Seat_Count(obj);
for (int i = 1; i < seats; ++i)
{
RegenObject(Get_Vehicle_Occupant(obj, i), bPassengersHealth, bPassengersArmour);
}
}
}
}
Commands->Start_Timer(obj, this, m_interval, TIMER_MISC_TICK);
}
// -------------------------------------------------------------------------------------------------
void dp88_RegenerateHitpoints::RegenObject(GameObject* obj, bool bHealth, bool bArmour)
{
if (NULL == obj || !bHealth && !bArmour)
return;
float hitpoints = (bHealth ? Commands->Get_Health(obj) : 0.0f) + (bArmour ? Commands->Get_Shield_Strength(obj) : 0.0f);
float maxHitpoints = (bHealth ? Commands->Get_Max_Health(obj) : 0.0f) + (bArmour ? Commands->Get_Max_Shield_Strength(obj) : 0.0f);
if (hitpoints < maxHitpoints)
{
float regenCap = (maxHitpoints*m_maxPercent);
float amount = min(m_amount, regenCap);
if (hitpoints < regenCap)
{
if (m_warheadId != -1)
{
Commands->Apply_Damage(obj, amount, ArmorWarheadManager::Get_Warhead_Name(m_warheadId), NULL);
}
else
{
ApplyNonWarheadRepairs(obj, amount, bHealth, bArmour);
}
// Trigger update for built-in engine damage bones
if (obj->As_VehicleGameObj())
{
obj->As_VehicleGameObj()->Damage_Meshes_Update();
}
}
}
}
// -------------------------------------------------------------------------------------------------
void dp88_RegenerateHitpoints::ApplyNonWarheadRepairs(GameObject* obj, float amount, bool bHealth, bool bArmour)
{
if (bHealth)
{
float health = Commands->Get_Health(obj);
float hrepair = min(amount, Commands->Get_Max_Health(obj) - health);
Commands->Set_Health(obj, health + hrepair);
amount -= hrepair;
}
if (bArmour)
{
float armour = Commands->Get_Shield_Strength(obj);
float arepair = min(amount, Commands->Get_Max_Shield_Strength(obj) - armour);
Commands->Set_Shield_Strength(obj, armour + arepair);
}
}
// -------------------------------------------------------------------------------------------------
void dp88_RegenerateHitpoints::Damaged(GameObject *obj, GameObject *damager, float amount)
{
if (amount > 0.0f)
m_lastDamage = time(NULL);
}
// -------------------------------------------------------------------------------------------------
void dp88_RegenerateHitpoints::Custom ( GameObject* pObj, int type, int param, GameObject* pSender )
{
if ( type == CUSTOM_VETERANCY_PROMOTED )
{
if (2==param)
m_amount = Get_Float_Parameter("Hitpoints_Elite");
else if (1==param)
m_amount = Get_Float_Parameter("Hitpoints_Veteran");
else
m_amount = Get_Float_Parameter("Hitpoints");
}
}
// -------------------------------------------------------------------------------------------------
ScriptRegistrant<dp88_RegenerateHitpoints> dp88_RegenerateHitpoints_Registrant(
"dp88_RegenerateHitpoints",
"Hitpoints:float,"
"Interval=1:int,"
"Warhead:string,"
"Max_Percent=100:int,"
"Damage_Timeout=0:int,"
"Hitpoints_Veteran:float,"
"Hitpoints_Elite:float,"
"Mode=3:int"
);
/*------------------------
Spawn Vehicle Part script
--------------------------*/
void dp88_CreateAttachedObject::Created(GameObject* obj)
{
m_spawnedObjectId = NULL;
m_hasDriver = NULL != Get_Vehicle_Driver(obj); // In theory, might not be attached at vehicle creation :)
// Spawn the new object
GameObject* spawnedObject = Commands->Create_Object_At_Bone(obj, Get_Parameter("Preset"), Get_Parameter("Bone"));
if (NULL == spawnedObject)
{
Console_Output("[%d:%s:%s] Critical Error: Failed to create an instance of the preset %s. Destroying script...\n", Commands->Get_ID(obj), Commands->Get_Preset_Name(obj), this->Get_Name(), Get_Parameter("Preset"));
Destroy_Script();
return;
}
// Attach it to the parent
Commands->Attach_To_Object_Bone(spawnedObject, obj, Get_Parameter("Bone"));
m_spawnedObjectId = Commands->Get_ID(spawnedObject);
// Configure linking features (health & veterancy)
if (1 == Get_Int_Parameter("EnableHealthLink"))
{
Attach_Script_Once_V(spawnedObject, "dp88_linkHealth", "%d", Commands->Get_ID(obj));
}
if (1 == Get_Int_Parameter("EnableVeterancyLink"))
{
Attach_Script_Once_V(spawnedObject, "dp88_linkVetPoints", "%d", Commands->Get_ID(obj));
}
// Configure AI visibility
if (0 == Get_Int_Parameter("VisibleToAI"))
{
Commands->Set_Is_Visible(spawnedObject, false);
}
// If driver customrs are enabled, send the appropriate custom based on whether we have a driver
int driverCustom = (m_hasDriver) ? Get_Int_Parameter("DriverEnterCustom") : Get_Int_Parameter("DriverExitCustom");
if (0 != driverCustom)
{
Commands->Send_Custom_Event(obj, spawnedObject, driverCustom, 0, 0);
}
}
// -------------------------------------------------------------------------------------------------
void dp88_CreateAttachedObject::Killed(GameObject* obj, GameObject *killer)
{
if (NULL != m_spawnedObjectId)
{
GameObject* spawnedObject = Commands->Find_Object(m_spawnedObjectId);
if (NULL != spawnedObject)
{
Commands->Destroy_Object(spawnedObject);
}
}
m_spawnedObjectId = NULL;
}
// -------------------------------------------------------------------------------------------------
void dp88_CreateAttachedObject::Custom(GameObject *obj, int type, int param, GameObject *sender)
{
if (type == CUSTOM_EVENT_VEHICLE_ENTERED || type == CUSTOM_EVENT_VEHICLE_EXITED)
{
GameObject* spawnedObject = Commands->Find_Object(m_spawnedObjectId);
if (NULL == spawnedObject)
{
return;
}
// Always sync the spawned objects team with our own
Commands->Set_Player_Type(spawnedObject, Commands->Get_Player_Type(obj));
// Decide which custom, if any, to send
bool hasDriver = NULL != Get_Vehicle_Driver(obj);
if (hasDriver != m_hasDriver)
{
m_hasDriver = hasDriver;
int driverCustom = (m_hasDriver) ? Get_Int_Parameter("DriverEnterCustom") : Get_Int_Parameter("DriverExitCustom");
if (0 != driverCustom)
{
Commands->Send_Custom_Event(obj, spawnedObject, driverCustom, 0, 0);
}
}
}
}
// -------------------------------------------------------------------------------------------------
ScriptRegistrant<dp88_CreateAttachedObject> dp88_CreateAttachedObject_Registrant(
"dp88_CreateAttachedObject",
"Preset:string,"
"Bone:string,"
"EnableHealthLink=1:int,"
"EnableVeterancyLink=0:int,"
"VisibleToAI=0:int,"
"DriverEnterCustom=0:int,"
"DriverExitCustom=0:int"
);
/*------------------------
Custom Points Percentage script
--------------------------*/
void dp88_customPointsPercentage::Created ( GameObject* obj )
{
// Preload values since converting strings to floats every time we take
// damage is very inefficient
m_killPoints = Get_Float_Parameter("killPoints") / 100;
m_damagePoints = Get_Float_Parameter("damagePoints") / 100;
m_repairPoints = Get_Float_Parameter("repairPoints") / 100;
m_killMoney = Get_Float_Parameter("killMoney") / 100;
m_damageMoney = Get_Float_Parameter("damageMoney") / 100;
m_repairMoney = Get_Float_Parameter("repairMoney") / 100;
}
// -------------------------------------------------------------------------------------------------
void dp88_customPointsPercentage::Damaged ( GameObject *obj, GameObject *damager, float amount )
{
// Abort if there is no damager, or the unit damaged itself, or the damager is not
// a star
if ( !damager || damager == obj || !Commands->Is_A_Star(damager) )
return;
/* Damaged or repaired? Then convert amount into it's absolute value for
calculating points granted */
bool bRepair = (amount < 0);
float points = ((bRepair) ? m_repairPoints : m_damagePoints) * amount;
float money = ((bRepair) ? m_repairMoney : m_damageMoney) * amount;
// Give the damager their points and money
GivePointsAndMoney ( damager, points, money );
}
// -------------------------------------------------------------------------------------------------
void dp88_customPointsPercentage::Killed ( GameObject* obj, GameObject *killer )
{
// Abort if there is no killer, or the unit killed itself, or the killer is not
// a star
if ( !killer || killer == obj || !Commands->Is_A_Star(killer) )
return;
// Give the killer their points and money
GivePointsAndMoney ( killer, m_killPoints, m_killMoney );
}
// -------------------------------------------------------------------------------------------------
void dp88_customPointsPercentage::GivePointsAndMoney ( GameObject* obj, float points, float money )
{
float pointsMultiplier = 1.f;
SmartGameObj *smart = obj->As_SmartGameObj();
if (smart->Is_Teammate(Owner()->As_DamageableGameObj()))
{
pointsMultiplier = -pointsMultiplier;
}
else if (!smart->Is_Enemy(Owner()->As_DamageableGameObj()))
{
pointsMultiplier = 0.f;
}
points *= pointsMultiplier;
money *= pointsMultiplier;
int playerId = Get_Player_ID(obj);
if ( playerId >= 0 )
{
if ( cPlayer* player = Find_Player(playerId) )
{
player->Set_Score(player->Get_Score()+points);
if (money > 0)
{
player->Increment_Money(money);
}
}
}
int team = Get_Object_Type(obj);
Set_Team_Score(team, Get_Team_Score(team) + points);
}
// -------------------------------------------------------------------------------------------------
ScriptRegistrant<dp88_customPointsPercentage> dp88_customPointsPercentage_Registrant(
"dp88_customPointsPercentage",
"killPoints:float,"
"damagePoints:float,"
"repairPoints:float,"
"killMoney:float,"
"damageMoney:float,"
"repairMoney:float"
);
| 33.594651 | 243 | 0.652974 | mpforums |
41abf5fe5cc98631a45e40b91d2d45a08c985d3a | 599 | cpp | C++ | reciver/main.cpp | talshadow/atto | 88e18a2968912e97d6fa20ad5e4fe8c2fa7d0a37 | [
"MIT"
] | null | null | null | reciver/main.cpp | talshadow/atto | 88e18a2968912e97d6fa20ad5e4fe8c2fa7d0a37 | [
"MIT"
] | null | null | null | reciver/main.cpp | talshadow/atto | 88e18a2968912e97d6fa20ad5e4fe8c2fa7d0a37 | [
"MIT"
] | null | null | null | #include <future>
#include <iostream>
#include <threadpool.hpp>
#include <tcpsocket.hpp>
int main() {
bclasses::TimeCalc timer;
try{
unsigned ThreadsCount = std::thread::hardware_concurrency() > 3 ? 4 : std::thread::hardware_concurrency() + 1;
auto pool = bclasses::ThreadPool::createInstance(ThreadsCount);
auto server = bclasses::TCPAcceptor::createInstance(pool->service(),bclasses::DefaultAdress,bclasses::TCPPort);
std::cout << '\n' << timer.getDuration() << '\n';
std::cin.get();
} catch( std::exception &e) {
ERROR_LOG_MESSAGE(e.what());
}
return 0;
}
| 24.958333 | 115 | 0.671119 | talshadow |
41ac4570ed1c0bbb1661b83e22c7f48ceae77ad4 | 968 | cpp | C++ | benchmark/TastyLib/test/test_MD5.cpp | JaredCJR/ThesisTools | 41af365ca85da3f73f72880488477ec699b05923 | [
"Apache-2.0"
] | 1 | 2018-10-14T13:49:36.000Z | 2018-10-14T13:49:36.000Z | benchmark/TastyLib/test/test_MD5.cpp | JaredCJR/ThesisTools | 41af365ca85da3f73f72880488477ec699b05923 | [
"Apache-2.0"
] | null | null | null | benchmark/TastyLib/test/test_MD5.cpp | JaredCJR/ThesisTools | 41af365ca85da3f73f72880488477ec699b05923 | [
"Apache-2.0"
] | null | null | null | #include "gtest/gtest.h"
#include "tastylib/MD5.h"
using tastylib::MD5;
using std::string;
TEST(MD5, EmptyString) {
EXPECT_STREQ(MD5<>::getInstance()->hash("").c_str(),
"d41d8cd98f00b204e9800998ecf8427e");
}
TEST(MD5, ShortString) {
EXPECT_STREQ(MD5<>::getInstance()->hash("TastyLib").c_str(),
"2dabbfd553b67530e4892eb9481121fa");
EXPECT_STREQ(MD5<>::getInstance()->hash("The quick brown fox jumps over the lazy dog").c_str(),
"9e107d9d372bb6826bd81d3542a419d6");
EXPECT_STREQ(MD5<>::getInstance()->hash("The quick brown fox jumps over the lazy dog.").c_str(),
"e4d909c290d0fb1ca068ffaddf22cbd0");
}
TEST(MD5, LongString) {
string msg;
for (int i = 0; i < 1000; ++i) {
msg += "abcdefghijklmnopqrstuvwxyz0123456789~!@#$%^&*()_+-={}[]|;:<>,.?/";
}
EXPECT_STREQ(MD5<>::getInstance()->hash(msg).c_str(),
"836fb4e7ebd9ec4cd03ac50f2a888ce6");
}
| 33.37931 | 100 | 0.618802 | JaredCJR |
41ac8e5bc3416f9b8db6eafd49e88baa91aeaab5 | 6,194 | cpp | C++ | unit_tests/src/test_logical_paths_and_special_characters.cpp | mcv21/irods | 3c793a5acbbbe25b5f20aaeeca2609417855eee6 | [
"BSD-3-Clause"
] | null | null | null | unit_tests/src/test_logical_paths_and_special_characters.cpp | mcv21/irods | 3c793a5acbbbe25b5f20aaeeca2609417855eee6 | [
"BSD-3-Clause"
] | null | null | null | unit_tests/src/test_logical_paths_and_special_characters.cpp | mcv21/irods | 3c793a5acbbbe25b5f20aaeeca2609417855eee6 | [
"BSD-3-Clause"
] | null | null | null | #include "catch.hpp"
#include "getRodsEnv.h"
#include "rodsPath.h"
#include "miscUtil.h"
#include "filesystem/path.hpp"
#include <cstring>
#include <string>
TEST_CASE("logical paths and special characters")
{
using namespace std::string_literals;
namespace fs = irods::experimental::filesystem;
rodsEnv env;
REQUIRE(getRodsEnv(&env) == 0);
rodsPath_t input{};
SECTION("expand tilde")
{
const std::string in_path = "~";
std::strncpy(input.inPath, in_path.data(), in_path.size());
REQUIRE(parseRodsPath(&input, &env) == 0);
REQUIRE(fs::path{env.rodsHome}.string() == input.outPath);
}
SECTION("hat should not expand to home collection")
{
const std::string in_path = "^";
std::strncpy(input.inPath, in_path.data(), in_path.size());
REQUIRE(parseRodsPath(&input, &env) == 0);
REQUIRE(fs::path{env.rodsHome} / in_path == input.outPath);
}
SECTION("keep leading tilde")
{
const std::string in_path = "/zone/~data_object";
std::strncpy(input.inPath, in_path.data(), in_path.size());
REQUIRE(parseRodsPath(&input, &env) == 0);
REQUIRE(in_path == input.outPath);
}
SECTION("keep leading period")
{
const std::string in_path = "/zone/.data_object";
std::strncpy(input.inPath, in_path.data(), in_path.size());
REQUIRE(parseRodsPath(&input, &env) == 0);
REQUIRE(in_path == input.outPath);
}
SECTION("keep leading hat")
{
const std::string in_path = "/zone/^data_object";
std::strncpy(input.inPath, in_path.data(), in_path.size());
REQUIRE(parseRodsPath(&input, &env) == 0);
REQUIRE(in_path == input.outPath);
}
SECTION("keep trailing tilde")
{
const std::string in_path = "/zone/data_object~";
std::strncpy(input.inPath, in_path.data(), in_path.size());
REQUIRE(parseRodsPath(&input, &env) == 0);
REQUIRE(in_path == input.outPath);
}
SECTION("keep trailing period")
{
const std::string in_path = "/zone/data_object.";
std::strncpy(input.inPath, in_path.data(), in_path.size());
REQUIRE(parseRodsPath(&input, &env) == 0);
REQUIRE(in_path == input.outPath);
}
SECTION("keep trailing hat")
{
const std::string in_path = "/zone/data_object^";
std::strncpy(input.inPath, in_path.data(), in_path.size());
REQUIRE(parseRodsPath(&input, &env) == 0);
REQUIRE(in_path == input.outPath);
}
}
TEST_CASE("test getLastPathElement")
{
using namespace std::string_literals;
char last_path_element[MAX_NAME_LEN]{};
SECTION("/path/to/.")
{
std::string path = "/path/to/.";
REQUIRE(getLastPathElement(path.data(), last_path_element) == 0);
REQUIRE(last_path_element == ""s);
}
SECTION("/path/to/..")
{
std::string path = "/path/to/..";
REQUIRE(getLastPathElement(path.data(), last_path_element) == 0);
REQUIRE(last_path_element == ""s);
}
SECTION("/path/to/foo")
{
std::string path = "/path/to/foo";
REQUIRE(getLastPathElement(path.data(), last_path_element) == 0);
REQUIRE(last_path_element == "foo"s);
}
SECTION("/path/to/foo/.")
{
std::string path = "/path/to/foo/.";
REQUIRE(getLastPathElement(path.data(), last_path_element) == 0);
REQUIRE(last_path_element == ""s);
}
SECTION("/path/to/foo/..")
{
std::string path = "/path/to/foo/..";
REQUIRE(getLastPathElement(path.data(), last_path_element) == 0);
REQUIRE(last_path_element == ""s);
}
SECTION("/path/to/foo/")
{
std::string path = "/path/to/foo/";
REQUIRE(getLastPathElement(path.data(), last_path_element) == 0);
REQUIRE(last_path_element == "/path/to/foo"s);
}
SECTION("/path/to/foo.")
{
std::string path = "/path/to/foo.";
REQUIRE(getLastPathElement(path.data(), last_path_element) == 0);
REQUIRE(last_path_element == "foo."s);
}
SECTION("/path/to/foo~")
{
std::string path = "/path/to/foo~";
REQUIRE(getLastPathElement(path.data(), last_path_element) == 0);
REQUIRE(last_path_element == "foo~"s);
}
SECTION("/path/to/foo^")
{
std::string path = "/path/to/foo^";
REQUIRE(getLastPathElement(path.data(), last_path_element) == 0);
REQUIRE(last_path_element == "foo^"s);
}
SECTION("/.")
{
std::string path = "/.";
REQUIRE(getLastPathElement(path.data(), last_path_element) == 0);
REQUIRE(last_path_element == ""s);
}
SECTION("/..")
{
std::string path = "/..";
REQUIRE(getLastPathElement(path.data(), last_path_element) == 0);
REQUIRE(last_path_element == ""s);
}
SECTION("/")
{
std::string path = "/";
REQUIRE(getLastPathElement(path.data(), last_path_element) == 0);
REQUIRE(last_path_element == ""s);
}
SECTION("/foo")
{
std::string path = "/foo";
REQUIRE(getLastPathElement(path.data(), last_path_element) == 0);
REQUIRE(last_path_element == "foo"s);
}
SECTION("/foo/")
{
std::string path = "/foo/";
REQUIRE(getLastPathElement(path.data(), last_path_element) == 0);
REQUIRE(last_path_element == "/foo"s);
}
SECTION("foo/")
{
std::string path = "foo/";
REQUIRE(getLastPathElement(path.data(), last_path_element) == 0);
REQUIRE(last_path_element == "foo"s);
}
SECTION(".")
{
std::string path = ".";
REQUIRE(getLastPathElement(path.data(), last_path_element) == 0);
REQUIRE(last_path_element == ""s);
}
SECTION("..")
{
std::string path = "..";
REQUIRE(getLastPathElement(path.data(), last_path_element) == 0);
REQUIRE(last_path_element == ""s);
}
SECTION("")
{
std::string path = "";
REQUIRE(getLastPathElement(path.data(), last_path_element) == 0);
REQUIRE(last_path_element == ""s);
}
}
| 27.048035 | 73 | 0.576041 | mcv21 |
41ad2ca7c00b3e8d2c314ff8906b6972599b80aa | 1,600 | hpp | C++ | src/include/migraphx/par_dfor.hpp | aaronenyeshi/AMDMIGraphX | 87528938188f0247f3dfcc6ab9b83c22187109fd | [
"MIT"
] | 72 | 2018-12-06T18:31:17.000Z | 2022-03-30T15:01:02.000Z | src/include/migraphx/par_dfor.hpp | aaronenyeshi/AMDMIGraphX | 87528938188f0247f3dfcc6ab9b83c22187109fd | [
"MIT"
] | 1,006 | 2018-11-30T16:32:33.000Z | 2022-03-31T22:43:39.000Z | src/include/migraphx/par_dfor.hpp | aaronenyeshi/AMDMIGraphX | 87528938188f0247f3dfcc6ab9b83c22187109fd | [
"MIT"
] | 36 | 2019-05-07T10:41:46.000Z | 2022-03-28T15:59:56.000Z | #ifndef MIGRAPHX_GUARD_RTGLIB_PAR_DFOR_HPP
#define MIGRAPHX_GUARD_RTGLIB_PAR_DFOR_HPP
#include <migraphx/par_for.hpp>
#include <migraphx/functional.hpp>
#include <array>
#include <numeric>
namespace migraphx {
inline namespace MIGRAPHX_INLINE_NS {
template <class... Ts>
auto par_dfor(Ts... xs)
{
return [=](auto f) {
using array_type = std::array<std::size_t, sizeof...(Ts)>;
array_type lens = {{static_cast<std::size_t>(xs)...}};
auto n = std::accumulate(lens.begin(), lens.end(), 1, std::multiplies<std::size_t>{});
const std::size_t min_grain = 8;
if(n > 2 * min_grain)
{
array_type strides;
strides.fill(1);
std::partial_sum(lens.rbegin(),
lens.rend() - 1,
strides.rbegin() + 1,
std::multiplies<std::size_t>());
auto size =
std::accumulate(lens.begin(), lens.end(), 1, std::multiplies<std::size_t>());
par_for(size, min_grain, [&](std::size_t i) {
array_type indices;
std::transform(strides.begin(),
strides.end(),
lens.begin(),
indices.begin(),
[&](size_t stride, size_t len) { return (i / stride) % len; });
migraphx::unpack(f, indices);
});
}
else
{
dfor(xs...)(f);
}
};
}
} // namespace MIGRAPHX_INLINE_NS
} // namespace migraphx
#endif
| 30.769231 | 94 | 0.5 | aaronenyeshi |
41affdb114725854740c6fd763b55990350c0165 | 4,463 | cpp | C++ | moos-ivp/ivp/src/lib_mbutil/Figlog.cpp | EasternEdgeRobotics/2018 | 24df2fe56fa6d172ba3c34c1a97f249dbd796787 | [
"MIT"
] | null | null | null | moos-ivp/ivp/src/lib_mbutil/Figlog.cpp | EasternEdgeRobotics/2018 | 24df2fe56fa6d172ba3c34c1a97f249dbd796787 | [
"MIT"
] | null | null | null | moos-ivp/ivp/src/lib_mbutil/Figlog.cpp | EasternEdgeRobotics/2018 | 24df2fe56fa6d172ba3c34c1a97f249dbd796787 | [
"MIT"
] | null | null | null | /*****************************************************************/
/* NAME: Michael Benjamin */
/* ORGN: Dept of Mechanical Eng / CSAIL, MIT Cambridge MA */
/* FILE: Figlog.cpp */
/* DATE: Dec 16th 2010 */
/* */
/* This file is part of IvP Helm Core Libs */
/* */
/* IvP Helm Core Libs is free software: you can redistribute it */
/* and/or modify it under the terms of the Lesser GNU General */
/* Public License as published by the Free Software Foundation, */
/* either version 3 of the License, or (at your option) any */
/* later version. */
/* */
/* IvP Helm Core Libs 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 Lesser GNU General Public License for more */
/* details. */
/* */
/* You should have received a copy of the Lesser GNU General */
/* Public License along with MOOS-IvP. If not, see */
/* <http://www.gnu.org/licenses/>. */
/*****************************************************************/
#include <iostream>
#include "Figlog.h"
#include "MBUtils.h"
#include "ColorParse.h"
using namespace std;
//----------------------------------------------------------------
// Procedure: getMessage
string Figlog::getMessage(unsigned int ix)
{
if(ix >= m_messages.size())
return("");
return(m_messages[ix]);
}
//----------------------------------------------------------------
// Procedure: getWarning
string Figlog::getWarning(unsigned int ix)
{
if(ix >= m_warnings.size())
return("");
return(m_warnings[ix]);
}
//----------------------------------------------------------------
// Procedure: getError
string Figlog::getError(unsigned int ix)
{
if(ix >= m_warnings.size())
return("");
return(m_warnings[ix]);
}
//----------------------------------------------------------------
// Procedure: augMessage
void Figlog::augMessage(string msg)
{
unsigned int vsize = m_messages.size();
if(vsize == 0)
m_messages.push_back(msg);
else
m_messages[vsize-1] += msg;
}
//----------------------------------------------------------------
// Procedure: augWarning
void Figlog::augWarning(string msg)
{
unsigned int vsize = m_warnings.size();
if(vsize == 0)
m_warnings.push_back(msg);
else
m_warnings[vsize-1] += msg;
}
//----------------------------------------------------------------
// Procedure: augError
void Figlog::augError(string msg)
{
unsigned int vsize = m_errors.size();
if(vsize == 0)
m_errors.push_back(msg);
else
m_errors[vsize-1] += msg;
}
//----------------------------------------------------------------
// Procedure: clear
void Figlog::clear()
{
m_messages.clear();
m_warnings.clear();
m_errors.clear();
}
//----------------------------------------------------------------
// Procedure: print
void Figlog::print() const
{
cout << "=====================================================" << endl;
cout << "Figlog Summary: ";
if(m_label == "")
cout << endl;
else
cout << "(" << m_label << ")" << endl;
unsigned int i, isize = m_messages.size();
unsigned int j, jsize = m_warnings.size();
unsigned int k, ksize = m_errors.size();
cout << "Messages: (" << isize << ")" << endl;
for(i=0; i<isize; i++)
cout << " [" << i << "] " << m_messages[i] << endl;
cout << "Warnings: (" << jsize << ")" << endl;
if(jsize > 0) {
cout << termColor("blue") << flush;
for(j=0; j<jsize; j++)
cout << " [" << j << "] " << m_warnings[j] << endl;
cout << termColor() << flush;
}
cout << "Errors: (" << jsize << ")" << endl;
if(ksize > 0) {
cout << termColor("red") << flush;
for(k=0; k<ksize; k++)
cout << " [" << k << "] " << m_errors[k] << endl;
cout << termColor() << flush;
}
cout << "=====================================================" << endl;
}
| 28.608974 | 74 | 0.423482 | EasternEdgeRobotics |
41b61e874572aa7cdc522b06f6f2a9709f6a4fcb | 6,791 | hpp | C++ | src/flat_combining.hpp | schets/flat_combining | fb9a0db459062f4f34d359f5b4d521dd021686fe | [
"MIT"
] | 1 | 2016-06-28T14:02:18.000Z | 2016-06-28T14:02:18.000Z | src/flat_combining.hpp | schets/flat_combining | fb9a0db459062f4f34d359f5b4d521dd021686fe | [
"MIT"
] | null | null | null | src/flat_combining.hpp | schets/flat_combining | fb9a0db459062f4f34d359f5b4d521dd021686fe | [
"MIT"
] | null | null | null | #ifndef FLAT_COMBINING_HPP_
#define FLAT_COMBINING_HPP_
#include "utils.hpp"
#include <atomic>
#include <thread>
#include <iostream>
#include <algorithm>
using namespace std;
#include <type_traits>
#include <stdexcept>
#include <utility>
#include <stdint.h>
#include <stddef.h>
#include "message_alloc.hpp"
namespace flat_combining {
using namespace _private;
int *mtest;
template<class T>
class combining_defaults {
public:
static void commit(T &) {}
static void begin(T &) {}
};
template<class Derived>
class simple_flat_combining {
using mtype = typename Derived::message_type;
//using spal_type = SPAlloc<message>::alloc_type;
typedef char buffer[128];
struct lw_mut {
std::atomic<size_t> mut;
bool try_acquire() {
size_t dummy = 0;
if (!mut.load(std::memory_order_relaxed)) {
return mut.compare_exchange_weak(dummy,
1,
std::memory_order_acquire,
std::memory_order_relaxed);
}
return false;
}
void release() {
mut.store(0, std::memory_order_release);
}
};
enum class not_reason {
empty = 0,
finished,
take_over,
};
struct message {
std::atomic<message *> next;
void *fromwhich;
std::exception_ptr exc_ptr;
not_reason reason;
uint8_t flags;
mtype mess;
message(mtype &m) :
next(0),
mess(std::move(m)),
exc_ptr(nullptr),
reason(not_reason::empty),
flags(0)
{}
};
using mpal_type = typename MPAlloc<message>::alloc_type;
constexpr static uint8_t is_mp = 1 << 1;
constexpr static uint8_t is_stack = 1 << 2;
constexpr static uint8_t is_malloc = 1 << 3;
constexpr static uint8_t alloc_mask = is_mp | is_stack | is_malloc;
struct message;
buffer _backb;
std::atomic<message *> qtail;
buffer _mutex2;
lw_mut op_mut;
buffer _waiting;
std::atomic<char> waiting;
buffer _bottom;
std::atomic<size_t> current;
public:
Derived *cur;
protected:
bool try_to_message(mtype &m,
uint16_t num_try) {
if (op_mut.try_acquire()) {
cur->handle_message(std::move(m));
if (num_try < 0) {
apply_to_messages<false>(-1);
}
else {
apply_to_messages<true>(num_try);
}
op_mut.release();
return true;
}
return false;
}
public:
simple_flat_combining() :
qtail(nullptr),
waiting(0),
current(0) {
op_mut.release();
mtest = (int *)0xffffffffull;
}
void send_operation(mtype m, int16_t num_try = -1) {
if (!try_to_message(m, num_try)) {
size_t n_micros = 0;
message setm(m);
set_flag(is_stack, setm.flags);
send_message(&setm);
//really shouldn't be hit...
try_again:
{
if (n_micros == 0) {
//spin
for (volatile size_t i = 0; i < 10; i++) {}
n_micros = 2;
}
else {
std::this_thread::sleep_for(std::chrono::microseconds(n_micros));
n_micros *= 1.3;
n_micros = std::min(n_micros, (size_t)10);
}
}
switch (setm.reason) {
case not_reason::finished:
std::atomic_thread_fence(std::memory_order_acquire);
if (setm.exc_ptr != nullptr) {
std::rethrow_exception(setm.exc_ptr);
}
break;
case not_reason::empty:
case not_reason::take_over:
if (!try_to_message(setm.mess, num_try)) {
goto try_again;
}
}
}
}
void send_operation_async(mtype m, int16_t num_try = -1) {
if (!try_to_message(m, num_try)) {
send_message(get_message(m));
}
}
private:
template<bool check = false>
inline void _handle_message(message &m) {
if (check && m.reason == not_reason::finished) {
return;
}
cur->handle_message(std::move(m.mess));
std::atomic_thread_fence(std::memory_order_release);
m.reason = not_reason::finished;
if (m.reason != not_reason::finished) {
cout << "WFTMATE\n";
}
}
//actual commit and message processing functions
inline void _do_message(message &m) {
try {
_handle_message(m);
}
catch (...) {
std::atomic_thread_fence(std::memory_order_release);
m.exc_ptr = std::current_exception();
}
if (m.reason != not_reason::finished) {
std::cout << "BAD BUG" << std::endl;
}
}
inline void _commit() {
combining_defaults<Derived>::commit(*cur);
}
inline void _begin() {
combining_defaults<Derived>::begin(*cur);
}
inline void set_flag(uint8_t flag,
uint8_t &flg) {
flg |= flag;
}
inline bool test_flag(uint8_t flag,
uint8_t flg) {
return flag & flg;
}
inline void return_message(message *m) {
//delegate to the proper message handler
//multi-producer, on the stack
switch (m->flags & alloc_mask) {
case is_mp:
((mpal_type *)m->fromwhich)->return_message(m);
break;
case is_malloc:
free(m);
case is_stack:
default:
break;
}
}
//allocates a message for
//use by an asynchronous request
message *get_message(mtype &m) {
message *retm;
auto calloc = MPAlloc<message>::current_alloc();
retm = (message *)calloc->get_message();
if (retm) {
new (retm) message(m);
retm->fromwhich = calloc;
set_flag(is_mp, retm->flags);
}
else {
retm = (message *)malloc(sizeof(*retm));
new (retm) message(m);
retm->fromwhich = nullptr;
set_flag(is_malloc, retm->flags);
}
return retm;
}
void send_message(message *m) {
if (test_flag(is_mp, m->flags)) {
if (m->fromwhich == nullptr) {
cout << "Bad ptr somehow! in send first" << endl;
cout << *mtest;
}
}
auto ctail = qtail.load(std::memory_order_relaxed);
do {
m->next.store(ctail, std::memory_order_relaxed);
} while (!qtail.compare_exchange_weak(ctail,
m,
std::memory_order_release,
std::memory_order_relaxed));
if (test_flag(is_mp, m->flags)) {
if (m->fromwhich == nullptr) {
cout << "Bad ptr somehow! in send second" << endl;
cout << *mtest;
}
}
}
template<bool limited>
bool apply_to_messages(int16_t l) {
//make work with older gccs
auto qtest = qtail.load(std::memory_order_relaxed);
if (qtest == nullptr) {
return false;
}
auto ctail = qtail.exchange(nullptr, std::memory_order_relaxed);
FLAT_COMB_CONSUME_FENCE;
uint16_t cnum = 0;
_begin();
for (;;) {
auto cur_m = ctail;
ctail = ctail->next.load(std::memory_order_relaxed);
FLAT_COMB_CONSUME_FENCE;
if (limited) {
++cnum;
}
//this wpn't throw! exceptions are stored in the notification
if (cur_m->reason == not_reason::empty) {
_do_message(*cur_m);
}
return_message(cur_m);
if (ctail == nullptr) {
if (limited && (cnum >= l)) {
break;
}
if (qtail.load(std::memory_order_relaxed) != nullptr) {
//should make work with older gccs
ctail = qtail.exchange(nullptr, std::memory_order_relaxed);
FLAT_COMB_CONSUME_FENCE;
}
else {
break;
}
}
};
_commit();
return true;
}
};
} //namespace flat_combining
#endif
| 19.514368 | 70 | 0.64453 | schets |
41bab5e50385bfb9db7580c865fa9232ef7bb6ba | 781 | cpp | C++ | sorting/selectonSort.cpp | Kshitij993/algorithm | c88efae1e72d057d8dbbb8630ea26f4e5e9860d4 | [
"MIT"
] | null | null | null | sorting/selectonSort.cpp | Kshitij993/algorithm | c88efae1e72d057d8dbbb8630ea26f4e5e9860d4 | [
"MIT"
] | null | null | null | sorting/selectonSort.cpp | Kshitij993/algorithm | c88efae1e72d057d8dbbb8630ea26f4e5e9860d4 | [
"MIT"
] | null | null | null | #include<iostream>
#include<vector>
using namespace std;
vector<int> selectionSort(vector<int> arr)
{
int i,j,small,pos,temp;
for(i=0;i<arr.size();i++)
{
small=arr.at(i);
pos=i;
for(j=i+1;j<arr.size();j++)
{
if(small>arr.at(j))
{
small=arr.at(j);
pos=j;
}
}
temp=arr[i];
arr[i]=arr[pos];
arr[pos]=temp;
}
return arr;
}
int main()
{
int n,i;
cin>>n;
vector<int> a(n);
for(i=0;i<n;i++)
{
cin>>a.at(i);
}
for(i=0;i<a.size();i++)
{
cout<<a.at(i)<<" ";
}
cout<<endl;
vector<int> b = selectionSort(a);
for(i=0;i<b.size();i++)
{
cout<<b.at(i)<<" ";
}
}
| 16.270833 | 42 | 0.408451 | Kshitij993 |
41bc133a5fc7a8a5fcca4bd0b55b7f402dd71fbc | 5,560 | cc | C++ | syzygy/trace/common/clock.cc | dandv/syzygy | 2444520c8e6e0b45b2f45b680d878d60b9636f45 | [
"Apache-2.0"
] | 1 | 2019-04-03T13:56:37.000Z | 2019-04-03T13:56:37.000Z | syzygy/trace/common/clock.cc | pombreda/syzygy | 7bac6936c0c28872bfabc10a1108e0157ff65d4a | [
"Apache-2.0"
] | 1 | 2015-03-19T18:20:25.000Z | 2015-03-19T18:20:25.000Z | syzygy/trace/common/clock.cc | sebmarchand/syzygy | 6c6db0e70e8161f1fec171138a825f6412e7778a | [
"Apache-2.0"
] | 1 | 2020-10-10T16:09:45.000Z | 2020-10-10T16:09:45.000Z | // Copyright 2013 Google Inc. All Rights Reserved.
//
// 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
// 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.
#include "syzygy/trace/common/clock.h"
#include <WinBase.h>
#include <type_traits>
#include "base/logging.h"
#include "base/win/registry.h"
namespace trace {
namespace common {
namespace {
union LargeInteger {
LARGE_INTEGER li;
uint64 ui64;
COMPILE_ASSERT(sizeof(LARGE_INTEGER) == sizeof(uint64),
LARGE_INTEGER_and_uint64_must_have_same_size);
};
typedef ULONGLONG (*GetTickCount64Ptr)();
} // namespace
void GetTickTimerInfo(TimerInfo* timer_info) {
DCHECK(timer_info != NULL);
// Ticks are in milliseconds.
timer_info->frequency = 1000;
// The resolution of the tick counter varies, but is documented to have a
// worst case of 16 ms.
timer_info->resolution = 16;
}
void GetTscTimerInfo(TimerInfo* timer_info) {
DCHECK(timer_info != NULL);
::memset(timer_info, 0, sizeof(TimerInfo));
// Check the TscInvariant flag to see if we can rely on TSC as a constant
// rate timer that is synchronous across all cores. This is in
// CPUID.80000007.EDX[8].
int info[4];
::__cpuid(info, 0x80000007);
if ((info[3] & (1 << 8)) == 0)
return;
// Get the CPU frequency. If all is well, this is the frequency of the TSC
// timer.
base::win::RegKey cpureg;
DWORD mhz = 0;
if (cpureg.Open(HKEY_LOCAL_MACHINE,
L"HARDWARE\\DESCRIPTION\\System\\CentralProcessor\\0",
KEY_READ) != 0 ||
cpureg.ReadValueDW(L"~MHz", &mhz) != 0) {
LOG(WARNING) << "Unable to get CPU frequency from registry.";
return;
}
// An invariant TSC is documented to run at the fastest clock speed of the
// CPU.
timer_info->frequency = mhz * 1000000;
timer_info->resolution = 1;
}
bool TimerToFileTime(const FILETIME& file_time_ref,
const TimerInfo& timer_info,
const uint64& timer_ref,
const uint64& timer_value,
FILETIME* file_time) {
DCHECK(file_time != NULL);
// This only works if we have valid timer information.
if (timer_info.frequency == 0 || timer_info.resolution == 0)
return false;
uint64 t = (static_cast<uint64>(file_time_ref.dwHighDateTime) << 32) |
file_time_ref.dwLowDateTime;
// The filetime is expressed in 100ns intervals.
double cycles_per_100ns = 1.0e-7 * timer_info.frequency;
double elapsed_100ns_intervals =
(static_cast<double>(timer_value) - timer_ref) / cycles_per_100ns;
double new_file_time = t + elapsed_100ns_intervals;
if (new_file_time < 0)
return false;
t = static_cast<uint64>(new_file_time);
file_time->dwLowDateTime = t & 0xFFFFFFFF;
file_time->dwHighDateTime = t >> 32;
return true;
}
uint64 GetTicks() {
// We can't explicitly invoke GetTickCount64 as it doesn't exist in Windows
// XP. This would make all of our trace code unable to be run on XP systems.
const GetTickCount64Ptr kUninitialized =
reinterpret_cast<GetTickCount64Ptr>(1);
static GetTickCount64Ptr get_tick_count64 = kUninitialized;
// This is racy but safe. Worst case scenario multiple threads do the lookup,
// each of them writing the same value to |get_tick_count64|. Since writes are
// atomic all will be well by the time it is dereferenced.
if (get_tick_count64 == kUninitialized) {
HMODULE kernel32 = ::GetModuleHandleA("kernel32.dll");
DCHECK(kernel32 != NULL);
get_tick_count64 = reinterpret_cast<GetTickCount64Ptr>(
::GetProcAddress(kernel32, "GetTickCount64"));
}
DCHECK(get_tick_count64 != kUninitialized);
if (get_tick_count64 != NULL)
return (*get_tick_count64)();
// Fall back to using the 32-bit counter if the 64-bit one is not available.
return ::GetTickCount();
}
void GetClockInfo(ClockInfo* clock_info) {
DCHECK(clock_info != NULL);
::memset(clock_info, 0, sizeof(ClockInfo));
GetTickTimerInfo(&clock_info->ticks_info);
GetTscTimerInfo(&clock_info->tsc_info);
::GetSystemTimeAsFileTime(&clock_info->file_time);
// The TSC timer may not always be valid/available.
if (clock_info->tsc_info.frequency)
clock_info->tsc_reference = GetTsc();
// The tick counter is always valid.
clock_info->ticks_reference = GetTicks();
}
bool TicksToFileTime(const ClockInfo& clock_info,
uint64 ticks,
FILETIME* file_time) {
DCHECK(file_time != NULL);
return TimerToFileTime(clock_info.file_time,
clock_info.ticks_info,
clock_info.ticks_reference,
ticks,
file_time);
}
bool TscToFileTime(const ClockInfo& clock_info,
uint64 tsc,
FILETIME* file_time) {
DCHECK(file_time != NULL);
return TimerToFileTime(clock_info.file_time,
clock_info.tsc_info,
clock_info.tsc_reference,
tsc,
file_time);
}
} // namespace common
} // namespace trace
| 31.590909 | 80 | 0.672842 | dandv |
41bc140502b6052a922be91a0472d904d77c2455 | 1,138 | cpp | C++ | src/UniSizeAllocator.cpp | mjssw/crux-net | 6dd2e2b36e9e6211b959f21cb34e3c7fb4845788 | [
"BSD-3-Clause"
] | 1 | 2016-07-04T16:07:57.000Z | 2016-07-04T16:07:57.000Z | src/UniSizeAllocator.cpp | mjssw/crux-net | 6dd2e2b36e9e6211b959f21cb34e3c7fb4845788 | [
"BSD-3-Clause"
] | null | null | null | src/UniSizeAllocator.cpp | mjssw/crux-net | 6dd2e2b36e9e6211b959f21cb34e3c7fb4845788 | [
"BSD-3-Clause"
] | null | null | null | #include "UniSizeAllocator.h"
namespace Crux
{
UniSizeAllocator::UniSizeAllocator( size_t size, int count )
{
//allocate all needed memory
m_pMemoryStart = malloc( size * count );
//link the free memory
LinkFreeElement( size, count );
}
UniSizeAllocator::~UniSizeAllocator()
{
free( m_pMemoryStart );
m_pMemoryStart = NULL;
}
void* UniSizeAllocator::allocate()
{
obj* pCurrentObj = m_FreeList;
if( NULL == pCurrentObj )
{
return NULL;
}
m_FreeList = pCurrentObj->m_pFreeListLink;
return pCurrentObj;
}
void UniSizeAllocator::deallocate( void* p )
{
obj* pCurrentObj = (obj*)p;
pCurrentObj->m_pFreeListLink = m_FreeList;
m_FreeList = pCurrentObj;
}
void UniSizeAllocator::LinkFreeElement( size_t size, int count )
{
m_FreeList = (obj*)m_pMemoryStart;
obj* pCurrentObj = m_FreeList;
//last element's free link is null, so loop count is count-1
for( int freeElementNum = 0; freeElementNum < count - 1; ++freeElementNum )
{
obj* pNextObj = (obj*)( (char*)pCurrentObj + size );
pCurrentObj->m_pFreeListLink = pNextObj;
pCurrentObj = pNextObj;
}
pCurrentObj->m_pFreeListLink = NULL;
}
} //namespace Crux
| 20.321429 | 76 | 0.723199 | mjssw |
41bf4993d552b742af10d37c4aa996685258e728 | 2,255 | cpp | C++ | worldlib/src/world/Observation.cpp | GT-RAIL/spatial_temporal_learning | 7935b361909a159873e6589e994f0d0d5fb5fe49 | [
"BSD-3-Clause"
] | null | null | null | worldlib/src/world/Observation.cpp | GT-RAIL/spatial_temporal_learning | 7935b361909a159873e6589e994f0d0d5fb5fe49 | [
"BSD-3-Clause"
] | null | null | null | worldlib/src/world/Observation.cpp | GT-RAIL/spatial_temporal_learning | 7935b361909a159873e6589e994f0d0d5fb5fe49 | [
"BSD-3-Clause"
] | 1 | 2021-08-01T17:45:13.000Z | 2021-08-01T17:45:13.000Z | /*!
* \file Observation.cpp
* \brief World observation configuration information.
*
* An observation consists of seeing a given item on a given surface at a give pose.
*
* \author Russell Toris, WPI - rctoris@wpi.edu
* \date April 24, 2015
*/
// worldlib
#include "worldlib/world/Observation.h"
using namespace std;
using namespace rail::spatial_temporal_learning::worldlib::geometry;
using namespace rail::spatial_temporal_learning::worldlib::world;
Observation::Observation(const Item &item, const Surface &surface, const Pose &pose, const ros::Time &time,
const ros::Time &removed_estimate, const ros::Time &removed_observed)
: item_(item), surface_(surface), pose_(pose), time_(time), removed_estimate_(removed_estimate),
removed_observed_(removed_observed)
{
}
const Item &Observation::getItem() const
{
return item_;
}
Item &Observation::getItem()
{
return item_;
}
void Observation::setItem(const Item &item)
{
item_ = item;
}
const Surface &Observation::getSurface() const
{
return surface_;
}
Surface &Observation::getSurface()
{
return surface_;
}
void Observation::setSurface(const Surface &surface)
{
surface_ = surface;
}
const PlacementSurface &Observation::getPlacementSurface() const
{
return surface_.findClosestPlacementSurface(pose_.getPosition());
}
const Pose &Observation::getPose() const
{
return pose_;
}
Pose &Observation::getPose()
{
return pose_;
}
void Observation::setPose(const Pose &pose)
{
pose_ = pose;
}
const ros::Time &Observation::getTime() const
{
return time_;
}
ros::Time &Observation::getTime()
{
return time_;
}
void Observation::setTime(const ros::Time &time)
{
time_ = time;
}
const ros::Time &Observation::getRemovedEstimate() const
{
return removed_estimate_;
}
ros::Time &Observation::getRemovedEstimate()
{
return removed_estimate_;
}
void Observation::setRemovedEstimate(const ros::Time &removed_estimate)
{
removed_estimate_ = removed_estimate;
}
const ros::Time &Observation::getRemovedObserved() const
{
return removed_observed_;
}
ros::Time &Observation::getRemovedObserved()
{
return removed_observed_;
}
void Observation::setRemovedObserved(const ros::Time &removed_observed)
{
removed_observed_ = removed_observed;
}
| 18.94958 | 107 | 0.742794 | GT-RAIL |
41bfdf2cb1ffc9fb91ecf7acedc1ffe3a8d7216a | 901 | cpp | C++ | WinNTKline/KlineUtil/test/Testcase.cpp | TsyQi/Auto-control | d0dda0752d53d28f358346ee7ab217bf05118c96 | [
"Apache-2.0"
] | 2 | 2015-03-08T01:06:39.000Z | 2015-03-14T15:33:59.000Z | WinNTKline/KlineUtil/test/Testcase.cpp | TsyQi/Auto-control | d0dda0752d53d28f358346ee7ab217bf05118c96 | [
"Apache-2.0"
] | null | null | null | WinNTKline/KlineUtil/test/Testcase.cpp | TsyQi/Auto-control | d0dda0752d53d28f358346ee7ab217bf05118c96 | [
"Apache-2.0"
] | null | null | null | #include <ios>
#include <cstring>
#define EXCEPTION_MESSAGE_MAXLEN 256
template <class TestClass>
class TestCase
{
public:
TestCase<TestClass>() { testClass = new TestClass(); };
TestCase<TestClass> getInstance();
virtual ~TestCase<TestClass>();
private:
TestCase<TestClass> instance;
TestClass* testClass;
};
template <class TestClass>
TestCase<TestClass>
TestCase<TestClass>::getInstance()
{
if (instance == nullptr)
instance = new TestCase<TestClass>();
return instance;
}
template <class TestClass>
TestCase<TestClass>::~TestCase()
{
delete testClass;
delete instance;
}
class Exception
{
private:
char m_ExceptionMessage[EXCEPTION_MESSAGE_MAXLEN];
public:
Exception(char *msg)
{
strncpy_s(m_ExceptionMessage, msg, EXCEPTION_MESSAGE_MAXLEN);
}
inline char *GetMessage()
{
return m_ExceptionMessage;
}
};
| 18.770833 | 69 | 0.695893 | TsyQi |
41c60c54c461e3a1ddc05413b9dd6ce60c910755 | 201 | cpp | C++ | Filesystem/Filesystem/File.cpp | mscheffauer/file-system | a9abe1130ab1a8d5ab8ed1a41ba10d049d25a7c6 | [
"Unlicense"
] | null | null | null | Filesystem/Filesystem/File.cpp | mscheffauer/file-system | a9abe1130ab1a8d5ab8ed1a41ba10d049d25a7c6 | [
"Unlicense"
] | null | null | null | Filesystem/Filesystem/File.cpp | mscheffauer/file-system | a9abe1130ab1a8d5ab8ed1a41ba10d049d25a7c6 | [
"Unlicense"
] | null | null | null | #include "File.h"
File::File(FSNode* firstChild, FSNode* nextSibling) : FSNode(nullptr,nextSibling)
{
//do nothing else
}
void File::print(std::ostream& os) const
{
FSNode::print(os);
}
| 16.75 | 82 | 0.661692 | mscheffauer |
41ce0c934e61500893b53582750567cf701a6bda | 897 | cpp | C++ | RenderSystem.cpp | skylarbpayne/CESPong | 670348abb41d9c2048ecb510bf2ad06464b0efa4 | [
"Apache-2.0"
] | 1 | 2017-11-23T01:47:59.000Z | 2017-11-23T01:47:59.000Z | RenderSystem.cpp | skylarbpayne/CESPong | 670348abb41d9c2048ecb510bf2ad06464b0efa4 | [
"Apache-2.0"
] | null | null | null | RenderSystem.cpp | skylarbpayne/CESPong | 670348abb41d9c2048ecb510bf2ad06464b0efa4 | [
"Apache-2.0"
] | null | null | null | /** Render System Implementation
*
* @author Caleb Geiger
* Created: 8-2-2013
* Source File: RenderSystem.cpp
*/
#include "Entity.h"
#include "IRenderComponent.h"
#include "RenderSystem.h"
void RenderSystem::Update(unsigned int dt)
{
std::set<unsigned int>::iterator it;
for(it = _EntitiesToUpdate.begin(); it != _EntitiesToUpdate.end(); ++it)
{
Entity* e = this->GetEntity(*it);
IRenderComponent* rc = e->GetComponent<IRenderComponent>("Render");
this->GetWindow()->draw(rc->GetDrawable());
}
}
bool RenderSystem::ValidateEntity(unsigned int ID)
{
Entity* e = this->GetEntity(ID);
return e->HasComponent("Render");
}
void RenderSystem::OnMessage(EntityMovedMessage& msg)
{
Entity* e = this->GetEntity(msg.ID);
IRenderComponent* rc = e->GetComponent<IRenderComponent>("Render");
rc->SetPosition(msg.newPosition);
}
| 23.605263 | 76 | 0.666667 | skylarbpayne |
41cf957daad6b4215dbf9d617c54679e69c58f24 | 8,295 | hpp | C++ | erts/emulator/beam/jit/beam_jit_common.hpp | sdrees/otp | 05b589602aa41d0f4161fbdc3a810049a6ded285 | [
"Apache-2.0"
] | null | null | null | erts/emulator/beam/jit/beam_jit_common.hpp | sdrees/otp | 05b589602aa41d0f4161fbdc3a810049a6ded285 | [
"Apache-2.0"
] | null | null | null | erts/emulator/beam/jit/beam_jit_common.hpp | sdrees/otp | 05b589602aa41d0f4161fbdc3a810049a6ded285 | [
"Apache-2.0"
] | 2 | 2015-10-18T22:36:46.000Z | 2022-01-26T14:01:57.000Z | /*
* %CopyrightBegin%
*
* Copyright Ericsson AB 2021-2022. All Rights Reserved.
*
* 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
* 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.
*
* %CopyrightEnd%
*/
#ifndef __BEAM_JIT_COMMON_HPP__
#define __BEAM_JIT_COMMON_HPP__
#include <string>
#include <vector>
#include <unordered_map>
#include <map>
extern "C"
{
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
#include "sys.h"
#include "bif.h"
#include "erl_vm.h"
#include "global.h"
#include "beam_file.h"
}
#include "beam_jit_args.hpp"
/* This is a view into a contiguous container (like an array or `std::vector`),
* letting us reuse the existing argument array in `beamasm_emit` while keeping
* our interfaces convenient.
*
* Needless to say, spans must not live longer than the container they wrap, so
* you must be careful not to return a span of an rvalue or stack-allocated
* container.
*
* We can replace this with std::span once we require C++20. */
template<typename T>
class Span {
const T *_data;
size_t _size;
public:
template<typename Container>
Span(const Container &other) : Span(other.data(), other.size()) {
}
template<typename Container>
Span(Container &other) : Span(other.data(), other.size()) {
}
Span(const T *begin, const T *end) : Span(begin, end - begin) {
}
Span(const T *data, size_t size) : _data(data), _size(size) {
}
Span<T> subspan(size_t index, size_t count) const {
ASSERT(index <= size() && count <= (size() - index));
return Span<T>(begin() + index, count);
}
const auto size() const {
return _size;
}
const auto begin() const {
return &_data[0];
}
const auto end() const {
return &_data[size()];
}
const T &operator[](size_t index) const {
#ifdef DEBUG
ASSERT(index < _size);
#endif
return _data[index];
}
const T &front() const {
return operator[](0);
}
const T &back() const {
return operator[](size() - 1);
}
};
static const Uint BSC_SEGMENT_OFFSET = 10;
typedef enum : Uint {
BSC_OP_BINARY = 0,
BSC_OP_FLOAT = 1,
BSC_OP_INTEGER = 2,
BSC_OP_UTF8 = 3,
BSC_OP_UTF16 = 4,
BSC_OP_UTF32 = 5,
BSC_OP_LAST = 5
} JitBSCOp;
static const Uint BSC_OP_MASK = 0x07;
static const Uint BSC_OP_OFFSET = 7;
typedef enum : Uint {
BSC_INFO_FVALUE = 0,
BSC_INFO_TYPE = 1,
BSC_INFO_SIZE = 2,
BSC_INFO_UNIT = 3,
BSC_INFO_DEPENDS = 4,
BSC_INFO_LAST = 4,
} JitBSCInfo;
static const Uint BSC_INFO_MASK = 0x07;
static const Uint BSC_INFO_OFFSET = 4;
typedef enum : Uint {
BSC_REASON_BADARG = 0,
BSC_REASON_SYSTEM_LIMIT = 1,
BSC_REASON_DEPENDS = 2,
BSC_REASON_LAST = 2,
} JitBSCReason;
static const Uint BSC_REASON_MASK = 0x03;
typedef enum : Uint {
BSC_VALUE_ARG1 = 0,
BSC_VALUE_ARG3 = 1,
BSC_VALUE_FVALUE = 2,
BSC_VALUE_LAST = 2
} JitBSCValue;
static const Uint BSC_VALUE_MASK = 0x03;
static const Uint BSC_VALUE_OFFSET = 2;
static constexpr Uint beam_jit_set_bsc_segment_op(Uint segment, JitBSCOp op) {
return (segment << BSC_SEGMENT_OFFSET) | (op << BSC_OP_OFFSET);
}
static constexpr Uint beam_jit_update_bsc_reason_info(Uint packed_info,
JitBSCReason reason,
JitBSCInfo info,
JitBSCValue value) {
return packed_info | (value << BSC_VALUE_OFFSET) |
(info << BSC_INFO_OFFSET) | reason;
}
static constexpr Uint beam_jit_get_bsc_segment(Uint packed_info) {
return packed_info >> BSC_SEGMENT_OFFSET;
}
static constexpr JitBSCOp beam_jit_get_bsc_op(Uint packed_info) {
ERTS_CT_ASSERT((BSC_OP_LAST & ~BSC_OP_MASK) == 0);
return (JitBSCOp)((packed_info >> BSC_OP_OFFSET) & BSC_OP_MASK);
}
static constexpr JitBSCInfo beam_jit_get_bsc_info(Uint packed_info) {
ERTS_CT_ASSERT((BSC_INFO_LAST & ~BSC_INFO_MASK) == 0);
return (JitBSCInfo)((packed_info >> BSC_INFO_OFFSET) & BSC_INFO_MASK);
}
static constexpr JitBSCReason beam_jit_get_bsc_reason(Uint packed_info) {
ERTS_CT_ASSERT((BSC_REASON_LAST & ~BSC_REASON_MASK) == 0);
return (JitBSCReason)(packed_info & BSC_REASON_MASK);
}
static constexpr JitBSCValue beam_jit_get_bsc_value(Uint packed_info) {
ERTS_CT_ASSERT((BSC_VALUE_LAST & ~BSC_VALUE_MASK) == 0);
return (JitBSCValue)((packed_info >> BSC_VALUE_OFFSET) & BSC_VALUE_MASK);
}
/* ** */
#if defined(DEBUG) && defined(JIT_HARD_DEBUG)
void beam_jit_validate_term(Eterm term);
#endif
typedef Eterm BeamJitNifF(struct enif_environment_t *, int argc, Eterm argv[]);
enum beam_jit_nif_load_ret { RET_NIF_success, RET_NIF_error, RET_NIF_yield };
Eterm beam_jit_call_bif(Process *c_p,
Eterm *reg,
ErtsCodePtr I,
ErtsBifFunc vbf,
Uint arity);
Eterm beam_jit_call_nif(Process *c_p,
ErtsCodePtr I,
Eterm *reg,
BeamJitNifF *fp,
struct erl_module_nif *NifMod);
enum beam_jit_nif_load_ret beam_jit_load_nif(Process *c_p,
ErtsCodePtr I,
Eterm *reg);
Uint beam_jit_get_map_elements(Eterm map,
Eterm *reg,
Eterm *E,
Uint n,
Eterm *fs);
void beam_jit_bs_field_size_argument_error(Process *c_p, Eterm size);
void beam_jit_bs_add_argument_error(Process *c_p, Eterm A, Eterm B);
Eterm beam_jit_bs_init(Process *c_p,
Eterm *reg,
ERL_BITS_DECLARE_STATEP,
Eterm num_bytes,
Uint alloc,
unsigned Live);
Eterm beam_jit_bs_init_bits(Process *c_p,
Eterm *reg,
ERL_BITS_DECLARE_STATEP,
Uint num_bits,
Uint alloc,
unsigned Live);
Eterm beam_jit_bs_get_integer(Process *c_p,
Eterm *reg,
Eterm context,
Uint flags,
Uint size,
Uint Live);
ErtsMessage *beam_jit_decode_dist(Process *c_p, ErtsMessage *msgp);
Sint beam_jit_remove_message(Process *c_p,
Sint FCALLS,
Eterm *HTOP,
Eterm *E,
Uint32 active_code_ix);
void beam_jit_bs_construct_fail_info(Process *c_p,
Uint packed_error_info,
Eterm arg3,
Eterm arg1);
Sint beam_jit_bs_bit_size(Eterm term);
void beam_jit_take_receive_lock(Process *c_p);
void beam_jit_wait_locked(Process *c_p, ErtsCodePtr cp);
void beam_jit_wait_unlocked(Process *c_p, ErtsCodePtr cp);
enum beam_jit_tmo_ret { RET_next = 0, RET_wait = 1, RET_badarg = 2 };
enum beam_jit_tmo_ret beam_jit_wait_timeout(Process *c_p,
Eterm timeout_value,
ErtsCodePtr next);
void beam_jit_timeout(Process *c_p);
void beam_jit_timeout_locked(Process *c_p);
void beam_jit_return_to_trace(Process *c_p);
Eterm beam_jit_build_argument_list(Process *c_p, const Eterm *regs, int arity);
Export *beam_jit_handle_unloaded_fun(Process *c_p,
Eterm *reg,
int arity,
Eterm fun_thing);
#endif
| 30.722222 | 79 | 0.602773 | sdrees |
41d069dec2882fbf50933bb83d79d6dbfdfaf225 | 3,678 | cpp | C++ | Code/External/GacLib/Tutorial/Console_Workflow/W04_InheritingCppClasses/Main.cpp | kasicass/gaclib-playground | 3f67caf6af09e6d2e8da7fcb1c67478789970568 | [
"MIT"
] | null | null | null | Code/External/GacLib/Tutorial/Console_Workflow/W04_InheritingCppClasses/Main.cpp | kasicass/gaclib-playground | 3f67caf6af09e6d2e8da7fcb1c67478789970568 | [
"MIT"
] | null | null | null | Code/External/GacLib/Tutorial/Console_Workflow/W04_InheritingCppClasses/Main.cpp | kasicass/gaclib-playground | 3f67caf6af09e6d2e8da7fcb1c67478789970568 | [
"MIT"
] | null | null | null | #include <VlppWorkflowCompiler.h>
using namespace vl;
using namespace vl::console;
using namespace vl::collections;
using namespace vl::parsing;
using namespace vl::reflection;
using namespace vl::reflection::description;
using namespace vl::workflow;
using namespace vl::workflow::emitter;
using namespace vl::workflow::runtime;
namespace myapi
{
class App : public Object, public AggregatableDescription<App>
{
private:
WString name;
List<Ptr<IValueSubscription>> subscriptions;
public:
static WString Get()
{
return Console::Read();
}
static WString Get(const WString& message)
{
Console::Write(message);
return Console::Read();
}
static void Print(const WString& text)
{
Console::WriteLine(text);
}
App() = default;
~App()
{
FOREACH(Ptr<IValueSubscription>, sub, subscriptions)
{
sub->Close();
}
FinalizeAggregation();
}
Event<void()> NameChanged;
WString GetName()
{
return name;
}
void SetName(const WString& value)
{
if (name != value)
{
name = value;
NameChanged();
}
}
List<Ptr<IValueSubscription>>& GetSubscriptions()
{
return subscriptions;
}
};
}
#define MYAPI_TYPELIST(F)\
F(myapi::App)\
namespace vl
{
namespace reflection
{
namespace description
{
MYAPI_TYPELIST(DECL_TYPE_INFO)
MYAPI_TYPELIST(IMPL_CPP_TYPE_INFO)
using namespace myapi;
#define _ ,
BEGIN_CLASS_MEMBER(App)
CLASS_MEMBER_STATIC_METHOD_OVERLOAD(Get, NO_PARAMETER, WString(*)())
CLASS_MEMBER_STATIC_METHOD_OVERLOAD(Get, { L"message" }, WString(*)(const WString&))
CLASS_MEMBER_STATIC_METHOD(Print, { L"text" })
CLASS_MEMBER_CONSTRUCTOR(Ptr<App>(), NO_PARAMETER)
CLASS_MEMBER_EVENT(NameChanged)
CLASS_MEMBER_PROPERTY_EVENT_FAST(Name, NameChanged)
CLASS_MEMBER_PROPERTY_READONLY_FAST(Subscriptions)
END_CLASS_MEMBER(App)
#undef _
class MyApiTypeLoader : public Object, public ITypeLoader
{
public:
void Load(ITypeManager* manager)
{
MYAPI_TYPELIST(ADD_TYPE_INFO)
}
void Unload(ITypeManager* manager)
{
}
};
}
}
}
const wchar_t ScriptCode[] = LR"Workflow(
module sampleModule;
using myapi::*;
namespace myscript
{
class MyApp : App
{
new(name: string)
{
Name = name;
/* "this" is not allowed in binding, copy it to a variable */
var self = this;
var subscription = bind($"Hello, $(self.Name)");
attach(subscription.ValueChanged,
func (value: object): void
{
Print(cast string value);
});
subscription.Open();
Subscriptions.Add(subscription);
}
delete
{
Print("Destructing myscript::MyApp");
}
}
}
)Workflow";
int main()
{
// start reflection
LoadPredefinedTypes();
WfLoadLibraryTypes();
GetGlobalTypeManager()->AddTypeLoader(new MyApiTypeLoader);
GetGlobalTypeManager()->Load();
{
// prepare Workflow script code
List<WString> codes;
codes.Add(WString(ScriptCode, false));
// compile code and get assemblies
List<Ptr<ParsingError>> errors;
auto table = WfLoadTable();
auto assembly = Compile(table, codes, errors);
CHECK_ERROR(assembly && errors.Count() == 0, L"Please check the 'errors' variable.");
// initialize the assembly
auto globalContext = MakePtr<WfRuntimeGlobalContext>(assembly);
auto initializeFunction = LoadFunction<void()>(globalContext, L"<initialize>");
initializeFunction();
// call MyApp
auto myapp = UnboxValue<Ptr<App>>(Value::Create(
L"myscript::MyApp",
(
Value_xs(), WString(L"vczh")
)));
myapp->SetName(L"Vczh Libraries++");
myapp->SetName(L"Workflow");
myapp->SetName(L"Gaclib");
}
// stop reflection
DestroyGlobalTypeManager();
} | 19.256545 | 88 | 0.688418 | kasicass |
41d154e6e462f7121e0d04f6d3df4fd0d2b51c72 | 3,732 | cpp | C++ | src/lib/io/mpp.cpp | kinglee1982/FaceRecognitionTerminalDemo | 5e197011a87403d2433f691b8390ec340432b2be | [
"Apache-2.0"
] | 2 | 2020-12-21T13:15:59.000Z | 2021-07-07T08:04:06.000Z | src/lib/io/mpp.cpp | kinglee1982/FaceRecognitionTerminalDemo | 5e197011a87403d2433f691b8390ec340432b2be | [
"Apache-2.0"
] | null | null | null | src/lib/io/mpp.cpp | kinglee1982/FaceRecognitionTerminalDemo | 5e197011a87403d2433f691b8390ec340432b2be | [
"Apache-2.0"
] | 1 | 2022-03-24T01:08:42.000Z | 2022-03-24T01:08:42.000Z | #include "mpp.h"
#include <assert.h>
#include "lib/logger.h"
#include "mpi_sys.h"
#include "mpi_vb.h"
Mpp *Mpp::getInstance() {
static Mpp self;
return &self;
}
Mpp::Mpp() { HI_MPI_SYS_Exit(); }
bool Mpp::init(const VB_CONFIG_S *pVbConf) {
HI_MPI_VB_Exit();
HI_U32 s32Ret = HI_MPI_VB_SetConfig(pVbConf);
if (HI_SUCCESS != s32Ret) {
SZ_LOG_ERROR("HI_MPI_VB_SetConf failed! {:X}", s32Ret);
return false;
}
s32Ret = HI_MPI_VB_Init();
if (HI_SUCCESS != s32Ret) {
SZ_LOG_ERROR("HI_MPI_VB_Init failed! {:X}", s32Ret);
return false;
}
s32Ret = HI_MPI_SYS_Init();
if (HI_SUCCESS != s32Ret) {
SZ_LOG_ERROR("HI_MPI_SYS_Init failed! {:X}", s32Ret);
return false;
}
return true;
}
bool Mpp::viBindVpss(VI_PIPE viPipe, VI_CHN viCh, VPSS_GRP vpssGrp) {
MPP_CHN_S stSrcChn;
MPP_CHN_S stDestChn;
stSrcChn.enModId = HI_ID_VI;
stSrcChn.s32DevId = viPipe;
stSrcChn.s32ChnId = viCh;
stDestChn.enModId = HI_ID_VPSS;
stDestChn.s32DevId = vpssGrp;
stDestChn.s32ChnId = 0;
HI_U32 ret = HI_MPI_SYS_Bind(&stSrcChn, &stDestChn);
if (HI_SUCCESS != ret) {
SZ_LOG_ERROR("HI_MPI_SYS_Bind(VI-VPSS) failed with {:X}", ret);
return false;
}
return true;
}
bool Mpp::vpssBindVo(VPSS_GRP vpssGrp, VPSS_CHN vpssCh, VO_LAYER voLayer,
VO_CHN voCh) {
MPP_CHN_S stSrcChn;
MPP_CHN_S stDestChn;
stSrcChn.enModId = HI_ID_VPSS;
stSrcChn.s32DevId = vpssGrp;
stSrcChn.s32ChnId = vpssCh;
stDestChn.enModId = HI_ID_VO;
stDestChn.s32DevId = voLayer;
stDestChn.s32ChnId = voCh;
HI_U32 ret = HI_MPI_SYS_Bind(&stSrcChn, &stDestChn);
if (HI_SUCCESS != ret) {
SZ_LOG_ERROR("HI_MPI_SYS_Bind(VPSS-VO) failed with {:X}", ret);
return false;
}
return true;
}
bool Mpp::vdecBindVpss(VDEC_CHN vdecCh, VPSS_GRP vpssGrp) {
MPP_CHN_S stSrcChn;
MPP_CHN_S stDestChn;
stSrcChn.enModId = HI_ID_VDEC;
stSrcChn.s32DevId = 0;
stSrcChn.s32ChnId = vdecCh;
stDestChn.enModId = HI_ID_VPSS;
stDestChn.s32DevId = vpssGrp;
stDestChn.s32ChnId = 0;
HI_U32 ret = HI_MPI_SYS_Bind(&stSrcChn, &stDestChn);
if (ret != HI_SUCCESS) {
SZ_LOG_ERROR("HI_MPI_SYS_Bind(VDEC-VPSS) failed {:X}", ret);
return false;
}
return true;
}
bool Mpp::vdecUnBindVpss(VDEC_CHN vdecCh, VPSS_GRP vpssGrp) {
MPP_CHN_S stSrcChn;
MPP_CHN_S stDestChn;
stSrcChn.enModId = HI_ID_VDEC;
stSrcChn.s32DevId = 0;
stSrcChn.s32ChnId = vdecCh;
stDestChn.enModId = HI_ID_VPSS;
stDestChn.s32DevId = vpssGrp;
stDestChn.s32ChnId = 0;
HI_U32 ret = HI_MPI_SYS_UnBind(&stSrcChn, &stDestChn);
if (ret != HI_SUCCESS) {
SZ_LOG_ERROR("HI_MPI_SYS_UnBind(VDEC-VPSS) failed {:X}", ret);
return false;
}
return true;
}
bool Mpp::vpssUnBindVo(VPSS_GRP vpssGrp, VPSS_CHN vpssChn, VO_LAYER voLayer,
VO_CHN voChn) {
MPP_CHN_S stSrcChn;
MPP_CHN_S stDestChn;
stSrcChn.enModId = HI_ID_VPSS;
stSrcChn.s32DevId = vpssGrp;
stSrcChn.s32ChnId = vpssChn;
stDestChn.enModId = HI_ID_VO;
stDestChn.s32DevId = voLayer;
stDestChn.s32ChnId = voChn;
HI_U32 ret = HI_MPI_SYS_UnBind(&stSrcChn, &stDestChn);
if (ret != HI_SUCCESS) {
SZ_LOG_ERROR("HI_MPI_SYS_UnBind(VPSS-VO) failed {:X}", ret);
return false;
}
return true;
}
bool Mpp::viUnBindVpss(VI_PIPE viPipe, VI_CHN viCh, VPSS_GRP vpssGrp) {
MPP_CHN_S stSrcChn;
MPP_CHN_S stDestChn;
stSrcChn.enModId = HI_ID_VI;
stSrcChn.s32DevId = viPipe;
stSrcChn.s32ChnId = viCh;
stDestChn.enModId = HI_ID_VPSS;
stDestChn.s32DevId = vpssGrp;
stDestChn.s32ChnId = 0;
HI_U32 ret = HI_MPI_SYS_UnBind(&stSrcChn, &stDestChn);
if (ret != HI_SUCCESS) {
SZ_LOG_ERROR("HI_MPI_SYS_UnBind(VI-VPSS) failed {:X}", ret);
return false;
}
return true;
}
| 24.392157 | 76 | 0.695874 | kinglee1982 |
41d1a49c8263952116cd3f09b91e62d35d15759d | 663 | hpp | C++ | src/Utils/unreachable.hpp | Kerndog73/STELA | 11449b4bb440494f3ec4b1172b2688b5ec1bcd0a | [
"MIT"
] | 10 | 2018-06-20T05:12:59.000Z | 2021-11-23T02:56:04.000Z | src/Utils/unreachable.hpp | Kerndog73/STELA | 11449b4bb440494f3ec4b1172b2688b5ec1bcd0a | [
"MIT"
] | null | null | null | src/Utils/unreachable.hpp | Kerndog73/STELA | 11449b4bb440494f3ec4b1172b2688b5ec1bcd0a | [
"MIT"
] | null | null | null | //
// unreachable.hpp
// STELA
//
// Created by Indi Kernick on 29/11/18.
// Copyright © 2018 Indi Kernick. All rights reserved.
//
#ifndef stela_unreachable_hpp
#define stela_unreachable_hpp
#if defined(TEST_COVERAGE)
#pragma message "Doing nothing in unreachable contexts"
#define UNREACHABLE() void("LCOV_EXCL_LINE")
#elif defined(NDEBUG) && (defined(__GNUC__) || defined(__clang__))
#pragma message "Calling __builtin_unreachable in unreachable contexts"
#define UNREACHABLE() __builtin_unreachable()
#else
#pragma message "Calling std::terminate in unreachable contexts"
#include <exception>
#define UNREACHABLE() std::terminate()
#endif
#endif
| 21.387097 | 71 | 0.761689 | Kerndog73 |
41d2de594e94610d310981d2d9955c2e5f04dc43 | 4,235 | cpp | C++ | lib/Alembic/AbcGeom/ILight.cpp | ryu-sw/alembic | 395450bad88f9d5ed6d20612e9201aac93a5eb54 | [
"MIT"
] | 921 | 2015-01-03T11:04:38.000Z | 2022-03-29T06:38:34.000Z | lib/Alembic/AbcGeom/ILight.cpp | ryu-sw/alembic | 395450bad88f9d5ed6d20612e9201aac93a5eb54 | [
"MIT"
] | 264 | 2015-01-05T17:15:45.000Z | 2022-03-28T20:14:51.000Z | lib/Alembic/AbcGeom/ILight.cpp | ryu-sw/alembic | 395450bad88f9d5ed6d20612e9201aac93a5eb54 | [
"MIT"
] | 276 | 2015-01-12T01:34:20.000Z | 2022-03-08T09:19:42.000Z | //-*****************************************************************************
//
// Copyright (c) 2009-2012,
// Sony Pictures Imageworks Inc. and
// Industrial Light & Magic, a division of Lucasfilm Entertainment Company Ltd.
//
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
// * Neither the name of Sony Pictures Imageworks, nor
// Industrial Light & Magic, nor the names of their contributors may be used
// to endorse or promote products derived from this software without specific
// prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
//-*****************************************************************************
#include <Alembic/AbcGeom/ILight.h>
namespace Alembic {
namespace AbcGeom {
namespace ALEMBIC_VERSION_NS {
//-*****************************************************************************
void ILightSchema::init( const Abc::Argument &iArg0,
const Abc::Argument &iArg1 )
{
ALEMBIC_ABC_SAFE_CALL_BEGIN( "ILightSchema::init()" );
Abc::Arguments args;
iArg0.setInto( args );
iArg1.setInto( args );
AbcA::CompoundPropertyReaderPtr _this = this->getPtr();
// none of these things are guaranteed to exist
if ( this->getPropertyHeader( ".camera" ) != NULL )
{
m_cameraSchema = ICameraSchema( _this, ".camera", iArg0, iArg1 );
}
if ( this->getPropertyHeader( ".childBnds" ) != NULL )
{
m_childBoundsProperty = Abc::IBox3dProperty( _this, ".childBnds",
iArg0, iArg1 );
}
if ( this->getPropertyHeader( ".arbGeomParams" ) != NULL )
{
m_arbGeomParams = Abc::ICompoundProperty( _this, ".arbGeomParams",
args.getErrorHandlerPolicy() );
}
if ( this->getPropertyHeader( ".userProperties" ) != NULL )
{
m_userProperties = Abc::ICompoundProperty( _this, ".userProperties",
args.getErrorHandlerPolicy() );
}
ALEMBIC_ABC_SAFE_CALL_END_RESET();
}
AbcA::TimeSamplingPtr ILightSchema::getTimeSampling() const
{
ALEMBIC_ABC_SAFE_CALL_BEGIN( "ILightSchema::getTimeSampling" );
if ( m_childBoundsProperty )
{
return m_childBoundsProperty.getTimeSampling();
}
else if ( m_cameraSchema )
{
return m_cameraSchema.getTimeSampling();
}
ALEMBIC_ABC_SAFE_CALL_END();
return AbcA::TimeSamplingPtr();
}
bool ILightSchema::isConstant() const
{
ALEMBIC_ABC_SAFE_CALL_BEGIN( "ILightSchema::isConstant" );
return getNumSamples() < 2;
ALEMBIC_ABC_SAFE_CALL_END();
return true;
}
size_t ILightSchema::getNumSamples() const
{
ALEMBIC_ABC_SAFE_CALL_BEGIN( "ILightSchema::getNumSamples" );
if ( m_childBoundsProperty )
{
return m_childBoundsProperty.getNumSamples();
}
else if ( m_cameraSchema )
{
return m_cameraSchema.getNumSamples();
}
ALEMBIC_ABC_SAFE_CALL_END();
return 0;
}
} // End namespace ALEMBIC_VERSION_NS
} // End namespace AbcGeom
} // End namespace Alembic
| 31.842105 | 80 | 0.662338 | ryu-sw |
41d3db405a8176ffda7c992ff48a1602927050c5 | 2,154 | cpp | C++ | android-31/android/location/LocationProvider.cpp | YJBeetle/QtAndroidAPI | 1468b5dc6eafaf7709f0b00ba1a6ec2b70684266 | [
"Apache-2.0"
] | 12 | 2020-03-26T02:38:56.000Z | 2022-03-14T08:17:26.000Z | android-31/android/location/LocationProvider.cpp | YJBeetle/QtAndroidAPI | 1468b5dc6eafaf7709f0b00ba1a6ec2b70684266 | [
"Apache-2.0"
] | 1 | 2021-01-27T06:07:45.000Z | 2021-11-13T19:19:43.000Z | android-30/android/location/LocationProvider.cpp | YJBeetle/QtAndroidAPI | 1468b5dc6eafaf7709f0b00ba1a6ec2b70684266 | [
"Apache-2.0"
] | 3 | 2021-02-02T12:34:55.000Z | 2022-03-08T07:45:57.000Z | #include "./Criteria.hpp"
#include "../../JString.hpp"
#include "./LocationProvider.hpp"
namespace android::location
{
// Fields
jint LocationProvider::AVAILABLE()
{
return getStaticField<jint>(
"android.location.LocationProvider",
"AVAILABLE"
);
}
jint LocationProvider::OUT_OF_SERVICE()
{
return getStaticField<jint>(
"android.location.LocationProvider",
"OUT_OF_SERVICE"
);
}
jint LocationProvider::TEMPORARILY_UNAVAILABLE()
{
return getStaticField<jint>(
"android.location.LocationProvider",
"TEMPORARILY_UNAVAILABLE"
);
}
// QJniObject forward
LocationProvider::LocationProvider(QJniObject obj) : JObject(obj) {}
// Constructors
// Methods
jint LocationProvider::getAccuracy() const
{
return callMethod<jint>(
"getAccuracy",
"()I"
);
}
JString LocationProvider::getName() const
{
return callObjectMethod(
"getName",
"()Ljava/lang/String;"
);
}
jint LocationProvider::getPowerRequirement() const
{
return callMethod<jint>(
"getPowerRequirement",
"()I"
);
}
jboolean LocationProvider::hasMonetaryCost() const
{
return callMethod<jboolean>(
"hasMonetaryCost",
"()Z"
);
}
jboolean LocationProvider::meetsCriteria(android::location::Criteria arg0) const
{
return callMethod<jboolean>(
"meetsCriteria",
"(Landroid/location/Criteria;)Z",
arg0.object()
);
}
jboolean LocationProvider::requiresCell() const
{
return callMethod<jboolean>(
"requiresCell",
"()Z"
);
}
jboolean LocationProvider::requiresNetwork() const
{
return callMethod<jboolean>(
"requiresNetwork",
"()Z"
);
}
jboolean LocationProvider::requiresSatellite() const
{
return callMethod<jboolean>(
"requiresSatellite",
"()Z"
);
}
jboolean LocationProvider::supportsAltitude() const
{
return callMethod<jboolean>(
"supportsAltitude",
"()Z"
);
}
jboolean LocationProvider::supportsBearing() const
{
return callMethod<jboolean>(
"supportsBearing",
"()Z"
);
}
jboolean LocationProvider::supportsSpeed() const
{
return callMethod<jboolean>(
"supportsSpeed",
"()Z"
);
}
} // namespace android::location
| 18.568966 | 81 | 0.68663 | YJBeetle |
41d3f07c16374b304cad471633177e42e2278ce9 | 562 | cpp | C++ | Core/UIScreen.cpp | anonymousthing/Sulphur | 65820d66ab8dd736e5ce64901177dbdf2ef48100 | [
"Unlicense"
] | null | null | null | Core/UIScreen.cpp | anonymousthing/Sulphur | 65820d66ab8dd736e5ce64901177dbdf2ef48100 | [
"Unlicense"
] | null | null | null | Core/UIScreen.cpp | anonymousthing/Sulphur | 65820d66ab8dd736e5ce64901177dbdf2ef48100 | [
"Unlicense"
] | null | null | null | #include "UIScreen.h"
#include "ResLoader.h"
UIScreen::UIScreen(Graphics *graphics) : Screen(graphics) {
}
UIScreen::~UIScreen() {
}
void UIScreen::addSprite(Sprite *sprite) {
sprites.push_back(sprite);
}
bool UIScreen::update(InputManager *inputManager) {
return false;
}
void UIScreen::draw(int delta) {
//Add all our sprites since the sprite buffer is cleared each frame
for (auto si = sprites.begin(), se = sprites.end(); si != se; ++si) {
Sprite *sprite = *si;
graphics->addSprite(sprite);
}
graphics->set2d();
graphics->draw2d();
}
| 19.37931 | 71 | 0.683274 | anonymousthing |
41d9344fbd8e01046ba4fb3141fa7a2df5576717 | 2,002 | cpp | C++ | src/analysis/event_definition.cpp | maximaximal/Distrac | 9c6b457247206a743ac0b140d0a03a419983c7bf | [
"MIT"
] | null | null | null | src/analysis/event_definition.cpp | maximaximal/Distrac | 9c6b457247206a743ac0b140d0a03a419983c7bf | [
"MIT"
] | null | null | null | src/analysis/event_definition.cpp | maximaximal/Distrac | 9c6b457247206a743ac0b140d0a03a419983c7bf | [
"MIT"
] | null | null | null | #include "distrac/headers.h"
#include "distrac/types.h"
#include <distrac/analysis/event_definition.hpp>
#include <distrac/analysis/property_definition.hpp>
namespace distrac {
event_definition::event_definition(std::string name,
uint8_t id,
std::string description)
: _name(std::move(name))
, _id(id)
, _description(std::move(description)) {
add_property_definition({ "_id", DISTRAC_TYPE_UINT64, 0 });
}
event_definition::event_definition(const distrac_event_header& header,
uint8_t id)
: _name(header.name)
, _id(id)
, _description(header.description)
, _has_causal_dependency(header.enable_after_constraint)
, _causal_dependency_event_id(header.after_event_id) {
_defs.reserve(header.property_count + 1);
add_property_definition({ "_id", DISTRAC_TYPE_UINT64, 0 });
}
event_definition::event_definition(const event_definition& o)
: _name(o._name)
, _defs(o._defs)
, _size(o._size)
, _id(o._id)
, _description(o._description)
, _has_causal_dependency(o._has_causal_dependency)
, _causal_dependency_event_id(o._causal_dependency_event_id) {
recompute_map();
}
event_definition::~event_definition() = default;
std::size_t
event_definition::property_size(std::size_t id) const {
const property_definition& def = definition(id);
return def.size();
}
void
event_definition::add_property_definition(const property_definition& def) {
_defs.push_back(def);
if(def.name()[0] != '_') {
_size += def.size();
}
_defs_map.insert({ def.name(), _defs[_defs.size() - 1] });
}
ssize_t
event_definition::get_property_id(const std::string& name) const {
const auto& it = _defs_map.find(name);
if(it == _defs_map.end())
return -1;
return it->second.id();
}
void
event_definition::recompute_map() {
// NOLINTNEXTLINE modernize-loop-convert
for(size_t i = 0; i < _defs.size(); ++i) {
_defs_map.insert({ _defs[i].name(), _defs[i] });
}
}
}
| 29.441176 | 75 | 0.691309 | maximaximal |
41d9b4d96a5839202d40b1e8e3ed1e771f5291ec | 23,241 | cpp | C++ | implementations/ugene/src/plugins/api_tests/src/core/dbi/assembly/AssemblyDbiUnitTests.cpp | r-barnes/sw_comparison | 1ac2c9cc10a32badd6b8fb1e96516c97f7800176 | [
"BSD-Source-Code"
] | null | null | null | implementations/ugene/src/plugins/api_tests/src/core/dbi/assembly/AssemblyDbiUnitTests.cpp | r-barnes/sw_comparison | 1ac2c9cc10a32badd6b8fb1e96516c97f7800176 | [
"BSD-Source-Code"
] | null | null | null | implementations/ugene/src/plugins/api_tests/src/core/dbi/assembly/AssemblyDbiUnitTests.cpp | r-barnes/sw_comparison | 1ac2c9cc10a32badd6b8fb1e96516c97f7800176 | [
"BSD-Source-Code"
] | null | null | null | /**
* UGENE - Integrated Bioinformatics Tools.
* Copyright (C) 2008-2020 UniPro <ugene@unipro.ru>
* http://ugene.net
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
* MA 02110-1301, USA.
*/
#include "AssemblyDbiUnitTests.h"
#include <U2Core/U2AssemblyDbi.h>
#include <U2Core/U2DbiUtils.h>
#include <U2Core/U2ObjectDbi.h>
#include <U2Core/U2SafePoints.h>
#include <U2Test/TestRunnerSettings.h>
#include "AssemblyDbiTestUtil.h"
namespace U2 {
static const QString &INVALID_ASSEMBLY_ID = "invalid_assembly_id";
static const QString &TOTAL_NUM_READS = "total_num_reads";
static const QString &NUM_READS_IN = "num_reads_in";
static const QString &NUM_READS_OUT = "num_reads_out";
static const QString &GET_READS_IN = "get_reads_region";
static const QString &GET_READS_OUT = "get_reads_out";
static const QString &GET_READS_BY_ROW_REGION = "get_reads_by_row_region";
static const QString &GET_READS_BY_ROW_BEGIN = "get_reads_by_row_begin";
static const QString &GET_READS_BY_ROW_END = "get_reads_by_row_end";
static const QString &GET_READS_BY_ROW_OUT = "get_reads_by_row_out";
static const QString &READS_BY_NAME_IN = "reads_by_name_in";
static const QString &MAX_END_POS = "max_end_pos";
static const QString &MAX_PACKED_ROW_IN = "max_packed_row_in";
static const QString &MAX_PACKED_ROW_OUT = "max_packed_row_out";
static const QString &REMOVE_READS_IN = "remove_reads_in";
static const QString &ADD_READ = "add_read";
const QString &AssemblyTestData::ASS_DB_URL("assembly-dbi.ugenedb");
U2AssemblyDbi *AssemblyTestData::assemblyDbi = NULL;
QList<U2DataId> *AssemblyTestData::assemblyIds = NULL;
TestDbiProvider AssemblyTestData::dbiProvider = TestDbiProvider();
static bool registerTests() {
qRegisterMetaType<U2::AssemblyDbiUnitTests_addReads>("AssemblyDbiUnitTests_addReads");
qRegisterMetaType<U2::AssemblyDbiUnitTests_addReadsInvalid>("AssemblyDbiUnitTests_addReadsInvalid");
qRegisterMetaType<U2::AssemblyDbiUnitTests_calculateCoverage>("AssemblyDbiUnitTests_calculateCoverage");
qRegisterMetaType<U2::AssemblyDbiUnitTests_calculateCoverageInvalid>("AssemblyDbiUnitTests_calculateCoverageInvalid");
qRegisterMetaType<U2::AssemblyDbiUnitTests_countReads>("AssemblyDbiUnitTests_countReads");
qRegisterMetaType<U2::AssemblyDbiUnitTests_countReadsInvalid>("AssemblyDbiUnitTests_countReadsInvalid");
qRegisterMetaType<U2::AssemblyDbiUnitTests_createAssemblyObject>("AssemblyDbiUnitTests_createAssemblyObject");
qRegisterMetaType<U2::AssemblyDbiUnitTests_getAssemblyObject>("AssemblyDbiUnitTests_getAssemblyObject");
qRegisterMetaType<U2::AssemblyDbiUnitTests_getAssemblyObjectInvalid>("AssemblyDbiUnitTests_getAssemblyObjectInvalid");
qRegisterMetaType<U2::AssemblyDbiUnitTests_getMaxEndPos>("AssemblyDbiUnitTests_getMaxEndPos");
qRegisterMetaType<U2::AssemblyDbiUnitTests_getMaxEndPosInvalid>("AssemblyDbiUnitTests_getMaxEndPosInvalid");
qRegisterMetaType<U2::AssemblyDbiUnitTests_getMaxPackedRow>("AssemblyDbiUnitTests_getMaxPackedRow");
qRegisterMetaType<U2::AssemblyDbiUnitTests_getMaxPackedRowInvalid>("AssemblyDbiUnitTests_getMaxPackedRowInvalid");
qRegisterMetaType<U2::AssemblyDbiUnitTests_getReads>("AssemblyDbiUnitTests_getReads");
qRegisterMetaType<U2::AssemblyDbiUnitTests_getReadsInvalid>("AssemblyDbiUnitTests_getReadsInvalid");
qRegisterMetaType<U2::AssemblyDbiUnitTests_getReadsByName>("AssemblyDbiUnitTests_getReadsByName");
qRegisterMetaType<U2::AssemblyDbiUnitTests_getReadsByNameInvalid>("AssemblyDbiUnitTests_getReadsByNameInvalid");
qRegisterMetaType<U2::AssemblyDbiUnitTests_getReadsByRow>("AssemblyDbiUnitTests_getReadsByRow");
qRegisterMetaType<U2::AssemblyDbiUnitTests_getReadsByRowInvalid>("AssemblyDbiUnitTests_getReadsByRowInvalid");
qRegisterMetaType<U2::AssemblyDbiUnitTests_pack>("AssemblyDbiUnitTests_pack");
qRegisterMetaType<U2::AssemblyDbiUnitTests_packInvalid>("AssemblyDbiUnitTests_packInvalid");
qRegisterMetaType<U2::AssemblyDbiUnitTests_removeReads>("AssemblyDbiUnitTests_removeReads");
qRegisterMetaType<U2::AssemblyDbiUnitTests_removeReadsInvalid>("AssemblyDbiUnitTests_removeReadsInvalid");
return true;
}
bool AssemblyTestData::registerTest = registerTests();
void AssemblyTestData::init() {
bool ok = dbiProvider.init(ASS_DB_URL, false);
SAFE_POINT(ok, "dbi provider failed to initialize", );
U2Dbi *dbi = dbiProvider.getDbi();
U2ObjectDbi *objDbi = dbi->getObjectDbi();
U2OpStatusImpl opStatus;
assemblyIds = new QList<U2DataId>(objDbi->getObjects(U2Type::Assembly, 0, U2DbiOptions::U2_DBI_NO_LIMIT, opStatus));
SAFE_POINT_OP(opStatus, );
assemblyDbi = dbi->getAssemblyDbi();
SAFE_POINT(NULL != assemblyDbi, "assembly database not loaded", );
}
U2AssemblyDbi *AssemblyTestData::getAssemblyDbi() {
if (assemblyDbi == NULL) {
AssemblyTestData::init();
}
return assemblyDbi;
}
void AssemblyTestData::shutdown() {
if (assemblyDbi != NULL) {
U2OpStatusImpl opStatus;
dbiProvider.close();
assemblyDbi = NULL;
SAFE_POINT_OP(opStatus, );
}
}
void AssemblyDbiUnitTests_getAssemblyObject::Test() {
U2AssemblyDbi *assemblyDbi = AssemblyTestData::getAssemblyDbi();
const U2DataId id = AssemblyTestData::getAssemblyIds()->first();
U2OpStatusImpl os;
U2Assembly assembly = assemblyDbi->getAssemblyObject(id, os);
CHECK_NO_ERROR(os);
CHECK_EQUAL(id, assembly.id, "assembly id is not equals to oiginal id");
}
void AssemblyDbiUnitTests_getAssemblyObjectInvalid::Test() {
U2AssemblyDbi *assemblyDbi = AssemblyTestData::getAssemblyDbi();
APITestData testData;
testData.addValue(INVALID_ASSEMBLY_ID, QByteArray("zZÿÿ"));
const U2DataId &invalidId = testData.getValue<QByteArray>(INVALID_ASSEMBLY_ID);
U2OpStatusImpl os;
const U2Assembly &assembly = assemblyDbi->getAssemblyObject(invalidId, os);
CHECK_TRUE(assembly.id.isEmpty(), "assembly id is empty");
}
void AssemblyDbiUnitTests_countReads::Test() {
U2AssemblyDbi *assemblyDbi = AssemblyTestData::getAssemblyDbi();
APITestData testData;
// countReads
testData.addValue(TOTAL_NUM_READS, 48);
testData.addValue(NUM_READS_IN, U2Region(10, 10));
testData.addValue(NUM_READS_OUT, 6);
const U2DataId id = AssemblyTestData::getAssemblyIds()->first();
{
U2OpStatusImpl os;
qint64 numReads = assemblyDbi->countReads(id, U2_REGION_MAX, os);
CHECK_NO_ERROR(os);
CHECK_EQUAL(numReads, testData.getValue<qint64>(TOTAL_NUM_READS), "incorrect total num reads");
}
U2OpStatusImpl os;
const U2Region &testRegion = testData.getValue<U2Region>(NUM_READS_IN);
qint64 numReads = assemblyDbi->countReads(id, testRegion, os);
CHECK_NO_ERROR(os);
CHECK_EQUAL(numReads, testData.getValue<qint64>(NUM_READS_OUT), "incorrect total num reads");
}
void AssemblyDbiUnitTests_countReadsInvalid::Test() {
U2AssemblyDbi *assemblyDbi = AssemblyTestData::getAssemblyDbi();
APITestData testData;
testData.addValue(INVALID_ASSEMBLY_ID, QByteArray("zZÿÿ"));
const U2DataId &id = testData.getValue<U2DataId>(INVALID_ASSEMBLY_ID);
U2OpStatusImpl os;
qint64 val = assemblyDbi->countReads(id, U2_REGION_MAX, os);
CHECK_EQUAL(-1, val, "count reads should be -1")
}
void AssemblyDbiUnitTests_getReads::Test() {
U2AssemblyDbi *assemblyDbi = AssemblyTestData::getAssemblyDbi();
APITestData testData;
//getReads
{
testData.addValue(GET_READS_IN, U2Region(140, 145));
U2AssemblyRead read1(new U2AssemblyReadData());
read1->name = "2797 Example sequence FW - secondary sequence 5464";
read1->leftmostPos = 93;
read1->effectiveLen = 49;
read1->packedViewRow = 15;
read1->readSequence = "AAGATCCTCATGTTATATCGGCAGTGGGTTGATCAATCCACGTGGATAG";
read1->cigar.append(U2CigarToken(U2CigarOp_M, 49));
read1->flags = None;
U2AssemblyRead read2(new U2AssemblyReadData());
read2->name = "4940 Example sequence FW - secondary sequence 5466";
read2->leftmostPos = 95;
read2->effectiveLen = 49;
read2->packedViewRow = 0;
read2->readSequence = "GATCCTCATGTTATATCGGCAGTGGGTTGATCAATCCACGTGGATAGAT";
read2->cigar.append(U2CigarToken(U2CigarOp_M, 49));
read2->flags = None;
U2AssemblyRead read3(new U2AssemblyReadData());
read3->name = "2378 Example sequence RV - secondary sequence 5468";
read3->leftmostPos = 97;
read3->effectiveLen = 49;
read3->packedViewRow = 16;
read3->readSequence = "TCCTCATGTTATATCGGCAGTGGGTTGATCAATCCACGTGGATAGATGC";
read3->cigar.append(U2CigarToken(U2CigarOp_M, 49));
read3->flags = None;
QVariantList reads;
reads << qVariantFromValue(read1) << qVariantFromValue(read2) << qVariantFromValue(read3);
testData.addValue(GET_READS_OUT, reads);
}
const U2DataId &id = AssemblyTestData::getAssemblyIds()->first();
const U2Region ®ion = testData.getValue<U2Region>(GET_READS_IN);
U2OpStatusImpl os;
QScopedPointer<U2DbiIterator<U2AssemblyRead>> iter;
iter.reset(assemblyDbi->getReads(id, region, os));
CHECK_NO_ERROR(os);
QVariantList expectedVar = testData.getValue<QVariantList>(GET_READS_OUT);
QList<U2AssemblyRead> expectedReads;
AssemblyDbiTestUtil::var2readList(expectedVar, expectedReads);
CHECK_TRUE(AssemblyDbiTestUtil::compareReadLists(iter.data(), expectedReads), "incorrect expected reads");
}
void AssemblyDbiUnitTests_getReadsInvalid::Test() {
U2AssemblyDbi *assemblyDbi = AssemblyTestData::getAssemblyDbi();
APITestData testData;
testData.addValue(INVALID_ASSEMBLY_ID, QByteArray("zZÿÿ"));
const U2DataId &id = testData.getValue<U2DataId>(INVALID_ASSEMBLY_ID);
U2OpStatusImpl os;
QScopedPointer<U2DbiIterator<U2AssemblyRead>> iter;
iter.reset(assemblyDbi->getReads(id, U2_REGION_MAX, os));
CHECK_TRUE(iter.isNull(), "expected reads should be NULL");
}
void AssemblyDbiUnitTests_getReadsByRow::Test() {
U2AssemblyDbi *assemblyDbi = AssemblyTestData::getAssemblyDbi();
APITestData testData;
// getReadsByRow
{
U2AssemblyRead read1(new U2AssemblyReadData());
read1->name = "4924 Example sequence RV -E(46=3|) secondary sequence 5400";
read1->leftmostPos = 29;
read1->effectiveLen = 49;
read1->packedViewRow = 10;
read1->readSequence = "TGACGCAGCGAGCCGCCTTCATACTTTGTTAGCACGGCTCCACACATAT";
read1->flags = None;
read1->cigar.append(U2CigarToken(U2CigarOp_M, 49));
U2AssemblyRead read2(new U2AssemblyReadData());
read2->name = "2728 Example sequence FW - secondary sequence 5440";
read2->leftmostPos = 69;
read2->effectiveLen = 49;
read2->packedViewRow = 5;
read2->readSequence = "CACACATATGGTCCGACTCTAATGAAGATCCTCATGTTATATCGGCAGT";
read2->flags = None;
read2->cigar.append(U2CigarToken(U2CigarOp_M, 49));
QVariantList reads;
reads << qVariantFromValue(read1) << qVariantFromValue(read2);
testData.addValue(GET_READS_BY_ROW_REGION, U2Region(74, 3));
testData.addValue(GET_READS_BY_ROW_BEGIN, 5);
testData.addValue(GET_READS_BY_ROW_END, 11);
testData.addValue(GET_READS_BY_ROW_OUT, reads);
}
const U2DataId &id = AssemblyTestData::getAssemblyIds()->first();
const U2Region ®ion = testData.getValue<U2Region>(GET_READS_BY_ROW_REGION);
U2OpStatusImpl os;
qint64 begin = testData.getValue<qint64>(GET_READS_BY_ROW_BEGIN);
qint64 end = testData.getValue<qint64>(GET_READS_BY_ROW_END);
QScopedPointer<U2DbiIterator<U2AssemblyRead>> iter;
iter.reset(assemblyDbi->getReadsByRow(id, region, begin, end, os));
CHECK_NO_ERROR(os);
QVariantList expectedVar = testData.getValue<QVariantList>(GET_READS_BY_ROW_OUT);
QList<U2AssemblyRead> expectedReads;
AssemblyDbiTestUtil::var2readList(expectedVar, expectedReads);
CHECK_TRUE(AssemblyDbiTestUtil::compareReadLists(iter.data(), expectedReads), "incorrect expected reads");
}
void AssemblyDbiUnitTests_getReadsByRowInvalid::Test() {
U2AssemblyDbi *assemblyDbi = AssemblyTestData::getAssemblyDbi();
APITestData testData;
{
testData.addValue(INVALID_ASSEMBLY_ID, QByteArray("zZÿÿ"));
testData.addValue(GET_READS_BY_ROW_REGION, U2Region(74, 3));
testData.addValue(GET_READS_BY_ROW_BEGIN, 5);
testData.addValue(GET_READS_BY_ROW_END, 11);
}
const U2DataId &id = testData.getValue<U2DataId>(INVALID_ASSEMBLY_ID);
qint64 begin = testData.getValue<qint64>(GET_READS_BY_ROW_BEGIN);
qint64 end = testData.getValue<qint64>(GET_READS_BY_ROW_END);
const U2Region ®ion = testData.getValue<U2Region>(GET_READS_BY_ROW_REGION);
U2OpStatusImpl os;
QScopedPointer<U2DbiIterator<U2AssemblyRead>> iter;
iter.reset(assemblyDbi->getReadsByRow(id, region, begin, end, os));
CHECK_TRUE(iter.isNull(), "expected reads by row should be NULL");
}
void AssemblyDbiUnitTests_getReadsByName::Test() {
U2AssemblyDbi *assemblyDbi = AssemblyTestData::getAssemblyDbi();
APITestData testData;
// getReadsByName
{
U2AssemblyRead read(new U2AssemblyReadData());
read->name = "Test read";
read->leftmostPos = 93;
read->effectiveLen = 49;
read->packedViewRow = 0;
read->readSequence = "AAGATCCTCATGTTATATCGGCAGTGGGTTGATCAATCCACGTGGATAG";
read->flags = None;
QVariantList readsByName;
readsByName.append(qVariantFromValue(read));
testData.addValue(READS_BY_NAME_IN, readsByName);
}
QVariantList readsVar = testData.getValue<QVariantList>(READS_BY_NAME_IN);
CHECK_TRUE(!readsVar.isEmpty(), "reads list should not be empty");
QList<U2AssemblyRead> reads;
AssemblyDbiTestUtil::var2readList(readsVar, reads);
const QByteArray &name = reads.first()->name;
const U2DataId &id = AssemblyTestData::getAssemblyIds()->first();
{
U2OpStatusImpl os;
BufferedDbiIterator<U2AssemblyRead> it(reads);
assemblyDbi->addReads(id, &it, os);
CHECK_NO_ERROR(os);
}
U2OpStatusImpl os;
QScopedPointer<U2DbiIterator<U2AssemblyRead>> iter;
iter.reset(assemblyDbi->getReadsByName(id, name, os));
CHECK_NO_ERROR(os);
CHECK_TRUE(AssemblyDbiTestUtil::compareReadLists(iter.data(), reads), "incorrect expected read list");
}
void AssemblyDbiUnitTests_getReadsByNameInvalid::Test() {
U2AssemblyDbi *assemblyDbi = AssemblyTestData::getAssemblyDbi();
APITestData testData;
testData.addValue(INVALID_ASSEMBLY_ID, QByteArray("zZÿÿ"));
const U2DataId &id = testData.getValue<U2DataId>(INVALID_ASSEMBLY_ID);
U2OpStatusImpl os;
QScopedPointer<U2DbiIterator<U2AssemblyRead>> iter;
iter.reset(assemblyDbi->getReadsByName(id, "", os));
CHECK_TRUE(iter.isNull(), "reads by name should be NULL");
}
void AssemblyDbiUnitTests_getMaxPackedRow::Test() {
U2AssemblyDbi *assemblyDbi = AssemblyTestData::getAssemblyDbi();
APITestData testData;
testData.addValue(MAX_PACKED_ROW_IN, U2Region(10, 6));
testData.addValue(MAX_PACKED_ROW_OUT, 3);
const U2DataId &id = AssemblyTestData::getAssemblyIds()->first();
U2OpStatusImpl os;
qint64 actual = assemblyDbi->getMaxPackedRow(id, testData.getValue<U2Region>(MAX_PACKED_ROW_IN), os);
CHECK_NO_ERROR(os);
CHECK_TRUE(actual == testData.getValue<qint64>(MAX_PACKED_ROW_OUT), "incorrect max packed row");
}
void AssemblyDbiUnitTests_getMaxPackedRowInvalid::Test() {
U2AssemblyDbi *assemblyDbi = AssemblyTestData::getAssemblyDbi();
APITestData testData;
testData.addValue(INVALID_ASSEMBLY_ID, QByteArray("zZÿÿ"));
const U2DataId &id = testData.getValue<U2DataId>(INVALID_ASSEMBLY_ID);
U2OpStatusImpl os;
qint64 val = assemblyDbi->getMaxPackedRow(id, U2_REGION_MAX, os);
CHECK_TRUE(val == -1, "max packed row should be -1");
}
void AssemblyDbiUnitTests_getMaxEndPos::Test() {
U2AssemblyDbi *assemblyDbi = AssemblyTestData::getAssemblyDbi();
APITestData testData;
testData.addValue(MAX_END_POS, qint64(146));
U2DataId id = AssemblyTestData::getAssemblyIds()->first();
U2OpStatusImpl os;
qint64 val = assemblyDbi->getMaxEndPos(id, os);
CHECK_NO_ERROR(os);
CHECK_TRUE(testData.getValue<qint64>(MAX_END_POS) == val, "incorrect max end position");
}
void AssemblyDbiUnitTests_getMaxEndPosInvalid::Test() {
U2AssemblyDbi *assemblyDbi = AssemblyTestData::getAssemblyDbi();
APITestData testData;
testData.addValue(INVALID_ASSEMBLY_ID, QByteArray("zZÿÿ"));
const U2DataId &id = testData.getValue<U2DataId>(INVALID_ASSEMBLY_ID);
U2OpStatusImpl os;
qint64 val = assemblyDbi->getMaxEndPos(id, os);
CHECK_TRUE(val == -1, "max end position should be -1");
}
void AssemblyDbiUnitTests_createAssemblyObject::Test() {
U2AssemblyDbi *assemblyDbi = AssemblyTestData::getAssemblyDbi();
U2Assembly assembly;
U2AssemblyReadsImportInfo importInfo;
U2OpStatusImpl os;
assemblyDbi->createAssemblyObject(assembly, "/", NULL, importInfo, os);
CHECK_NO_ERROR(os);
U2Assembly res = assemblyDbi->getAssemblyObject(assembly.id, os);
CHECK_NO_ERROR(os);
}
void AssemblyDbiUnitTests_removeReads::Test() {
U2AssemblyDbi *assemblyDbi = AssemblyTestData::getAssemblyDbi();
APITestData testData;
testData.addValue(REMOVE_READS_IN, U2Region(10, 10));
const U2DataId &id = AssemblyTestData::getAssemblyIds()->first();
const U2Region ®ion = testData.getValue<U2Region>(REMOVE_READS_IN);
U2OpStatusImpl os;
QList<U2DataId> readIds;
{
QScopedPointer<U2DbiIterator<U2AssemblyRead>> iter;
iter.reset(assemblyDbi->getReads(id, region, os));
CHECK_NO_ERROR(os);
while (iter->hasNext()) {
const U2AssemblyRead &read = iter->next();
readIds.append(read->id);
}
}
assemblyDbi->removeReads(id, readIds, os);
CHECK_NO_ERROR(os);
QScopedPointer<U2DbiIterator<U2AssemblyRead>> iter;
iter.reset(assemblyDbi->getReads(id, region, os));
CHECK_TRUE(!iter->hasNext(), "reads list should be empty");
}
void AssemblyDbiUnitTests_removeReadsInvalid::Test() {
U2AssemblyDbi *assemblyDbi = AssemblyTestData::getAssemblyDbi();
APITestData testData;
testData.addValue(INVALID_ASSEMBLY_ID, QByteArray("zZÿÿ"));
const U2DataId &id = testData.getValue<U2DataId>(INVALID_ASSEMBLY_ID);
U2OpStatusImpl os;
assemblyDbi->removeReads(id, QList<U2DataId>(), os);
CHECK_TRUE(os.hasError(), "error should be thrown");
}
void AssemblyDbiUnitTests_addReads::Test() {
U2AssemblyDbi *assemblyDbi = AssemblyTestData::getAssemblyDbi();
APITestData testData;
// addReads
{
U2AssemblyRead read2add(new U2AssemblyReadData());
read2add->name = "Test read";
read2add->leftmostPos = 90;
read2add->readSequence = "GTTATATCGGCAGTGGGTTGATC";
read2add->effectiveLen = read2add->readSequence.length();
read2add->flags = None;
QVariantList reads2add;
reads2add.append(qVariantFromValue(read2add));
testData.addValue(ADD_READ, reads2add);
}
QVariantList reads2add = testData.getValue<QVariantList>(ADD_READ);
QList<U2AssemblyRead> reads;
foreach (const QVariant &var, reads2add) {
const U2AssemblyRead read = var.value<U2AssemblyRead>();
reads.append(read);
}
const U2DataId &id = AssemblyTestData::getAssemblyIds()->first();
BufferedDbiIterator<U2AssemblyRead> it(reads);
U2OpStatusImpl os;
assemblyDbi->addReads(id, &it, os);
CHECK_NO_ERROR(os);
foreach (U2AssemblyRead read, reads) {
QScopedPointer<U2DbiIterator<U2AssemblyRead>> iter;
iter.reset(assemblyDbi->getReads(id, U2_REGION_MAX, os));
CHECK_NO_ERROR(os);
bool added = false;
while (iter->hasNext()) {
if (AssemblyDbiTestUtil::compareReads(read, iter->next())) {
added = true;
break;
}
}
CHECK_TRUE(added, "incorrect compared reads");
}
}
void AssemblyDbiUnitTests_addReadsInvalid::Test() {
U2AssemblyDbi *assemblyDbi = AssemblyTestData::getAssemblyDbi();
APITestData testData;
testData.addValue(INVALID_ASSEMBLY_ID, QByteArray("zZÿÿ"));
const U2DataId &id = testData.getValue<U2DataId>(INVALID_ASSEMBLY_ID);
QList<U2AssemblyRead> reads;
BufferedDbiIterator<U2AssemblyRead> it(reads);
U2OpStatusImpl os;
assemblyDbi->addReads(id, &it, os);
CHECK_TRUE(os.hasError(), "error should be thrown");
}
void AssemblyDbiUnitTests_pack::Test() {
U2AssemblyDbi *assemblyDbi = AssemblyTestData::getAssemblyDbi();
const U2DataId &id = AssemblyTestData::getAssemblyIds()->first();
U2AssemblyPackStat stats;
U2OpStatusImpl os;
assemblyDbi->pack(id, stats, os);
CHECK_NO_ERROR(os);
CHECK_TRUE(stats.maxProw == 29, "incorrect max prow");
CHECK_TRUE(stats.readsCount == 44, "incorrect count reads");
}
void AssemblyDbiUnitTests_packInvalid::Test() {
U2AssemblyDbi *assemblyDbi = AssemblyTestData::getAssemblyDbi();
APITestData testData;
testData.addValue(INVALID_ASSEMBLY_ID, QByteArray("zZÿÿ"));
const U2DataId &id = testData.getValue<U2DataId>(INVALID_ASSEMBLY_ID);
U2AssemblyPackStat stat;
U2OpStatusImpl os;
assemblyDbi->pack(id, stat, os);
CHECK_TRUE(os.hasError(), "error should be thrown");
}
void AssemblyDbiUnitTests_calculateCoverage::Test() {
U2AssemblyDbi *assemblyDbi = AssemblyTestData::getAssemblyDbi();
U2OpStatusImpl os;
const U2DataId &id = AssemblyTestData::getAssemblyIds()->first();
const U2Region ®ion = U2Region(20, 1);
U2AssemblyCoverageStat c;
c.resize(1);
assemblyDbi->calculateCoverage(id, region, c, os);
CHECK_NO_ERROR(os);
int res = c.first();
CHECK_TRUE(res == 1, "incorrect calculate Coverage");
}
void AssemblyDbiUnitTests_calculateCoverageInvalid::Test() {
U2AssemblyDbi *assemblyDbi = AssemblyTestData::getAssemblyDbi();
APITestData testData;
testData.addValue(INVALID_ASSEMBLY_ID, QByteArray("zZÿÿ"));
const U2DataId &id = testData.getValue<U2DataId>(INVALID_ASSEMBLY_ID);
const U2Region ®ion = U2Region(20, 1);
U2AssemblyCoverageStat c;
U2OpStatusImpl os;
assemblyDbi->calculateCoverage(id, region, c, os);
CHECK_TRUE(os.hasError(), "error should be thrown");
}
} // namespace U2
| 38.799666 | 122 | 0.735467 | r-barnes |
41d9c3662b13f387977b4b0dfa71f56f4526c0a0 | 14,646 | cc | C++ | utils/testing/compact_vector_test.cc | kstepanmpmg/mldb | f78791cd34d01796705c0f173a14359ec1b2e021 | [
"Apache-2.0"
] | 665 | 2015-12-09T17:00:14.000Z | 2022-03-25T07:46:46.000Z | utils/testing/compact_vector_test.cc | Davletvm/mldb | f78791cd34d01796705c0f173a14359ec1b2e021 | [
"Apache-2.0"
] | 797 | 2015-12-09T19:48:19.000Z | 2022-03-07T02:19:47.000Z | utils/testing/compact_vector_test.cc | matebestek/mldb | f78791cd34d01796705c0f173a14359ec1b2e021 | [
"Apache-2.0"
] | 103 | 2015-12-25T04:39:29.000Z | 2022-02-03T02:55:22.000Z | /* compact_vector_test.cc
Jeremy Barnes, 3 March 2009
Copyright (c) 2009 Jeremy Barnes. All rights reserved.
This file is part of MLDB. Copyright 2015 mldb.ai inc. All rights reserved.
Test for the compact_vector class.
*/
#define BOOST_TEST_MAIN
#define BOOST_TEST_DYN_LINK
#include "mldb/vfs/filter_streams.h"
#include "mldb/utils/compact_vector.h"
#include "mldb/arch/exception.h"
#include "mldb/arch/exception_handler.h"
#include "mldb/arch/arch.h"
#include <boost/test/unit_test.hpp>
#include "mldb/utils/vector_utils.h"
#include "mldb/utils/pair_utils.h"
#include "mldb/arch/file_functions.h"
#include "mldb/utils/string_functions.h"
#include <iostream>
#include <sstream>
using namespace std;
using namespace MLDB;
using boost::unit_test_framework::test_suite;
size_t constructed = 0, copied = 0, moved = 0, destroyed = 0;
int GOOD = 0xfeedbac4;
int BAD = 0xdeadbeef;
struct Obj {
Obj()
: val(0)
{
//cerr << "default construct at " << this << endl;
++constructed;
magic = GOOD;
}
Obj(int val)
: val(val)
{
//cerr << "value construct at " << this << endl;
++constructed;
magic = GOOD;
}
~Obj() noexcept(false)
{
//cerr << "destroying at " << this << endl;
++destroyed;
if (magic == BAD)
throw Exception("object destroyed twice");
if (magic != GOOD)
throw Exception("object never initialized in destructor");
magic = BAD;
}
Obj(const Obj & other)
: val(other.val)
{
//cerr << "copy construct at " << this << endl;
++constructed;
++copied;
magic = GOOD;
}
Obj & operator = (Obj & other)
{
// cerr << "copy assign at " << this << endl;
if (magic == BAD)
throw Exception("assigned to destroyed object");
if (magic != GOOD)
throw Exception("assigned to object never initialized in assign");
val = other.val;
++copied;
return *this;
}
Obj(Obj && other) :
val(std::move(other.val))
{
// cerr << "move construct at " << this << endl;
++constructed;
++moved;
magic = GOOD;
}
Obj & operator=(Obj && other)
{
// cerr << "move assign at " << this << endl;
if (magic == BAD)
throw Exception("assigned to destroyed object");
if (magic != GOOD)
throw Exception("assigned to object never initialized in assign");
val = std::move(other.val);
++moved;
return *this;
}
int val;
int magic;
operator int () const
{
if (magic == BAD)
throw Exception("read destroyed object");
if (magic != GOOD)
throw Exception("read from uninitialized object");
return val;
}
};
BOOST_AUTO_TEST_CASE( check_sizes )
{
compact_vector<int, 1, uint16_t> vec1;
#if (MLDB_BITS == 32)
BOOST_CHECK_EQUAL(sizeof(vec1), 8);
#else
BOOST_CHECK_EQUAL(sizeof(vec1), 12);
#endif
compact_vector<uint16_t, 3, uint16_t> vec2;
#if (MLDB_BITS == 32)
BOOST_CHECK_EQUAL(sizeof(vec2), 8);
#else
BOOST_CHECK_EQUAL(sizeof(vec2), 12);
#endif
compact_vector<uint16_t, 5, uint16_t> vec3;
BOOST_CHECK_EQUAL(sizeof(vec3), 12);
}
template<class Vector>
void check_basic_ops_type(Vector & vec)
{
vec.clear();
BOOST_CHECK_EQUAL(vec.size(), 0);
vec.push_back(1);
BOOST_CHECK_EQUAL(vec.size(), 1);
BOOST_CHECK_EQUAL(vec.front(), 1);
BOOST_CHECK_EQUAL(vec.back(), 1);
Vector copy = vec;
BOOST_CHECK_EQUAL(copy, vec);
copy.reserve(2);
BOOST_CHECK_EQUAL(copy, vec);
vec.push_back(2);
BOOST_CHECK_EQUAL(vec.size(), 2);
BOOST_CHECK_EQUAL(vec.front(), 1);
BOOST_CHECK_EQUAL(vec.back(), 2);
vec.push_back(3);
BOOST_CHECK_EQUAL(vec.size(), 3);
BOOST_CHECK_EQUAL(vec.front(), 1);
BOOST_CHECK_EQUAL(vec.back(), 3);
vec.push_back(4);
BOOST_CHECK_EQUAL(vec.size(), 4);
BOOST_CHECK_EQUAL(vec[0], 1);
BOOST_CHECK_EQUAL(vec[1], 2);
BOOST_CHECK_EQUAL(vec[2], 3);
BOOST_CHECK_EQUAL(vec[3], 4);
BOOST_CHECK_EQUAL(vec.front(), 1);
BOOST_CHECK_EQUAL(vec.back(), 4);
{
Set_Trace_Exceptions guard(false);
BOOST_CHECK_THROW(vec.at(4), std::exception);
}
vec.pop_back();
BOOST_CHECK_EQUAL(vec.size(), 3);
BOOST_CHECK_EQUAL(vec.front(), 1);
BOOST_CHECK_EQUAL(vec.back(), 3);
vec.pop_back();
BOOST_CHECK_EQUAL(vec.size(), 2);
BOOST_CHECK_EQUAL(vec.front(), 1);
BOOST_CHECK_EQUAL(vec.back(), 2);
vec.pop_back();
BOOST_CHECK_EQUAL(vec.size(), 1);
BOOST_CHECK_EQUAL(vec.front(), 1);
BOOST_CHECK_EQUAL(vec.back(), 1);
vec.pop_back();
BOOST_CHECK_EQUAL(vec.size(), 0);
}
BOOST_AUTO_TEST_CASE( check_basic_ops )
{
constructed = destroyed = 0;
compact_vector<int> v1;
check_basic_ops_type(v1);
compact_vector<int, 1, uint16_t> v2;
check_basic_ops_type(v2);
compact_vector<uint16_t, 2, uint16_t> v3;
check_basic_ops_type(v3);
compact_vector<uint16_t, 3, uint16_t> v4;
check_basic_ops_type(v4);
compact_vector<uint64_t, 4, uint16_t> v5;
check_basic_ops_type(v5);
BOOST_CHECK_EQUAL(constructed, destroyed);
compact_vector<Obj, 4, uint16_t> v6;
check_basic_ops_type(v6);
v6.clear();
BOOST_CHECK_EQUAL(constructed, destroyed);
}
template<class Vector>
void check_insert_erase_type(Vector & vec)
{
vec.clear();
BOOST_CHECK_EQUAL(vec.size(), 0);
vector<int> v1;
v1.push_back(1);
v1.push_back(2);
v1.push_back(3);
v1.push_back(4);
v1.push_back(5);
vector<int> v2;
v2.push_back(6);
v2.push_back(7);
v2.push_back(8);
v2.push_back(9);
v2.push_back(10);
auto it1 = vec.insert(vec.begin(), v1.begin(), v1.end());
BOOST_CHECK(it1 == vec.begin());
BOOST_CHECK_EQUAL_COLLECTIONS(vec.begin(), vec.end(), v1.begin(), v1.end());
vec.erase(vec.begin(), vec.end());
BOOST_CHECK_EQUAL(vec.size(), 0);
BOOST_CHECK(vec.begin() == vec.end());
auto it2 = vec.insert(vec.begin(), v1.begin(), v1.end());
BOOST_CHECK(it2 == vec.begin());
auto it3 = vec.insert(vec.end(), v2.begin(), v2.end());
BOOST_CHECK(it3 == vec.begin() + v1.size());
BOOST_CHECK_EQUAL_COLLECTIONS(vec.begin(), vec.begin() + 5,
v1.begin(), v1.end());
BOOST_CHECK_EQUAL_COLLECTIONS(vec.begin() + 5, vec.end(),
v2.begin(), v2.end());
vec.clear();
//cerr << "vec 1 = " << vec << endl;
vec.insert(vec.begin(), v1.begin(), v1.end());
//cerr << "vec 2 = " << vec << endl;
auto it4 = vec.insert(vec.begin() + 2, v2.begin(), v2.end());
BOOST_CHECK(it4 == vec.begin() + 2);
//cerr << "vec 3 = " << vec << endl;
BOOST_CHECK_EQUAL(*vec.erase(vec.begin() + 7), 4);
BOOST_CHECK_EQUAL(vec[0], 1);
BOOST_CHECK_EQUAL(vec[1], 2);
BOOST_CHECK_EQUAL(vec[2], 6);
BOOST_CHECK_EQUAL(vec[3], 7);
BOOST_CHECK_EQUAL(vec[4], 8);
BOOST_CHECK_EQUAL(vec[5], 9);
BOOST_CHECK_EQUAL(vec[6], 10);
BOOST_CHECK_EQUAL(vec[7], 4);
BOOST_CHECK_EQUAL(vec[8], 5);
}
BOOST_AUTO_TEST_CASE( check_insert_erase )
{
constructed = destroyed = 0;
compact_vector<int> v1;
check_insert_erase_type(v1);
compact_vector<int, 1, uint16_t> v2;
check_insert_erase_type(v2);
compact_vector<uint16_t, 2, uint16_t> v3;
check_insert_erase_type(v3);
compact_vector<uint16_t, 3, uint16_t> v4;
check_insert_erase_type(v4);
compact_vector<uint64_t, 4, uint16_t> v5;
check_insert_erase_type(v5);
BOOST_CHECK_EQUAL(constructed, destroyed);
compact_vector<Obj, 4, uint16_t> v6;
check_insert_erase_type(v6);
v6.clear();
BOOST_CHECK_EQUAL(constructed, destroyed);
}
BOOST_AUTO_TEST_CASE( check_swap_finishes )
{
constructed = destroyed = 0;
compact_vector<Obj, 1, uint16_t> v1, v2;
v1.push_back(1);
v2.push_back(2);
v1.swap(v2);
BOOST_CHECK(v1.size() == 1);
BOOST_CHECK(v2.size() == 1);
BOOST_CHECK(v1[0] == 2);
BOOST_CHECK(v2[0] == 1);
v1.clear(); v2.clear();
BOOST_CHECK_EQUAL(constructed, destroyed);
}
BOOST_AUTO_TEST_CASE( check_swap_bounds )
{
constructed = destroyed = 0;
compact_vector<Obj, 2, uint16_t> v1, v2;
v1.push_back(1);
v1.push_back(2);
v2.push_back(3);
BOOST_CHECK_EQUAL(v1.size(), 2);
BOOST_CHECK_EQUAL(v2.size(), 1);
BOOST_CHECK_EQUAL(v1[0], 1);
BOOST_CHECK_EQUAL(v1[1], 2);
BOOST_CHECK_EQUAL(v2[0], 3);
v1.swap(v2);
BOOST_CHECK_EQUAL(v1.size(), 1);
BOOST_CHECK_EQUAL(v2.size(), 2);
BOOST_CHECK_EQUAL(v1[0], 3);
BOOST_CHECK_EQUAL(v2[0], 1);
BOOST_CHECK_EQUAL(v2[1], 2);
v2.swap(v1);
BOOST_CHECK_EQUAL(v1.size(), 2);
BOOST_CHECK_EQUAL(v2.size(), 1);
BOOST_CHECK_EQUAL(v1[0], 1);
BOOST_CHECK_EQUAL(v1[1], 2);
BOOST_CHECK_EQUAL(v2[0], 3);
v1.clear(); v2.clear();
BOOST_CHECK_EQUAL(constructed, destroyed);
}
BOOST_AUTO_TEST_CASE( check_reserve )
{
constructed = destroyed = 0;
compact_vector<Obj, 3, unsigned> v;
v.resize(3);
v.reserve(4);
v.clear();
BOOST_CHECK_EQUAL(constructed, destroyed);
}
BOOST_AUTO_TEST_CASE( check_resize )
{
constructed = destroyed = 0;
compact_vector<Obj, 3, unsigned> v;
v.resize(0);
BOOST_CHECK_EQUAL(v.size(), 0);
v.resize(1);
v[0] = 10;
BOOST_CHECK_EQUAL(v.size(), 1);
BOOST_CHECK_EQUAL(v[0], 10);
v.resize(2);
v[1] = 20;
BOOST_CHECK_EQUAL(v.size(), 2);
BOOST_CHECK_EQUAL(v[0], 10);
BOOST_CHECK_EQUAL(v[1], 20);
v.resize(3);
v[2] = 30;
BOOST_CHECK_EQUAL(v.size(), 3);
BOOST_CHECK_EQUAL(v[0], 10);
BOOST_CHECK_EQUAL(v[1], 20);
BOOST_CHECK_EQUAL(v[2], 30);
v.resize(4);
v[3] = 40;
BOOST_CHECK_EQUAL(v.size(), 4);
BOOST_CHECK_EQUAL(v[0], 10);
BOOST_CHECK_EQUAL(v[1], 20);
BOOST_CHECK_EQUAL(v[2], 30);
BOOST_CHECK_EQUAL(v[3], 40);
v.resize(3);
BOOST_CHECK_EQUAL(v.size(), 3);
BOOST_CHECK_EQUAL(v[0], 10);
BOOST_CHECK_EQUAL(v[1], 20);
BOOST_CHECK_EQUAL(v[2], 30);
v.resize(2);
BOOST_CHECK_EQUAL(v.size(), 2);
BOOST_CHECK_EQUAL(v[0], 10);
BOOST_CHECK_EQUAL(v[1], 20);
v.resize(1);
BOOST_CHECK_EQUAL(v.size(), 1);
BOOST_CHECK_EQUAL(v[0], 10);
v.resize(0);
BOOST_CHECK_EQUAL(v.size(), 0);
BOOST_CHECK_EQUAL(constructed, destroyed);
}
BOOST_AUTO_TEST_CASE( check_c11_ops )
{
auto reset = [] { moved = copied = 0; };
{
compact_vector<Obj, 6, unsigned> v;
reset();
v.emplace_back(10);
BOOST_CHECK_EQUAL(moved, 0);
BOOST_CHECK_EQUAL(copied, 0);
BOOST_CHECK_EQUAL(v.size(), 1);
BOOST_CHECK_EQUAL(v[0], 10);
reset();
v.emplace_back(Obj(20));
BOOST_CHECK_EQUAL(moved, 1);
BOOST_CHECK_EQUAL(copied, 0);
BOOST_CHECK_EQUAL(v.size(), 2);
BOOST_CHECK_EQUAL(v[0], 10);
BOOST_CHECK_EQUAL(v[1], 20);
reset();
Obj o1(30);
v.emplace_back(o1);
BOOST_CHECK_EQUAL(moved, 0);
BOOST_CHECK_EQUAL(copied, 1);
BOOST_CHECK_EQUAL(v.size(), 3);
BOOST_CHECK_EQUAL(v[0], 10);
BOOST_CHECK_EQUAL(v[1], 20);
BOOST_CHECK_EQUAL(v[2], 30);
reset();
v.emplace(v.begin() + 1, 40);
BOOST_CHECK_GT(moved, 0);
BOOST_CHECK_EQUAL(copied, 0);
BOOST_CHECK_EQUAL(v.size(), 4);
BOOST_CHECK_EQUAL(v[0], 10);
BOOST_CHECK_EQUAL(v[1], 40);
BOOST_CHECK_EQUAL(v[2], 20);
BOOST_CHECK_EQUAL(v[3], 30);
reset();
v.push_back(Obj(50));
BOOST_CHECK_EQUAL(moved, 1);
BOOST_CHECK_EQUAL(copied, 0);
BOOST_CHECK_EQUAL(v.size(), 5);
BOOST_CHECK_EQUAL(v[0], 10);
BOOST_CHECK_EQUAL(v[1], 40);
BOOST_CHECK_EQUAL(v[2], 20);
BOOST_CHECK_EQUAL(v[3], 30);
BOOST_CHECK_EQUAL(v[4], 50);
reset();
Obj obj(60);
v.push_back(obj);
BOOST_CHECK_EQUAL(moved, 0);
BOOST_CHECK_EQUAL(copied, 1);
BOOST_CHECK_EQUAL(v.size(), 6);
BOOST_CHECK_EQUAL(v[0], 10);
BOOST_CHECK_EQUAL(v[1], 40);
BOOST_CHECK_EQUAL(v[2], 20);
BOOST_CHECK_EQUAL(v[3], 30);
BOOST_CHECK_EQUAL(v[4], 50);
BOOST_CHECK_EQUAL(v[5], 60);
}
BOOST_CHECK_EQUAL(constructed, destroyed);
{
// Check that on move assignment that the moved-from version
// is correctly resized
compact_vector<Obj, 3, unsigned> v;
v.push_back(1);
v.push_back(2);
compact_vector<Obj, 3, unsigned> u(std::move(v));
BOOST_CHECK_EQUAL(v.size(), 0);
BOOST_CHECK_EQUAL(u.size(), 2);
}
BOOST_CHECK_EQUAL(constructed, destroyed);
}
BOOST_AUTO_TEST_CASE( check_zero_internal )
{
compact_vector<std::string, 0, uint32_t> vec;
BOOST_CHECK_EQUAL(vec.size(), 0);
BOOST_CHECK_EQUAL(vec.capacity(), 0);
vec.push_back("hello");
BOOST_CHECK_EQUAL(vec.size(), 1);
BOOST_CHECK_EQUAL(vec.capacity(), 1);
vec.clear();
BOOST_CHECK_EQUAL(vec.size(), 0);
BOOST_CHECK_EQUAL(vec.capacity(), 0);
}
void test_erase(std::vector<int> init,
int first,
int last)
{
BOOST_REQUIRE_EQUAL(constructed, destroyed);
{
compact_vector<Obj, 4> v(init.begin(), init.end());
BOOST_CHECK_EQUAL(v.size(), init.size());
v.erase(v.begin() + first, v.begin() + last);
init.erase(init.begin() + first, init.begin() + last);
BOOST_CHECK_EQUAL(v.size(), init.size());
BOOST_CHECK_EQUAL_COLLECTIONS(v.begin(), v.end(), init.begin(), init.end());
}
BOOST_CHECK_EQUAL(constructed, destroyed);
}
BOOST_AUTO_TEST_CASE(check_erase_external_to_internal)
{
test_erase({1,2,3,4,5,6,7,8}, 2, 6);
test_erase({1,2,3,4,5,6,7,8}, 0, 6);
test_erase({1,2,3,4,5,6,7,8}, 0, 3);
test_erase({1,2,3,4,5,6,7,8}, 4, 7);
test_erase({1,2,3,4,5,6,7,8}, 0, 7);
test_erase({1,2,3,4,5,6,7,8}, 3, 7);
test_erase({1,2,3,4,5,6,7,8}, 3, 4);
test_erase({1,2,3,4,5,6,7,8}, 3, 6);
test_erase({1,2,3,4,5,6,7,8}, 0, 0);
test_erase({1,2,3,4,5,6,7,8}, 1, 1);
test_erase({1,2,3,4,5,6,7,8}, 3, 3);
test_erase({1,2,3,4,5,6,7,8}, 4, 4);
test_erase({1,2,3,4,5,6,7,8}, 7, 7);
test_erase({1,2,3,4,5,6,7,8}, 8, 8);
}
| 23.699029 | 84 | 0.599549 | kstepanmpmg |
41e1ae28a545f19e0ba1b5f020f609cbac5e3ef1 | 1,850 | cpp | C++ | Basic Calculator.cpp | Faiquekhan15/C-C-conceptual-Questions | a75141bd5a58c32e2446f695e66ffbf979b8c8af | [
"MIT"
] | null | null | null | Basic Calculator.cpp | Faiquekhan15/C-C-conceptual-Questions | a75141bd5a58c32e2446f695e66ffbf979b8c8af | [
"MIT"
] | null | null | null | Basic Calculator.cpp | Faiquekhan15/C-C-conceptual-Questions | a75141bd5a58c32e2446f695e66ffbf979b8c8af | [
"MIT"
] | null | null | null | #include<iostream>
#include<cmath>
using namespace std;
int input(int &a,int &b)
{
a=0;
b=0;
cout<<"Enter Value Of First Number"<<endl;
cin>>a;
cout<<"Enter Value Of Second Number"<<endl;
cin>>b;
return a;
return b;
}
int add(int a,int b)
{
int c=a+b;
return c;
}
int subs(int a,int b)
{
int c=a-b;
return c;
}
int mul(int a,int b)
{
int c=a*b;
return c;
}
float divn(float a,float b)
{
if(a<0&&b<0)
{
float c=a/b;
return c;
}
else if(a>0&&b!=0)
{
float c=a/b;
return c;
}
else if(a<0&&b!=0)
{
float c=a/b;
return c;
}
if(a>0&&b==0)
{
cout<<"denominator should be greater then zero"<<endl;
}
}
float Power(float a, int b)
{
float c = 1;
if ( Power > 0)
{
for (int n = 0; n < b; n++)
{
c *= a;
}
}
else
{
for (int n = 0; n > b; n--)
{
c /= a;
}
}
return c;
}
void main()
{
int a=0;
int b=0;
int c=0,d=0,e=0;
float f=0;
float g=0;
char m;
cout<<"#################CALCULATOR##########"<<endl;
cout<<"ENTER WHICH OPERATION YOU WANT TO PERFORM"<<endl;
cout<<"Press 1 for addition "<<endl;
cout<<"Press 2 for substraction "<<endl;
cout<<"Press 3 for multiplication "<<endl;
cout<<"Press 4 for division "<<endl;
cout<<"Press 5 for power "<<endl;
cout<<"press only small alphabet t ########for termination of calculator "<<endl;
cout<<endl;
m='\0';
input(a,b);
while(m!='t')
{
cout<<"Enter operation"<<endl;
cin>>m;
if(m=='1')
{
c=add(a,b);
cout<<"addition="<<c<<endl;
}
if(m=='2')
{
d=subs(a,b);
cout<<"substraction="<<d<<endl;
}
if(m=='3')
{
e=mul(a,b);
cout<<"multiplication="<<e<<endl;
}
if(m=='4')
{
f=divn(a,b);
cout<<"division="<<f<<endl;
}
if(m=='5')
{
g=Power(a,b);
cout<<"power="<<g<<endl;
}
}
system("pause");
} | 15.04065 | 84 | 0.511351 | Faiquekhan15 |
41e75173008d39d67c39e3840c8c3da72372e865 | 3,901 | cpp | C++ | Source/Messages/Message.cpp | CG-SS/Urho3D-Empty-Project | e8991c5ac57d2f3636169f37168c1f0606e8d58e | [
"MIT"
] | null | null | null | Source/Messages/Message.cpp | CG-SS/Urho3D-Empty-Project | e8991c5ac57d2f3636169f37168c1f0606e8d58e | [
"MIT"
] | null | null | null | Source/Messages/Message.cpp | CG-SS/Urho3D-Empty-Project | e8991c5ac57d2f3636169f37168c1f0606e8d58e | [
"MIT"
] | null | null | null | #include <Urho3D/Urho3DAll.h>
#include "Message.h"
#include "../Audio/AudioManagerDefs.h"
#include "../MyEvents.h"
#include "../UI/NuklearUI.h"
static struct nk_rect _outerRect;
static struct nk_rect _innerRect;
/// Construct.
Message::Message(Context* context) :
Object(context),
_messageTime(0)
{
Init();
int width = 300;
int height = 160;
auto graphics = GetSubsystem<Graphics>();
_innerRect.x = graphics->GetWidth() / 2 - width / 2;
_innerRect.w = width;
_innerRect.y = graphics->GetHeight() / 2 - height / 2;
_innerRect.h = height;
_outerRect.x = 0;
_outerRect.w = graphics->GetWidth();
_outerRect.y = 0;
_outerRect.h = graphics->GetHeight();
}
Message::~Message()
{
}
void Message::Init()
{
SubscribeToEvents();
}
bool Message::Create()
{
SubscribeToEvents();
return true;
}
void Message::SubscribeToEvents()
{
SubscribeToEvent("ShowAlertMessage", URHO3D_HANDLER(Message, HandleShowMessage));
}
void Message::HandleShowMessage(StringHash eventType, VariantMap& eventData)
{
_title = eventData["Title"].GetString();
_message = eventData["Message"].GetString();
SubscribeToEvent(E_UPDATE, URHO3D_HANDLER(Message, HandleUpdate));
_messageTime = 0.0f;
}
void Message::HandleUpdate(StringHash eventType, VariantMap& eventData)
{
using namespace Update;
float timeStep = eventData[P_TIMESTEP].GetFloat();
_messageTime += timeStep * 200;
auto nuklear = GetSubsystem<NuklearUI>();
auto ctx = nuklear->GetNkContext();
if (nuklear && ctx) {
nk_style_default(ctx);
int alpha = Sin(_messageTime) * 50 + 150;
ctx->style.window.background = nk_rgba(100, 50, 50, alpha);
ctx->style.window.fixed_background = nk_style_item_color(nk_rgba(100, 50, 50, alpha));
ctx->style.window.border_color = nk_rgb(255, 165, 0);
ctx->style.window.combo_border_color = nk_rgb(255, 165, 0);
ctx->style.window.contextual_border_color = nk_rgb(255, 165, 0);
ctx->style.window.menu_border_color = nk_rgb(255, 165, 0);
ctx->style.window.group_border_color = nk_rgb(255, 165, 0);
ctx->style.window.tooltip_border_color = nk_rgb(255, 165, 0);
ctx->style.window.scrollbar_size = nk_vec2(16, 16);
ctx->style.window.border_color = nk_rgba(0, 0, 0, 0);
ctx->style.window.border = 1;
if (nk_begin(nuklear->GetNkContext(), "PopUpMessageOuter", _outerRect, NK_WINDOW_NO_SCROLLBAR)) {
nk_style_default(ctx);
//if (nk_begin(nuklear->GetNkContext(), "PopUpMessageInner", _innerRect, NK_WINDOW_NO_SCROLLBAR)) {
if (nk_popup_begin(ctx, NK_POPUP_STATIC, "piemenu", NK_WINDOW_NO_SCROLLBAR, _innerRect))
{
nk_layout_row_dynamic(ctx, 1, 1);
nk_spacing(nuklear->GetNkContext(), 1);
nk_layout_row_dynamic(ctx, 20, 1);
nk_label(nuklear->GetNkContext(), _title.CString(), NK_TEXT_CENTERED);
nk_layout_row_dynamic(ctx, 2, 1);
nk_spacing(nuklear->GetNkContext(), 1);
nk_layout_row_dynamic(ctx, 60, 1);
nk_label_wrap(nuklear->GetNkContext(), "Lorem Ipsum is simply dummy text of the printing and typesetting industry. Lorem Ipsum has been the industry's standard dummy text ever since the 1500s, when an unknown printer took a galley of type and scrambled it to make a type specimen book. It has survived not only five centuries, but also the leap into electronic typesetting, remaining essentially unchanged.");
nk_layout_row_dynamic(ctx, 30, 3);
nk_spacing(nuklear->GetNkContext(), 1);
if (nk_button_label(nuklear->GetNkContext(), "Ok")) {
UnsubscribeFromEvent(E_UPDATE);
}
}
nk_popup_end(ctx);
}
nk_end(ctx);
}
} | 36.12037 | 425 | 0.651115 | CG-SS |
41e9741be8f41f7fa5089578de004098bd1ab28d | 4,472 | hpp | C++ | glfw3_app/common/utils/handle_set.hpp | hirakuni45/glfw3_app | d9ceeef6d398229fda4849afe27f8b48d1597fcf | [
"BSD-3-Clause"
] | 9 | 2015-09-22T21:36:57.000Z | 2021-04-01T09:16:53.000Z | glfw3_app/common/utils/handle_set.hpp | hirakuni45/glfw3_app | d9ceeef6d398229fda4849afe27f8b48d1597fcf | [
"BSD-3-Clause"
] | null | null | null | glfw3_app/common/utils/handle_set.hpp | hirakuni45/glfw3_app | d9ceeef6d398229fda4849afe27f8b48d1597fcf | [
"BSD-3-Clause"
] | 2 | 2019-02-21T04:22:13.000Z | 2021-03-02T17:24:32.000Z | #pragma once
//=====================================================================//
/*! @file
@brief ハンドルによるリソース管理
@author 平松邦仁 (hira@rvf-rc45.net)
*/
//=====================================================================//
#include <set>
#include <vector>
#include <boost/optional.hpp>
namespace utils {
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++//
/*!
@brief ハンドル管理テンプレート・クラス
@param[in] HANDLE ハンドルの型
@param[in] SET 管理用 set コンテナ
@param[in] ARRAY アレイコンテナ
*/
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++//
template <class T,
class HANDLE = uint32_t,
class SET = std::set<HANDLE>,
class ARRAY = std::vector<T> >
struct handle_set {
typedef T value_type;
typedef HANDLE handle_type;
typedef ARRAY array_type;
typedef boost::optional<T&> optional_value_type;
typedef boost::optional<const T&> optional_const_value_type;
private:
array_type array_;
typedef SET set_type;
set_type erase_set_;
typedef typename set_type::iterator set_it;
bool zero_handle_enable_;
public:
//-----------------------------------------------------------------//
/*!
@brief コンストラクター
@param[in] zhe ０番ハンドルを無効にする場合「false」
@param[in] fas 初期アレイサイズ
*/
//-----------------------------------------------------------------//
handle_set(bool zhe = true, uint32_t fas = 0) : array_(), erase_set_(),
zero_handle_enable_(zhe) {
if(fas) {
array_.reserve(fas);
array_.clear();
}
if(zero_handle_enable_) array_.push_back(T());
}
//-----------------------------------------------------------------//
/*!
@brief デストラクター
*/
//-----------------------------------------------------------------//
~handle_set() { }
//-----------------------------------------------------------------//
/*!
@brief 使用サイズを返す
@return 使用サイズ
*/
//-----------------------------------------------------------------//
handle_type size() const { return static_cast<handle_type>(array_.size()); }
//-----------------------------------------------------------------//
/*!
@brief ハンドルを消去
*/
//-----------------------------------------------------------------//
void clear() {
erase_set_.clear();
array_.clear();
if(zero_handle_enable_) array_.push_back(T());
}
//-----------------------------------------------------------------//
/*!
@brief ハンドルが有効か調べる
@param[in] h ハンドル
@return 有効なら「true」が返る
*/
//-----------------------------------------------------------------//
inline bool probe(handle_type h) const {
if(static_cast<size_t>(h) < size()) {
return erase_set_.find(h) == erase_set_.end();
} else {
return false;
}
}
//-----------------------------------------------------------------//
/*!
@brief ハンドルを消去
@param[in] h ハンドル
@return 消去できたら「true」を返す
*/
//-----------------------------------------------------------------//
bool erase(handle_type h) {
if(static_cast<size_t>(h) < size()) {
set_it it = erase_set_.find(h);
if(it == erase_set_.end()) {
erase_set_.insert(h);
return true;
}
}
return false;
}
//-----------------------------------------------------------------//
/*!
@brief インスタンスを挿入してハンドルを返す
@param[in] st インスタンス
@return ハンドルを返す
*/
//-----------------------------------------------------------------//
handle_type insert(const T& st) {
handle_type h;
if(erase_set_.empty()) {
h = static_cast<handle_type>(array_.size());
array_.push_back(st);
} else {
set_it it = erase_set_.begin();
h = *it;
array_[h] = st;
erase_set_.erase(it);
}
return h;
}
//-----------------------------------------------------------------//
/*!
@brief 値の参照（RW）
@param[in] h ハンドル
@return 有効なら「true」を返す。
*/
//-----------------------------------------------------------------//
optional_value_type at(handle_type h) {
if(probe(h)) {
return optional_value_type(array_[h]);
} else {
return optional_value_type();
}
}
//-----------------------------------------------------------------//
/*!
@brief 値の参照（RO）
@param[in] h ハンドル
@return 有効なら「true」を返す。
*/
//-----------------------------------------------------------------//
optional_const_value_type get(handle_type h) const {
if(probe(h)) {
return optional_const_value_type(array_[h]);
} else {
return optional_const_value_type();
}
}
};
}
| 24.98324 | 78 | 0.400939 | hirakuni45 |
41eeb5acce45e72baaa3fa58bb876f381ce364ad | 15,960 | hpp | C++ | framework/api/sys/common/ByteBuffer.hpp | dterletskiy/carpc | c98d84e5bce69fb30a0f34e7b6cd82b4c98ba9b5 | [
"MIT"
] | 6 | 2022-03-24T15:40:03.000Z | 2022-03-30T09:40:20.000Z | framework/api/sys/common/ByteBuffer.hpp | dterletskiy/carpc | c98d84e5bce69fb30a0f34e7b6cd82b4c98ba9b5 | [
"MIT"
] | 7 | 2022-03-24T18:53:52.000Z | 2022-03-30T10:15:50.000Z | framework/api/sys/common/ByteBuffer.hpp | dterletskiy/carpc | c98d84e5bce69fb30a0f34e7b6cd82b4c98ba9b5 | [
"MIT"
] | 1 | 2022-03-20T21:22:09.000Z | 2022-03-20T21:22:09.000Z | #pragma once
#include <string>
#include <vector>
#include <queue>
#include <deque>
#include <list>
#include <set>
#include <map>
#include <optional>
#include <type_traits>
namespace carpc {
#define __INTEGRAL_TYPE__( TYPE ) std::is_integral_v< TYPE >
#define __FLOATING_POINT_TYPE__( TYPE ) std::is_floating_point_v< TYPE >
#define __ENUM_TYPE__( TYPE ) std::is_enum_v< TYPE >
#define __REST_TYPES__( TYPE ) !std::is_integral_v< TYPE > && !std::is_floating_point_v< TYPE > && !std::is_enum_v< TYPE >
class ByteBuffer
{
public:
template< typename TYPE >
ByteBuffer& operator << ( const TYPE& );
template< typename TYPE >
ByteBuffer& operator >> ( TYPE& );
public:
ByteBuffer( const size_t capacity = 1024 );
ByteBuffer( const void*, const size_t );
template< typename TYPE >
ByteBuffer( const TYPE& );
ByteBuffer( const ByteBuffer& );
~ByteBuffer( );
/*****************************************
*
* Push buffer methods
*
****************************************/
public:
bool push( void*, const size_t, const bool is_reallocate = true );
bool push( const void*, const size_t, const bool is_reallocate = true );
bool push( const void* const, const bool is_reallocate = true );
bool push( const std::string&, const bool is_reallocate = true );
bool push( const ByteBuffer&, const bool is_reallocate = true );
template< typename TYPE >
bool push( const std::optional< TYPE >&, const bool is_reallocate = true );
template< typename TYPE >
bool push( const std::vector< TYPE >&, const bool is_reallocate = true );
template< typename TYPE >
bool push( const std::list< TYPE >&, const bool is_reallocate = true );
template< typename TYPE_FIRST, typename TYPE_SECOND >
bool push( const std::pair< TYPE_FIRST, TYPE_SECOND >&, const bool is_reallocate = true );
template< typename TYPE >
bool push( const std::set< TYPE >&, const bool is_reallocate = true );
template< typename TYPE_KEY, typename TYPE_VALUE >
bool push( const std::map< TYPE_KEY, TYPE_VALUE >&, const bool is_reallocate = true );
// This method is for integral types and types with floating point
template< typename TYPE >
typename std::enable_if_t< __INTEGRAL_TYPE__( TYPE ) || __FLOATING_POINT_TYPE__( TYPE ), bool >
push( const TYPE&, const bool is_reallocate = true );
// This method is for enumerations.
template< typename TYPE >
typename std::enable_if_t< __ENUM_TYPE__( TYPE ), bool >
push( const TYPE&, const bool is_reallocate = true );
// This method is for user defined types. It calles "to_buffer" method of this type, so it should be implemented in it.
template< typename TYPE >
typename std::enable_if_t< __REST_TYPES__( TYPE ), bool >
push( const TYPE&, const bool is_reallocate = true );
// This method for multipl push
template< typename ... TYPES >
bool push( const TYPES& ... values, const bool is_reallocate = true );
private:
bool push_buffer_with_size( const void*, const size_t, const bool is_reallocate );
template< typename TYPE_CONTAINER >
bool push_stl_container( const TYPE_CONTAINER&, const bool is_reallocate );
template< typename TYPE_CONTAINER >
bool push_stl_associative_container( const TYPE_CONTAINER&, const bool is_reallocate );
/*****************************************
*
* Pop buffer methods
*
****************************************/
public:
bool pop( void*, const size_t );
bool pop( const void*, const size_t );
bool pop( const void*& );
bool pop( std::string& );
bool pop( ByteBuffer& );
template< typename TYPE >
bool pop( std::optional< TYPE >& );
template< typename TYPE >
bool pop( std::vector< TYPE >& );
template< typename TYPE >
bool pop( std::list< TYPE >& );
template< typename TYPE_FIRST, typename TYPE_SECOND >
bool pop( std::pair< TYPE_FIRST, TYPE_SECOND >& );
template< typename TYPE >
bool pop( std::set< TYPE >& );
template< typename TYPE_KEY, typename TYPE_VALUE >
bool pop( std::map< TYPE_KEY, TYPE_VALUE >& );
// This method is for integral types and types with floating poing
template< typename TYPE >
typename std::enable_if_t< __INTEGRAL_TYPE__( TYPE ) || __FLOATING_POINT_TYPE__( TYPE ), bool >
pop( TYPE& );
// This method is for enumerations.
template< typename TYPE >
typename std::enable_if_t< __ENUM_TYPE__( TYPE ), bool >
pop( TYPE& );
// This method is for user defined types. It calles "from_buffer" method of this type, so it should be implemented in it.
template< typename TYPE >
typename std::enable_if_t< __REST_TYPES__( TYPE ), bool >
pop( TYPE& );
// This method for multipl push
template< typename ... TYPES >
bool pop( TYPES& ... values );
private:
template< typename TYPE_CONTAINER >
bool pop_stl_container( TYPE_CONTAINER& );
template< typename TYPE_CONTAINER >
bool pop_stl_associative_container( TYPE_CONTAINER& );
/*****************************************
*
* Test buffer methods
*
****************************************/
public:
template< typename TYPE >
bool test( const TYPE& value, const size_t offset = 0 )
{
if( offset >= m_size )
return false;
size_t size_backup = m_size;
m_size -= offset;
TYPE buffer_value;
if( false == pop( buffer_value ) )
{
m_size = size_backup;
return false;
}
m_size = size_backup;
return value == buffer_value;
}
/*****************************************
*
* Get buffer methods
*
****************************************/
public:
template< typename TYPE >
bool get( TYPE& value, const size_t offset = 0 )
{
if( offset >= m_size )
return false;
size_t size_backup = m_size;
m_size -= offset;
bool result = pop( value );
m_size = size_backup;
return result;
}
/*****************************************
*
* Read / Write buffer methods
*
****************************************/
protected:
bool write( const void*, const size_t, const bool is_reallocate = true );
bool read( const void*, const size_t );
/*****************************************
*
* Other methods and members
*
****************************************/
public:
bool allocate( const size_t );
bool reallocate( const size_t, const bool is_store = false );
bool trancate( );
void reset( );
void fill( const char symbol = 0 );
public:
const void* const buffer( ) const;
protected:
void* mp_buffer = nullptr;
public:
const size_t capacity( ) const;
protected:
size_t m_capacity = 0;
public:
const size_t size( ) const;
protected:
size_t m_size = 0;
public:
void dump( ) const;
void info( ) const;
};
template< typename TYPE >
ByteBuffer::ByteBuffer( const TYPE& data )
{
if( false == allocate( sizeof( data ) ) ) return;
*this << data;
}
inline
const void* const ByteBuffer::buffer( ) const
{
return mp_buffer;
}
inline
const size_t ByteBuffer::size( ) const
{
return m_size;
}
inline
const size_t ByteBuffer::capacity( ) const
{
return m_capacity;
}
template< typename TYPE >
ByteBuffer& ByteBuffer::operator << ( const TYPE& value )
{
push( value, true );
return *this;
}
template< typename TYPE >
ByteBuffer& ByteBuffer::operator >> ( TYPE& value )
{
pop( value );
return *this;
}
/*****************************************
*
* Push buffer methods
*
****************************************/
template< typename TYPE >
bool ByteBuffer::push( const std::optional< TYPE >& optional, const bool is_reallocate )
{
if( std::nullopt != optional )
{
if( false == push( optional.value( ) ) )
return false;
if( false == push( static_cast< size_t >( 1 ) ) )
return false;
}
else
{
if( false == push( static_cast< size_t >( 0 ) ) )
return false;
}
return true;
}
template< typename TYPE >
bool ByteBuffer::push( const std::vector< TYPE >& vector, const bool is_reallocate )
{
return push_stl_container( vector, is_reallocate );
}
template< typename TYPE >
bool ByteBuffer::push( const std::list< TYPE >& list, const bool is_reallocate )
{
return push_stl_container( list, is_reallocate );
}
template< typename TYPE_FIRST, typename TYPE_SECOND >
bool ByteBuffer::push( const std::pair< TYPE_FIRST, TYPE_SECOND >& pair, const bool is_reallocate )
{
if( false == push( pair.first, is_reallocate ) )
return false;
if( false == push( pair.second, is_reallocate ) )
return false;
return true;
}
template< typename TYPE >
bool ByteBuffer::push( const std::set< TYPE >& set, const bool is_reallocate )
{
return push_stl_associative_container( set, is_reallocate );
}
template< typename TYPE_KEY, typename TYPE_VALUE >
bool ByteBuffer::push( const std::map< TYPE_KEY, TYPE_VALUE >& map, const bool is_reallocate )
{
return push_stl_associative_container( map, is_reallocate );
}
template< typename TYPE >
typename std::enable_if_t< __INTEGRAL_TYPE__( TYPE ) || __FLOATING_POINT_TYPE__( TYPE ), bool >
ByteBuffer::push( const TYPE& value, const bool is_reallocate )
{
return push( static_cast< const void* >( &value ), sizeof( TYPE ), is_reallocate );
}
template< typename TYPE >
typename std::enable_if_t< __REST_TYPES__( TYPE ), bool >
ByteBuffer::push( const TYPE& value, const bool is_reallocate )
{
return value.to_buffer( *this );
}
template< typename ... TYPES >
bool ByteBuffer::push( const TYPES& ... values, const bool is_reallocate )
{
size_t size_backup = m_size;
bool result = true;
(void)std::initializer_list< int >{ ( result &= push( values, is_reallocate ), 0 )... };
if( false == result )
m_size = size_backup;
return result;
}
template< typename TYPE >
typename std::enable_if_t< __ENUM_TYPE__( TYPE ), bool >
ByteBuffer::push( const TYPE& value, const bool is_reallocate )
{
using ENUM_TYPE = std::underlying_type_t< TYPE >;
return push( static_cast< ENUM_TYPE >( value ), is_reallocate );
}
template< typename TYPE_CONTAINER >
bool ByteBuffer::push_stl_container( const TYPE_CONTAINER& container, const bool is_reallocate )
{
using TYPE_ITERATOR = typename TYPE_CONTAINER::const_reverse_iterator;
for( TYPE_ITERATOR iterator = container.crbegin( ); iterator != container.crend( ); ++iterator )
if( false == push( *iterator, is_reallocate ) )
return false;
return push( container.size( ) );
}
template< typename TYPE_CONTAINER >
bool ByteBuffer::push_stl_associative_container( const TYPE_CONTAINER& container, const bool is_reallocate )
{
return push_stl_container( container, is_reallocate );
}
/*****************************************
*
* Pop buffer methods
*
****************************************/
template< typename TYPE >
bool ByteBuffer::pop( std::optional< TYPE >& optional )
{
size_t has_value = false;
if( false == pop( has_value ) )
return false;
if( 1 == has_value )
{
TYPE value;
if( false == pop( value ) )
return false;
optional = value;
}
else optional = std::nullopt;
return true;
}
template< typename TYPE >
bool ByteBuffer::pop( std::vector< TYPE >& vector )
{
return pop_stl_container( vector );
}
template< typename TYPE >
bool ByteBuffer::pop( std::list< TYPE >& list )
{
return pop_stl_container( list );
}
template< typename TYPE_FIRST, typename TYPE_SECOND >
bool ByteBuffer::pop( std::pair< TYPE_FIRST, TYPE_SECOND >& pair )
{
if( false == pop( pair.second ) )
return false;
if( false == pop( pair.first ) )
return false;
return true;
}
template< typename TYPE >
bool ByteBuffer::pop( std::set< TYPE >& set )
{
return pop_stl_associative_container( set );
}
template< typename TYPE_KEY, typename TYPE_VALUE >
bool ByteBuffer::pop( std::map< TYPE_KEY, TYPE_VALUE >& map )
{
return pop_stl_associative_container( map );
}
template< typename TYPE >
typename std::enable_if_t< __INTEGRAL_TYPE__( TYPE ) || __FLOATING_POINT_TYPE__( TYPE ), bool >
ByteBuffer::pop( TYPE& value )
{
return pop( static_cast< const void* >( &value ), sizeof( TYPE ) );
}
template< typename TYPE >
typename std::enable_if_t< __REST_TYPES__( TYPE ), bool >
ByteBuffer::pop( TYPE& value )
{
return value.from_buffer( *this );
}
template< typename ... TYPES >
bool ByteBuffer::pop( TYPES& ... values )
{
size_t size_backup = m_size;
bool result = true;
(void)std::initializer_list< int >{ ( result &= pop( values ), 0 )... };
if( false == result )
m_size = size_backup;
return result;
}
template< typename TYPE >
typename std::enable_if_t< __ENUM_TYPE__( TYPE ), bool >
ByteBuffer::pop( TYPE& value )
{
using ENUM_TYPE = std::underlying_type_t< TYPE >;
ENUM_TYPE _value;
if( false == pop( _value ) )
return false;
value = static_cast< TYPE >( _value );
return true;
}
template< typename TYPE_CONTAINER >
bool ByteBuffer::pop_stl_container( TYPE_CONTAINER& container )
{
size_t size = 0;
// Reading size of string content
if( false == pop( size ) )
return false;
for( size_t index = 0; index < size; ++index )
{
typename TYPE_CONTAINER::value_type value;
if( false == pop( value ) )
return false;
container.emplace_back( value );
}
return true;
}
template< typename TYPE_CONTAINER >
bool ByteBuffer::pop_stl_associative_container( TYPE_CONTAINER& container )
{
size_t size = 0;
// Reading size of string content
if( false == pop( size ) )
return false;
for( size_t index = 0; index < size; ++index )
{
// Here value is a pair in case of map and simple type in case of set
typename TYPE_CONTAINER::value_type value;
if( false == pop( value ) )
return false;
container.emplace( value );
}
return true;
}
} // namespace carpc
| 30.810811 | 136 | 0.557456 | dterletskiy |
41f57a9d25a394084196fd820c9a5469f04a0ee3 | 12,217 | cpp | C++ | src/webots/gui/WbHtmlExportDialog.cpp | awesome-archive/webots | 8e74fb8393d1e3a6540749afc492635c43f1b30f | [
"Apache-2.0"
] | 2 | 2019-07-12T13:47:44.000Z | 2019-08-17T02:53:54.000Z | src/webots/gui/WbHtmlExportDialog.cpp | golbh/webots | 8e74fb8393d1e3a6540749afc492635c43f1b30f | [
"Apache-2.0"
] | null | null | null | src/webots/gui/WbHtmlExportDialog.cpp | golbh/webots | 8e74fb8393d1e3a6540749afc492635c43f1b30f | [
"Apache-2.0"
] | 1 | 2019-07-13T17:58:04.000Z | 2019-07-13T17:58:04.000Z | // Copyright 1996-2018 Cyberbotics Ltd.
//
// 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
// 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.
#include "WbHtmlExportDialog.hpp"
#include "WbLight.hpp"
#include "WbMathsUtilities.hpp"
#include "WbPerspective.hpp"
#include "WbPreferences.hpp"
#include "WbProject.hpp"
#include "WbWorld.hpp"
#include <QtCore/QFileInfo>
#include <QtWidgets/QCheckBox>
#include <QtWidgets/QDialogButtonBox>
#include <QtWidgets/QFileDialog>
#include <QtWidgets/QGroupBox>
#include <QtWidgets/QLabel>
#include <QtWidgets/QLineEdit>
#include <QtWidgets/QPushButton>
#include <QtWidgets/QSlider>
#include <QtWidgets/QSpinBox>
#include <QtWidgets/QVBoxLayout>
#include <cassert>
#include <cmath>
const QString gShadowIntensityString = "shadowIntensity";
const QString gShadowMapSizeString = "shadowMapSize";
const QString gShadowFilterSizeString = "shadowFilterSize";
const QString gShadowCascadesString = "shadowCascades";
const QString gFrustumCullingString = "frustumCulling";
WbHtmlExportDialog::WbHtmlExportDialog(const QString &title, const QString &worldFilePath, QWidget *parent) :
QDialog(parent),
mTitle(title),
mWorldFilePath(worldFilePath) {
setWindowTitle(title);
setModal(true);
mShadowMapLabel = new QLabel(this);
mShadowMapSlider = createSlider(gShadowMapSizeString);
mShadowMapSlider->setRange(1, 8);
mShadowMapSlider->setTickInterval(1);
mShadowMapSlider->setTickPosition(QSlider::TicksBelow);
mShadowCascadesEdit = createSpinBox(gShadowCascadesString);
mShadowCascadesEdit->setRange(0, 10);
mShadowCascadesSlider = createSlider(gShadowCascadesString);
mShadowCascadesSlider->setRange(0, 10);
mShadowFilterEdit = createSpinBox(gShadowFilterSizeString);
mShadowFilterEdit->setRange(0, 64);
mShadowFilterSlider = createSlider(gShadowFilterSizeString);
mShadowFilterSlider->setRange(0, 32);
mShadowIntensityEdit = new QDoubleSpinBox(this);
mShadowIntensityEdit->setFixedWidth(50);
mShadowIntensityEdit->setRange(0.0, 1.0);
mShadowIntensityEdit->setButtonSymbols(QAbstractSpinBox::NoButtons);
mShadowIntensityEdit->setProperty("parameterName", gShadowIntensityString);
mShadowIntensitySlider = createSlider(gShadowIntensityString);
mShadowIntensitySlider->setRange(0, 100);
mFrustumCullingCheckBox = new QCheckBox(this);
connect(mShadowMapSlider, &QSlider::valueChanged, this, &WbHtmlExportDialog::updateShadowEditValue);
connect(mShadowCascadesSlider, &QSlider::valueChanged, this, &WbHtmlExportDialog::updateShadowEditValue);
connect(mShadowFilterSlider, &QSlider::valueChanged, this, &WbHtmlExportDialog::updateShadowEditValue);
connect(mShadowIntensitySlider, &QSlider::valueChanged, this, &WbHtmlExportDialog::updateShadowEditValue);
connect(mShadowFilterEdit, static_cast<void (QSpinBox::*)(int)>(&QSpinBox::valueChanged), this,
&WbHtmlExportDialog::updateShadowSliderValue);
connect(mShadowCascadesEdit, static_cast<void (QSpinBox::*)(int)>(&QSpinBox::valueChanged), this,
&WbHtmlExportDialog::updateShadowSliderValue);
connect(mShadowIntensityEdit, static_cast<void (QDoubleSpinBox::*)(double)>(&QDoubleSpinBox::valueChanged), this,
&WbHtmlExportDialog::updateShadowIntensitySliderValue);
QGroupBox *shadowsGroup = new QGroupBox(tr("X3D Shadow Parameters"), this);
QGridLayout *shadowsLayout = new QGridLayout(shadowsGroup);
shadowsLayout->setColumnStretch(0, 0);
shadowsLayout->setColumnStretch(1, 0);
shadowsLayout->setColumnStretch(2, 1);
shadowsLayout->setColumnStretch(3, 0);
shadowsLayout->setColumnStretch(3, 0);
shadowsLayout->addWidget(new QLabel(gShadowIntensityString + ":", this), 0, 0, Qt::AlignLeft);
shadowsLayout->addWidget(new QLabel("<small>0</small>", this), 0, 1, Qt::AlignRight);
shadowsLayout->addWidget(mShadowIntensitySlider, 0, 2);
shadowsLayout->addWidget(new QLabel("<small>1</small>", this), 0, 3, Qt::AlignLeft);
shadowsLayout->addWidget(mShadowIntensityEdit, 0, 4);
shadowsLayout->addWidget(new QLabel(gShadowMapSizeString + ":", this), 1, 0, Qt::AlignLeft);
shadowsLayout->addWidget(new QLabel("<small>32</small>", this), 1, 1, Qt::AlignRight);
shadowsLayout->addWidget(mShadowMapSlider, 1, 2);
shadowsLayout->addWidget(new QLabel("<small>4096</small>", this), 1, 3, Qt::AlignLeft);
shadowsLayout->addWidget(mShadowMapLabel, 1, 4, Qt::AlignCenter);
shadowsLayout->addWidget(new QLabel(gShadowFilterSizeString + ":", this), 2, 0, Qt::AlignLeft);
shadowsLayout->addWidget(new QLabel("<small>0</small>", this), 2, 1, Qt::AlignRight);
shadowsLayout->addWidget(mShadowFilterSlider, 2, 2);
shadowsLayout->addWidget(new QLabel("<small>32</small>", this), 2, 3, Qt::AlignLeft);
shadowsLayout->addWidget(mShadowFilterEdit, 2, 4);
shadowsLayout->addWidget(new QLabel(gShadowCascadesString + ":", this), 3, 0, Qt::AlignLeft);
shadowsLayout->addWidget(new QLabel("<small>0</small>", this), 3, 1, Qt::AlignRight);
shadowsLayout->addWidget(mShadowCascadesSlider, 3, 2);
shadowsLayout->addWidget(new QLabel("<small>10</small>", this), 3, 3, Qt::AlignLeft);
shadowsLayout->addWidget(mShadowCascadesEdit, 3, 4);
QGroupBox *renderingGroup = new QGroupBox(tr("X3D Rendering Parameters"), this);
QGridLayout *renderingLayout = new QGridLayout(renderingGroup);
renderingLayout->addWidget(new QLabel(gFrustumCullingString + ":", this), 0, 0, Qt::AlignLeft);
renderingLayout->addWidget(mFrustumCullingCheckBox, 0, 1);
QGroupBox *fileGroup = new QGroupBox(this);
mFileLineEdit = new QLineEdit(this);
QString proposedFilename;
for (int i = 0; i < 100; ++i) {
QString suffix = i == 0 ? "" : QString("_%1").arg(i);
proposedFilename =
WbPreferences::instance()->value("Directories/www").toString() + QFileInfo(mWorldFilePath).baseName() + suffix + ".html";
if (!QFileInfo::exists(proposedFilename))
break;
}
mFileLineEdit->setText(WbProject::computeBestPathForSaveAs(proposedFilename));
mFileLineEdit->setReadOnly(true);
QPushButton *browseButton = new QPushButton("...", this);
browseButton->setMaximumWidth(30);
connect(browseButton, &QPushButton::clicked, this, &WbHtmlExportDialog::browse);
QHBoxLayout *fileLayout = new QHBoxLayout(fileGroup);
fileLayout->addWidget(new QLabel(tr("File name:"), this), 0, Qt::AlignLeft);
fileLayout->addWidget(mFileLineEdit, 1);
fileLayout->addWidget(browseButton, 0, Qt::AlignLeft);
mButtonBox = new QDialogButtonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel, Qt::Horizontal, this);
connect(mButtonBox, &QDialogButtonBox::accepted, this, &WbHtmlExportDialog::accept);
connect(mButtonBox, &QDialogButtonBox::rejected, this, &WbHtmlExportDialog::reject);
QVBoxLayout *mainLayout = new QVBoxLayout(this);
mainLayout->addWidget(shadowsGroup);
mainLayout->addWidget(renderingGroup);
mainLayout->addWidget(fileGroup);
mainLayout->addWidget(mButtonBox);
// read intial export values
const QHash<QString, QString> parameters = WbWorld::instance()->perspective()->x3dExportParameters();
QString mapValueString;
if (parameters.contains(gShadowMapSizeString))
mapValueString = parameters.value(gShadowMapSizeString);
else
mapValueString = WbLight::defaultX3dShadowsParameter(gShadowMapSizeString);
mShadowMapSlider->setValue(computeShadowMapSliderIndex(mapValueString.toInt()));
QString filterValueString;
if (parameters.contains(gShadowFilterSizeString))
filterValueString = parameters.value(gShadowFilterSizeString);
else
filterValueString = WbLight::defaultX3dShadowsParameter(gShadowFilterSizeString);
mShadowFilterSlider->setValue(filterValueString.toInt());
QString intensityValueString;
if (parameters.contains(gShadowIntensityString))
intensityValueString = parameters.value(gShadowIntensityString);
else
intensityValueString = WbLight::defaultX3dShadowsParameter(gShadowIntensityString);
mShadowIntensitySlider->setValue(intensityValueString.toDouble() * 100);
QString cascadesValueString;
if (parameters.contains(gShadowCascadesString))
cascadesValueString = parameters.value(gShadowCascadesString);
else
cascadesValueString = WbLight::defaultX3dShadowsParameter(gShadowCascadesString);
mShadowCascadesSlider->setValue(cascadesValueString.toInt());
QString frustumCullingValueString = parameters.value(gFrustumCullingString);
if (frustumCullingValueString.isEmpty())
frustumCullingValueString = WbWorld::defaultX3dFrustumCullingParameter();
mFrustumCullingCheckBox->setChecked(frustumCullingValueString == "true");
}
WbHtmlExportDialog::~WbHtmlExportDialog() {
}
QSlider *WbHtmlExportDialog::createSlider(const QString ¶meterName) {
QSlider *slider = new QSlider(Qt::Horizontal, this);
slider->setTickInterval(0);
slider->setTracking(true);
slider->setMinimumWidth(200);
slider->setProperty("parameterName", parameterName);
return slider;
}
QSpinBox *WbHtmlExportDialog::createSpinBox(const QString ¶meterName) {
QSpinBox *spinBox = new QSpinBox(this);
spinBox->setMaximumWidth(50);
spinBox->setButtonSymbols(QAbstractSpinBox::NoButtons);
spinBox->setProperty("parameterName", parameterName);
return spinBox;
}
void WbHtmlExportDialog::accept() {
// store x3d export preferences
WbPerspective *perspective = WbWorld::instance()->perspective();
perspective->setX3dExportParameter(gShadowMapSizeString, mShadowMapLabel->text());
perspective->setX3dExportParameter(gShadowFilterSizeString, QString::number(mShadowFilterEdit->value()));
perspective->setX3dExportParameter(gShadowIntensityString, QString::number(mShadowIntensityEdit->value()));
perspective->setX3dExportParameter(gShadowCascadesString, QString::number(mShadowCascadesEdit->value()));
perspective->setX3dExportParameter(gFrustumCullingString, convertBoolToString(mFrustumCullingCheckBox->isChecked()));
perspective->save();
QDialog::accept();
}
int WbHtmlExportDialog::computeShadowMapSliderIndex(int value) {
int indexValue = 32;
for (int i = 1; i <= 8; ++i) {
if (indexValue == value)
return i;
indexValue *= 2;
}
assert(false);
return 0;
}
void WbHtmlExportDialog::updateShadowEditValue(int value) {
QObject *senderObject = QObject::sender();
const QString ¶meterName = senderObject->property("parameterName").toString();
senderObject->blockSignals(true);
if (parameterName == gShadowMapSizeString)
mShadowMapLabel->setText(QString::number(std::pow(2, value + 4)));
else if (parameterName == gShadowFilterSizeString)
mShadowFilterEdit->setValue(value);
else if (parameterName == gShadowCascadesString)
mShadowCascadesEdit->setValue(value);
else if (parameterName == gShadowIntensityString)
mShadowIntensityEdit->setValue(((double)value) / 100.0);
senderObject->blockSignals(false);
}
void WbHtmlExportDialog::updateShadowSliderValue(int value) {
QObject *senderObject = QObject::sender();
const QString ¶meterName = senderObject->property("parameterName").toString();
senderObject->blockSignals(true);
if (parameterName == gShadowFilterSizeString)
mShadowFilterSlider->setValue(value);
else if (parameterName == gShadowCascadesString)
mShadowCascadesSlider->setValue(value);
senderObject->blockSignals(false);
}
void WbHtmlExportDialog::updateShadowIntensitySliderValue(double value) {
mShadowIntensitySlider->blockSignals(true);
mShadowIntensitySlider->setValue(value * 100);
mShadowIntensitySlider->blockSignals(false);
}
void WbHtmlExportDialog::browse() {
const QString &fileName = QFileDialog::getSaveFileName(this, mTitle, mFileLineEdit->text(), tr("HTML Files (*.html *.HTML)"));
if (!fileName.isEmpty())
mFileLineEdit->setText(fileName);
}
QString WbHtmlExportDialog::fileName() {
return mFileLineEdit->text();
}
| 44.915441 | 128 | 0.770238 | awesome-archive |
41f7fd4f6d2601b32b16e82123d28a26eb79f900 | 1,137 | cpp | C++ | apps/dashboard/Dashboard.cpp | zSelimReborn/fairwindplusplus | aa0f754dc81414c21e5b3a8fc1f4a7b9b6bb6c20 | [
"Apache-2.0"
] | null | null | null | apps/dashboard/Dashboard.cpp | zSelimReborn/fairwindplusplus | aa0f754dc81414c21e5b3a8fc1f4a7b9b6bb6c20 | [
"Apache-2.0"
] | null | null | null | apps/dashboard/Dashboard.cpp | zSelimReborn/fairwindplusplus | aa0f754dc81414c21e5b3a8fc1f4a7b9b6bb6c20 | [
"Apache-2.0"
] | null | null | null | //
// Created by Raffaele Montella on 01/04/21.
//
#include "Dashboard.hpp"
#include <QDebug>
#include <QJsonArray>
#include <FairWindSdk/FairWind.hpp>
#include <FairWindSdk/ILayout.hpp>
#include "MainPage.hpp"
namespace fairwind::apps::dashboard {
void Dashboard::onCreate() { FairWindApp::onCreate(); }
void Dashboard::onResume() { FairWindApp::onResume(); }
void Dashboard::onPause() { FairWindApp::onPause(); }
void Dashboard::onStop() { FairWindApp::onStop(); }
void Dashboard::onDestroy() { FairWindApp::onDestroy(); }
void Dashboard::onConfigChanged() { FairWindApp::onConfigChanged(); }
bool Dashboard::onInstall() {
FairWindApp::onInstall();
return true;
}
bool Dashboard::onUninstall() {
FairWindApp::onUninstall();
return true;
}
void Dashboard::onStart() {
FairWindApp::onStart();
QString route = getRoute();
if (route.isEmpty()) {
route = "__home__";
}
auto mainPage = new MainPage();
add(mainPage, route);
show(route);
}
Dashboard::~Dashboard() {
}
} | 21.055556 | 73 | 0.612137 | zSelimReborn |
41f8dad6223bc2c14bb2e44348b039e684d60288 | 2,271 | cpp | C++ | Tests/Unit/TestBadMemory.cpp | EDFilms/GCAP | 4d68809efe3528cb0b9a0039d3082512400c84da | [
"MIT"
] | 17 | 2018-03-29T15:24:40.000Z | 2022-01-10T05:01:09.000Z | Tests/Unit/TestBadMemory.cpp | EDFilms/GCAP | 4d68809efe3528cb0b9a0039d3082512400c84da | [
"MIT"
] | null | null | null | Tests/Unit/TestBadMemory.cpp | EDFilms/GCAP | 4d68809efe3528cb0b9a0039d3082512400c84da | [
"MIT"
] | 3 | 2018-04-07T06:02:05.000Z | 2019-01-21T00:37:18.000Z | #define CATCH_CONFIG_MAIN // This tells Catch to provide a main() - only do this in one cpp file
#include "catch.hpp"
#include "SceneTrackStatic.h"
#include "TestCommon.h"
#include "TestCRC.h"
extern "C" {
ST_PUBLIC int stInternal_SetMallocMaxSizeMb(int megaBytes);
}
bool MaybeRange(int x, int y, int n)
{
return (x >= (y - n) && x <= (y + n));
}
TEST_CASE("Force NULL at 40 mb", "[BadMemory]")
{
printf("In Config.inc make sure these are set:\n");
printf("#define ST_CFG_TRACK_MEMORY 1\n");
printf("#define ST_CFG_MALLOC_CONTROLLED_NULL 1\n");
printf("And Recompile - Otherwise this test will not work\n");
stInternal_SetMallocMaxSizeMb(40);
uint32_t context = stCreateRecording();
REQUIRE(stGetError() == 0);
uint32_t classTransform = stCreateObjectType(ST_FREQUENCY_DYNAMIC);
uint32_t varTransform_Position = stAddObjectTypeComponentEx2(classTransform, ST_KIND_POSITION, ST_TYPE_FLOAT32, 3, 1, ST_UNITS_UNSPECIFIED, ST_REFERENCE_WORLD);
uint32_t nbObjects = 4096;
uint32_t nbFrames = 4000;
uint32_t* transforms = (uint32_t*) malloc(sizeof(uint32_t) * nbObjects);
// Start
for(uint32_t i=0;i < nbObjects;i++)
{
transforms[i] = stCreateObject(classTransform);
}
uint32_t frameNb=0;
for(;frameNb < nbFrames;frameNb++)
{
for(uint32_t j=0;j < nbObjects;j++)
{
Vector3 p;
p.x = randFloat2(100);
p.y = randFloat2(100);
p.z = randFloat2(100);
stSetValue_3_float32(transforms[j], varTransform_Position, p.x, p.y, p.z);
}
stSubmit(1.0f / 60.0f);
if (stGetError() == ST_ERROR_DISK)
{
printf("Error reached!\n\nDisk error on frame: %i\n\n", frameNb);
// break;
}
if (stGetError() == ST_ERROR_RECORDING)
{
printf("Error reached!\n\nRecording error on frame: %i\n\n", frameNb);
break;
}
if (stGetError() == ST_ERROR_WRITING)
{
printf("Error reached!\n\nWrite error on frame: %i\n\n", frameNb);
break;
}
REQUIRE(frameNb <= 40);
}
stCloseRecording(context);
printf("Test should pass if no assertions, and 'Recording error' message is printed. Should fail around frame 30.\n\n");
// Recording is expected to fail around 28..32 (Usually 30)
REQUIRE(MaybeRange(frameNb, 30, 2));
}
| 26.717647 | 162 | 0.667988 | EDFilms |
41fa6326c64e9df0b3a7916f2b56cb2dba59e394 | 3,180 | cpp | C++ | src/CGnuPlotStyleAdjacency.cpp | colinw7/CQGnuPlot | 8001b0a0d40c1fde8e5efe05ebe0c9b0541daa94 | [
"MIT"
] | null | null | null | src/CGnuPlotStyleAdjacency.cpp | colinw7/CQGnuPlot | 8001b0a0d40c1fde8e5efe05ebe0c9b0541daa94 | [
"MIT"
] | null | null | null | src/CGnuPlotStyleAdjacency.cpp | colinw7/CQGnuPlot | 8001b0a0d40c1fde8e5efe05ebe0c9b0541daa94 | [
"MIT"
] | 1 | 2019-04-01T13:08:45.000Z | 2019-04-01T13:08:45.000Z | #include <CGnuPlotStyleAdjacency.h>
#include <CGnuPlotAdjacencyStyleValue.h>
#include <CGnuPlotStyleValueMgr.h>
#include <CGnuPlotPlot.h>
#include <CGnuPlotGroup.h>
#include <CGnuPlotRenderer.h>
#include <CGnuPlotDevice.h>
#include <CGnuPlotStyleAdjacencyRenderer.h>
CGnuPlotStyleAdjacency::
CGnuPlotStyleAdjacency() :
CGnuPlotStyleBase(CGnuPlot::PlotStyle::ADJACENCY)
{
CGnuPlotStyleValueMgrInst->setId<CGnuPlotAdjacencyStyleValue>("adjacency");
}
void
CGnuPlotStyleAdjacency::
draw2D(CGnuPlotPlot *plot, CGnuPlotRenderer *renderer)
{
CGnuPlotAdjacencyStyleValue *value =
CGnuPlotStyleValueMgrInst->getValue<CGnuPlotAdjacencyStyleValue>(plot);
if (! value) {
value = plot->app()->device()->createAdjacencyStyleValue(plot);
value->initRenderer(renderer);
CGnuPlotStyleValueMgrInst->setValue<CGnuPlotAdjacencyStyleValue>(plot, value);
}
//---
plot->group()->setMargin(CGnuPlotMargin(0, 0, 0, 0));
CAdjacency *adjacency = value->adjacency();
if (! value->isInited()) {
int state = 0;
for (const auto &point : plot->getPoints2D()) {
if (point.isDiscontinuity())
++state;
// node id, name and group
if (state == 0) {
if (point.getNumValues() != 3)
continue;
int id = 0;
if (! point.getValue(1, id))
continue;
std::string name;
if (! point.getValue(2, name))
continue;
int group;
if (! point.getValue(3, group))
continue;
adjacency->addNode(id, name, group);
}
// source, target, value
else if (state == 1) {
int source = 0;
if (! point.getValue(1, source))
continue;
int target = 0;
if (! point.getValue(2, target))
continue;
int value3 = 0;
if (! point.getValue(3, value3))
continue;
adjacency->connectNodes(source, target, value3);
}
}
adjacency->sortNodes();
value->setInited(true);
}
CGnuPlotStyleAdjacencyRenderer *arenderer = value->renderer();
arenderer->setRenderer(renderer);
arenderer->setPalette (value->palette());
arenderer->clearRects();
adjacency->draw(arenderer);
}
bool
CGnuPlotStyleAdjacency::
mouseTip(CGnuPlotPlot *plot, const CGnuPlotMouseEvent &mouseEvent, CGnuPlotTipData &tipData)
{
CGnuPlotAdjacencyStyleValue *value =
CGnuPlotStyleValueMgrInst->getValue<CGnuPlotAdjacencyStyleValue>(plot);
if (! value) return false;
CGnuPlotStyleAdjacencyRenderer *arenderer = value->renderer();
int ivalue;
std::string name1, name2;
CRGBA c;
if (! arenderer->getValueAtPos(mouseEvent.window(), ivalue, name1, name2, c))
return false;
if (ivalue <= 0)
return false;
tipData.setBorderColor(c);
if (name1 != name2) {
tipData.setXStr(name1);
tipData.setYStr(name2 + " = " + CStrUtil::strprintf("%d", ivalue));
}
else {
tipData.setXStr(name1);
tipData.setYStr("");
}
return true;
}
void
CGnuPlotStyleAdjacency::
mousePress(CGnuPlotPlot *, const CGnuPlotMouseEvent &)
{
}
CBBox2D
CGnuPlotStyleAdjacency::
fit(CGnuPlotPlot *)
{
return CBBox2D(0, 0, 1, 1);
}
| 21.342282 | 92 | 0.652516 | colinw7 |
41ff4a5d750d5766f9b4f1925ba290f50a6404ee | 1,718 | cpp | C++ | books/tech/cpp/std-11/a_williams-cpp_concurrency_in_action/code/ch_04-sync_concurrent_operations/02-using_condition_variable/main.cpp | ordinary-developer/education | 1b1f40dacab873b28ee01dfa33a9bd3ec4cfed58 | [
"MIT"
] | 1 | 2017-05-04T08:23:46.000Z | 2017-05-04T08:23:46.000Z | books/techno/cpp/_upper-intermediate/cpp_concurrency_in_action_a_williams/code/ch_4-SYNCHRONIZING_CONCURRENT_OPERATIONS/02-using_condition_variable/main.cpp | ordinary-developer/lin_education | 13d65b20cdbc3e5467b2383e5c09c73bbcdcb227 | [
"MIT"
] | null | null | null | books/techno/cpp/_upper-intermediate/cpp_concurrency_in_action_a_williams/code/ch_4-SYNCHRONIZING_CONCURRENT_OPERATIONS/02-using_condition_variable/main.cpp | ordinary-developer/lin_education | 13d65b20cdbc3e5467b2383e5c09c73bbcdcb227 | [
"MIT"
] | null | null | null | #include <mutex>
#include <condition_variable>
#include <thread>
#include <queue>
#include <iostream>
#include <chrono>
bool more_data_to_prepare() { return false; }
struct data_chunk { };
data_chunk prepare_data() { return data_chunk(); }
void process(data_chunk&) {
std::cout << "[OK] - begin processing data" << std::endl;
std::this_thread::sleep_for(std::chrono::milliseconds(3000));
std::cout << "[OK] - end processing data" << std::endl;
}
bool is_last_chunk(data_chunk&) { return true; }
std::mutex mutex;
std::queue<data_chunk> data_queue;
std::condition_variable data_condition;
void dataPreparationThread() {
do {
const data_chunk data = prepare_data();
std::lock_guard<std::mutex> lock(mutex);
std::cout << "[ok] - {producer} start locking" << std::endl;
data_queue.push(data);
data_condition.notify_one();
std::cout << "[ok] - {producer} stop locking" << std::endl;
} while (more_data_to_prepare());
}
void dataProcessingThread() {
while (true) {
std::unique_lock<std::mutex> lock(mutex);
data_condition.wait(lock, [] {
return !data_queue.empty();
});
std::cout << "[ok] - {consumer} start locking" << std::endl;
data_chunk data = data_queue.front();
data_queue.pop();
std::cout << "[ok] - {consumer} stop locking" << std::endl;
lock.unlock();
process(data);
if (is_last_chunk(data)) {
break;
}
}
}
int main() {
std::thread t1(dataPreparationThread);
std::thread t2(dataProcessingThread);
t1.join();
t2.join();
return 0;
}
| 26.030303 | 68 | 0.587311 | ordinary-developer |
41ffcf0434ec01fa7066425ec09ebc319d2884ed | 2,393 | hpp | C++ | Engine/Code/Engine/Services/IConsoleService.hpp | cugone/Abrams2022 | 54efe5fdd7d2d9697f005ee45a171ecea68d0df8 | [
"MIT"
] | null | null | null | Engine/Code/Engine/Services/IConsoleService.hpp | cugone/Abrams2022 | 54efe5fdd7d2d9697f005ee45a171ecea68d0df8 | [
"MIT"
] | 20 | 2021-11-29T14:09:33.000Z | 2022-03-26T20:12:44.000Z | Engine/Code/Engine/Services/IConsoleService.hpp | cugone/Abrams2022 | 54efe5fdd7d2d9697f005ee45a171ecea68d0df8 | [
"MIT"
] | null | null | null | #pragma once
#include "Engine/Services/IService.hpp"
#include <filesystem>
#include <string>
struct ConsoleCommand { virtual ~ConsoleCommand() noexcept = default; };
struct ConsoleCommandList { virtual ~ConsoleCommandList() noexcept = default; };
class IConsoleService : public IService {
public:
virtual ~IConsoleService() noexcept {};
virtual void RunCommand([[maybe_unused]] const std::string& name_and_args) noexcept = 0;
virtual void RegisterCommand([[maybe_unused]] const ConsoleCommand& command) noexcept = 0;
virtual void UnregisterCommand([[maybe_unused]] const std::string& command_name) noexcept = 0;
virtual void PushCommandList([[maybe_unused]] const ConsoleCommandList& list) noexcept = 0;
virtual void PopCommandList([[maybe_unused]] const ConsoleCommandList& list) noexcept = 0;
virtual void PrintMsg([[maybe_unused]] const std::string& msg) noexcept = 0;
virtual void WarnMsg([[maybe_unused]] const std::string& msg) noexcept = 0;
virtual void ErrorMsg([[maybe_unused]] const std::string& msg) noexcept = 0;
[[nodiscard]] virtual void* GetAcceleratorTable() const noexcept = 0;
[[nodiscard]] virtual bool IsOpen() const noexcept = 0;
[[nodiscard]] virtual bool IsClosed() const noexcept = 0;
protected:
private:
};
class NullConsoleService : public IConsoleService {
public:
~NullConsoleService() noexcept override {};
void RunCommand([[maybe_unused]] const std::string& name_and_args) noexcept override {};
void RegisterCommand([[maybe_unused]] const ConsoleCommand& command) noexcept override {};
void UnregisterCommand([[maybe_unused]] const std::string& command_name) noexcept override {};
void PushCommandList([[maybe_unused]] const ConsoleCommandList& list) noexcept override {};
void PopCommandList([[maybe_unused]] const ConsoleCommandList& list) noexcept override {};
void PrintMsg([[maybe_unused]] const std::string& msg) noexcept override {};
void WarnMsg([[maybe_unused]] const std::string& msg) noexcept override {};
void ErrorMsg([[maybe_unused]] const std::string& msg) noexcept override {};
[[nodiscard]] void* GetAcceleratorTable() const noexcept override { return nullptr; };
[[nodiscard]] bool IsOpen() const noexcept override { return false; };
[[nodiscard]] bool IsClosed() const noexcept override { return true; };
protected:
private:
};
| 45.150943 | 98 | 0.7313 | cugone |
5100742544b8dbd797d993bf13aa46f420702b2c | 506 | cpp | C++ | src/Base/GHSoundProfileTransition.cpp | GoldenHammerSoftware/GH | 757213f479c0fc80ed1a0f59972bf3e9d92b7526 | [
"MIT"
] | null | null | null | src/Base/GHSoundProfileTransition.cpp | GoldenHammerSoftware/GH | 757213f479c0fc80ed1a0f59972bf3e9d92b7526 | [
"MIT"
] | null | null | null | src/Base/GHSoundProfileTransition.cpp | GoldenHammerSoftware/GH | 757213f479c0fc80ed1a0f59972bf3e9d92b7526 | [
"MIT"
] | null | null | null | #include "GHSoundProfileTransition.h"
#include "GHSoundVolumeMgr.h"
GHSoundProfileTransition::GHSoundProfileTransition(GHSoundVolumeMgr& volumeMgr, const GHSoundProfile& profile)
: mVolumeMgr(volumeMgr)
, mSoundProfile(profile)
{
}
void GHSoundProfileTransition::activate(void)
{
mVolumeMgr.setEnvironmentProfile(mSoundProfile);
}
void GHSoundProfileTransition::deactivate(void)
{
// todo? find a way to remember state?
GHSoundProfile zeroProfile;
mVolumeMgr.setEnvironmentProfile(zeroProfile);
}
| 24.095238 | 110 | 0.818182 | GoldenHammerSoftware |
eeddcaa6d6cdddeb3dcc43a0fcd2b6166bf0e8f9 | 1,631 | cc | C++ | src/abc120/decayed_bridges.cc | nryotaro/at_c | 8d7d3aecb4e3c768aefdf0ceaeefb269ca9ab34c | [
"MIT"
] | null | null | null | src/abc120/decayed_bridges.cc | nryotaro/at_c | 8d7d3aecb4e3c768aefdf0ceaeefb269ca9ab34c | [
"MIT"
] | null | null | null | src/abc120/decayed_bridges.cc | nryotaro/at_c | 8d7d3aecb4e3c768aefdf0ceaeefb269ca9ab34c | [
"MIT"
] | null | null | null | #include <iostream>
#include <algorithm>
#include <vector>
#include "decayed_bridges.h"
#define MAX_N 100000
using namespace std;
long long par[MAX_N];
int size[MAX_N];
void init(long long n) {
for(int i=0;i<n;i++) {
par[i] = i;
size[i] = 1;
}
}
// rootを返す
long long find(long long x) {
if(par[x] == x) {
return x;
}
long long root = find(par[x]);
par[x] = root;
return root;
}
void unite(long long x, long long y) {
// 親どうし
long long root_x = find(x);
long long root_y = find(y);
if (root_x == root_y) {
return;
}
par[root_y] = root_x;
size[root_x] += size[root_y];
}
bool same(long long x, long long y) {
return find(x) == find(y);
}
long long size_tree(long long x) {
return size[find(x)];
}
/*
* n 島の数
* m 橋の数
* a[i] - b[i];
*/
vector<long long> decayed_bridges(long long n, long long m, long long a[], long long b[]) {
init(n);
vector<long long> answer;
answer.push_back((n * (n-1)) / 2);
for(int i=m-1;i>=1;i--) {
int aa = a[i] - 1;
int bb = b[i] - 1;
long long last = answer[answer.size() - 1];
if(same(aa, bb)) {
answer.push_back(last);
continue;
}
answer.push_back(last - size_tree(aa) * size_tree(bb));
unite(aa, bb);
}
reverse(answer.begin(), answer.end());
return answer;
}
/*
int main() {
long long n, m;
cin >> n;
cin >> m;
long long a[m];
long long b[m];
for(int i=0;i<m;i++) {
cin >> a[i];
cin >> b[i];
}
vector<long long> answer = decayed_bridges(n, m, a, b);
for(int i=0;i<answer.size();i++) {
cout << answer[i];
if(i != answer.size())
cout << endl;
}
}
*/
| 18.325843 | 91 | 0.561619 | nryotaro |
eede03fe3b9b3784d28016e3977bcf63b4408ebc | 1,448 | cpp | C++ | project/source/game/net/PlayerInfo.cpp | ntnt/carpg | f26c43c76d39f2ec2c51bd929f1b85f3c5197337 | [
"MIT"
] | null | null | null | project/source/game/net/PlayerInfo.cpp | ntnt/carpg | f26c43c76d39f2ec2c51bd929f1b85f3c5197337 | [
"MIT"
] | null | null | null | project/source/game/net/PlayerInfo.cpp | ntnt/carpg | f26c43c76d39f2ec2c51bd929f1b85f3c5197337 | [
"MIT"
] | null | null | null | #include "Pch.h"
#include "GameCore.h"
#include "PlayerInfo.h"
#include "SaveState.h"
#include "NetChangePlayer.h"
#include "Net.h"
//=================================================================================================
PlayerInfo::PlayerInfo() : pc(nullptr), u(nullptr), clas(Class::INVALID), left(LEFT_NO), update_flags(0), ready(false), loaded(false), warping(false)
{
}
//=================================================================================================
void PlayerInfo::Save(FileWriter& f)
{
f << name;
f << clas;
f << id;
f << devmode;
hd.Save(f);
f << (u ? u->refid : -1);
f.WriteStringArray<int, word>(notes);
}
//=================================================================================================
void PlayerInfo::Load(FileReader& f)
{
f >> name;
f >> clas;
f >> id;
f >> devmode;
int old_left;
if(LOAD_VERSION < V_0_5_1)
{
bool left;
f >> left;
old_left = (left ? 1 : 0);
}
else
old_left = -1;
hd.Load(f);
int refid;
f >> refid;
u = Unit::GetByRefid(refid);
f.ReadStringArray<int, word>(notes);
if(LOAD_VERSION < V_0_5_1)
f >> left;
if(old_left == 0 || old_left == -1)
left = LEFT_NO;
loaded = false;
}
//=================================================================================================
int PlayerInfo::GetIndex() const
{
int index = 0;
for(PlayerInfo* info : N.players)
{
if(info == this)
return index;
++index;
}
return -1;
}
| 22.276923 | 149 | 0.450967 | ntnt |
eee74198c07346542696b84e61d04976906622dd | 2,701 | ipp | C++ | boost/archive/impl/archive_pointer_oserializer.ipp | mike-code/boost_1_38_0 | 7ff8b2069344ea6b0b757aa1f0778dfb8526df3c | [
"BSL-1.0"
] | 4 | 2018-12-06T00:55:34.000Z | 2022-02-06T03:05:51.000Z | boost/archive/impl/archive_pointer_oserializer.ipp | mike-code/boost_1_38_0 | 7ff8b2069344ea6b0b757aa1f0778dfb8526df3c | [
"BSL-1.0"
] | 1 | 2016-03-31T20:56:08.000Z | 2016-04-18T08:56:40.000Z | boost/archive/impl/archive_pointer_oserializer.ipp | mike-code/boost_1_38_0 | 7ff8b2069344ea6b0b757aa1f0778dfb8526df3c | [
"BSL-1.0"
] | null | null | null | /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
// archive_pointer_oserializer.ipp:
// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
// Use, modification and distribution is subject to the Boost Software
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
// See http://www.boost.org for updates, documentation, and revision history.
#include <utility>
#include <cassert>
#include <boost/config.hpp> // msvc 6.0 needs this for warning suppression
#include <boost/archive/detail/archive_pointer_oserializer.hpp>
#include <boost/archive/detail/basic_serializer_map.hpp>
#include <boost/serialization/singleton.hpp>
namespace boost {
namespace archive {
namespace detail {
namespace { // anon
template<class Archive>
class oserializer_map : public basic_serializer_map
{
};
}
template<class Archive>
BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY())
archive_pointer_oserializer<Archive>::archive_pointer_oserializer(
const boost::serialization::extended_type_info & eti
) :
basic_pointer_oserializer(eti)
{
std::pair<
BOOST_DEDUCED_TYPENAME oserializer_map<Archive>::iterator,
bool
> result;
result = serialization::singleton<
oserializer_map<Archive>
>::get_mutable_instance().insert(this);
assert(result.second);
}
template<class Archive>
BOOST_ARCHIVE_OR_WARCHIVE_DECL(const basic_pointer_oserializer *)
archive_pointer_oserializer<Archive>::find(
const boost::serialization::extended_type_info & eti
){
const basic_serializer_arg bs(eti);
basic_serializer_map::const_iterator it;
it = boost::serialization::singleton<
oserializer_map<Archive>
>::get_const_instance().find(& bs);
assert(
it
!=
boost::serialization::singleton<
oserializer_map<Archive>
>::get_const_instance().end()
);
return static_cast<const basic_pointer_oserializer *>(*it);
}
template<class Archive>
BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY())
archive_pointer_oserializer<Archive>::~archive_pointer_oserializer(){
// note: we need to check that the map still exists as we can't depend
// on static variables being constructed in a specific sequence
if(! serialization::singleton<
oserializer_map<Archive>
>::is_destroyed()
){
unsigned int count;
count = serialization::singleton<
oserializer_map<Archive>
>::get_mutable_instance().erase(this);
assert(count);
}
}
} // namespace detail
} // namespace archive
} // namespace boost
| 30.693182 | 80 | 0.688264 | mike-code |
eee8cd824197fc13d546c76d907e9d7020521990 | 4,050 | cpp | C++ | apps/coprobber/dscrsimulation/OptimalUnit.cpp | AaronTrip/hog2 | 96616b40f4173959b127011c76f3e649688e1a99 | [
"MIT"
] | 5 | 2020-08-03T09:43:26.000Z | 2022-01-11T08:28:30.000Z | apps/coprobber/dscrsimulation/OptimalUnit.cpp | AaronTrip/hog2 | 96616b40f4173959b127011c76f3e649688e1a99 | [
"MIT"
] | null | null | null | apps/coprobber/dscrsimulation/OptimalUnit.cpp | AaronTrip/hog2 | 96616b40f4173959b127011c76f3e649688e1a99 | [
"MIT"
] | 7 | 2017-07-31T13:01:28.000Z | 2021-05-16T10:15:49.000Z | #include "OptimalUnit.h"
#include "GLUtil.h"
/*------------------------------------------------------------------------------
| Implementation
------------------------------------------------------------------------------*/
OptimalUnit::OptimalUnit( AbstractionGraphEnvironment *env, graphState initial_state, unsigned int _cop_speed, bool _I_am_a_robber, DSDijkstra_MemOptim *_dsdijkstra ):
myenv( env ),
current_pos(initial_state), copunit(-1), cop_speed(_cop_speed), done(false),
I_am_a_robber(_I_am_a_robber), movecacheindex(0)
{
if( _dsdijkstra == NULL ) {
dsdijkstra = new DSDijkstra_MemOptim( env, _cop_speed );
fprintf( stdout, "solving entire state space... " );
fflush( stdout );
dsdijkstra->dsdijkstra();
fprintf( stdout, "done\n" );
fflush( stdout );
delete_dsdijkstra_when_getting_destroyed = true;
} else {
dsdijkstra = _dsdijkstra;
delete_dsdijkstra_when_getting_destroyed = false;
}
};
OptimalUnit::OptimalUnit( AbstractionGraphEnvironment *env, graphState initial_state, int _copunit, unsigned int _cop_speed, bool _I_am_a_robber, DSDijkstra_MemOptim *_dsdijkstra ):
myenv( env ),
current_pos(initial_state), copunit(_copunit), cop_speed(_cop_speed), done(false),
I_am_a_robber(_I_am_a_robber), movecacheindex(0)
{
if( _dsdijkstra == NULL ) {
dsdijkstra = new DSDijkstra_MemOptim( env, _cop_speed );
fprintf( stdout, "solving entire state space... " );
fflush( stdout );
dsdijkstra->dsdijkstra();
fprintf( stdout, "done\n" );
fflush( stdout );
delete_dsdijkstra_when_getting_destroyed = true;
} else {
dsdijkstra = _dsdijkstra;
delete_dsdijkstra_when_getting_destroyed = false;
}
};
OptimalUnit::~OptimalUnit() {
if( delete_dsdijkstra_when_getting_destroyed )
delete dsdijkstra;
};
const char* OptimalUnit::GetName() {
char *str; str = (char*) malloc( sizeof(char) * 20 );
sprintf( str, "OptimalUnit" );
return str;
};
bool OptimalUnit::MakeMove( AbstractionGraphEnvironment *env, OccupancyInterface<graphState,graphMove> *, SimulationInfo<graphState,graphMove,AbstractionGraphEnvironment> *sinfo, graphMove &a ) {
// if the cop that we have to run away from is not set yet
if( copunit < 0 || done ) {
a = env->GetAction( current_pos, current_pos );
return false;
}
if( movecacheindex < movecache.size() ) {
a = env->GetAction( current_pos, movecache[movecacheindex] );
movecacheindex++;
return true;
}
movecacheindex = 0;
DSDijkstra_MemOptim::CRState mypos;
mypos.assign( 2, 0 );
// get information from opponent
PublicUnitInfo<graphState,graphMove,AbstractionGraphEnvironment> pui;
sinfo->GetPublicUnitInfo( copunit, pui );
if( I_am_a_robber ) {
mypos[0] = current_pos;
mypos[1] = pui.currentState;
movecache.clear();
graphState next_state = dsdijkstra->MakeMove( mypos, false );
movecache.push_back( next_state );
} else {
mypos[0] = pui.currentState;
mypos[1] = current_pos;
dsdijkstra->MakeSingleStepsCopMove( mypos, movecache );
}
a = env->GetAction( current_pos, movecache[movecacheindex] );
current_pos = movecache[movecacheindex];
movecacheindex++;
return true;
};
void OptimalUnit::UpdateLocation( AbstractionGraphEnvironment *, graphState &s, bool, SimulationInfo<graphState,graphMove,AbstractionGraphEnvironment> *sinfo ) {
current_pos = s;
if( copunit >= 0 ) {
PublicUnitInfo<graphState,graphMove,AbstractionGraphEnvironment> pui;
sinfo->GetPublicUnitInfo( copunit, pui );
if( pui.currentState == current_pos )
done = true;
}
};
void OptimalUnit::OpenGLDraw( const AbstractionGraphEnvironment *env, const SimulationInfo<graphState,graphMove,AbstractionGraphEnvironment>* ) const {
node *n = myenv->GetGraph()->GetNode( current_pos );
GLdouble x, y, z, rad = myenv->Scale()/4.;
x = n->GetLabelF(GraphAbstractionConstants::kXCoordinate);
y = n->GetLabelF(GraphAbstractionConstants::kYCoordinate);
z = n->GetLabelF(GraphAbstractionConstants::kZCoordinate);
if( done )
glColor3d( 0., 1., 0. ); // turn green when done
else
glColor3f( r, g, b );
DrawSphere( x, y, z, rad );
return;
};
| 33.196721 | 195 | 0.708642 | AaronTrip |
eeed2d7786df5bc0e33ac5019e7fe8dc200bcb72 | 938 | cpp | C++ | mcrouter/lib/AuxiliaryCPUThreadPool.cpp | Ngo-The-Trung/mcrouter | 277e5be62529e9961c24ca70a172c153491521b8 | [
"BSD-3-Clause"
] | null | null | null | mcrouter/lib/AuxiliaryCPUThreadPool.cpp | Ngo-The-Trung/mcrouter | 277e5be62529e9961c24ca70a172c153491521b8 | [
"BSD-3-Clause"
] | null | null | null | mcrouter/lib/AuxiliaryCPUThreadPool.cpp | Ngo-The-Trung/mcrouter | 277e5be62529e9961c24ca70a172c153491521b8 | [
"BSD-3-Clause"
] | 1 | 2021-03-16T04:36:39.000Z | 2021-03-16T04:36:39.000Z | /*
* Copyright (c) 2017, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
*/
#include "AuxiliaryCPUThreadPool.h"
namespace facebook {
namespace memcache {
namespace mcrouter {
// Number of CPU threads to run in CPU thread pool.
constexpr size_t kNumCPUThreads = 5;
namespace {
folly::Singleton<AuxiliaryCPUThreadPool> gAuxiliaryCPUThreadPool;
} // anonymous
wangle::CPUThreadPoolExecutor& AuxiliaryCPUThreadPool::getThreadPool() {
folly::call_once(initFlag_, [&] {
threadPool_ = std::make_unique<wangle::CPUThreadPoolExecutor>(
kNumCPUThreads,
std::make_shared<wangle::NamedThreadFactory>("mcr-cpuaux-"));
});
return *threadPool_;
}
} // mcrouter
} // memcache
} // facebook
| 26.055556 | 79 | 0.729211 | Ngo-The-Trung |
eeed8e9e036351e0cb78c590c47e4a95bdc7b64a | 2,180 | hpp | C++ | ui/include/ui/bordered.hpp | dobson156/irc_client | 9afc098087a64c88f599e3dae956b7be1407bb96 | [
"BSL-1.0"
] | 1 | 2019-07-13T18:43:38.000Z | 2019-07-13T18:43:38.000Z | ui/include/ui/bordered.hpp | dobson156/irc_client | 9afc098087a64c88f599e3dae956b7be1407bb96 | [
"BSL-1.0"
] | null | null | null | ui/include/ui/bordered.hpp | dobson156/irc_client | 9afc098087a64c88f599e3dae956b7be1407bb96 | [
"BSL-1.0"
] | null | null | null |
// Copyright Joseph Dobson 2014
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#ifndef BOARDERED_HPP
#define BOARDERED_HPP
#include "util.hpp"
#include "window.hpp"
#include <utility> //move
#include <algorithm> //max
namespace cons {
enum class borders { top, bottom, left, right };
class bordered : public base {
frame frame_;
unique_base_ptr element;
bool top { false }, bottom { false },
left { false }, right { false };
//TODO make safe for very small sizes
point calc_element_dimension() const;
point calc_element_position() const;
unique_window_ptr make_element_window();
void set_flags() { }
template<typename T, typename... Args>
void set_flags(T val, Args... args) {
switch(val) {
case borders::top: top =true; break;
case borders::bottom: bottom=true; break;
case borders::left: left =true; break;
case borders::right: right =true; break;
}
set_flags(args...);
}
public:
template<typename... Boarders>
bordered(unique_window_ptr handle_, Boarders... b)
: frame_ { std::move(handle_) }
{
set_flags(b...);
}
template<typename ElementType, typename... Args>
ElementType& emplace_element(Args&&...additional_args) {
auto element_fill=util::make_unique<ElementType>(
make_element_window(),
std::forward<Args>(additional_args)...
);
auto raw_ptr=element_fill.get();
element=std::move(element_fill);
return *raw_ptr;
}
//Overrides
void clear() override;
void refresh() override;
void set_position(const point& position) override;
void set_dimension(const point& dimension) override;
point get_position() const override;
point get_dimension() const override;
unique_window_ptr reset(unique_window_ptr handle) override;
//Colours
void set_background(short bg);
void set_foreground(short fg);
short get_background() const;
short get_foreground() const;
}; //class border
} //namespace cons
#endif //BOARDERED_HPP
| 27.594937 | 61 | 0.668807 | dobson156 |
eef62976daacda72254ac6c0b8dddbf301a56545 | 30,140 | cc | C++ | tools/cddl/parse.cc | gtalis/openscreen | 9b28b9695df98d310c2271eaa65d20cc6d224203 | [
"BSD-3-Clause"
] | 1 | 2020-09-22T05:59:36.000Z | 2020-09-22T05:59:36.000Z | tools/cddl/parse.cc | gtalis/openscreen | 9b28b9695df98d310c2271eaa65d20cc6d224203 | [
"BSD-3-Clause"
] | null | null | null | tools/cddl/parse.cc | gtalis/openscreen | 9b28b9695df98d310c2271eaa65d20cc6d224203 | [
"BSD-3-Clause"
] | 1 | 2022-02-03T11:05:44.000Z | 2022-02-03T11:05:44.000Z | // Copyright 2018 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "tools/cddl/parse.h"
#include <unistd.h>
#include <algorithm>
#include <iostream>
#include <memory>
#include <sstream>
#include <vector>
#include "absl/strings/ascii.h"
#include "absl/strings/match.h"
#include "absl/types/optional.h"
#include "tools/cddl/logging.h"
static_assert(sizeof(absl::string_view::size_type) == sizeof(size_t),
"We assume string_view's size_type is the same as size_t. If "
"not, the following file needs to be refactored");
// All of the parsing methods in this file that operate on Parser are named
// either Parse* or Skip* and are named according to the CDDL grammar in
// grammar.abnf. Similarly, methods like ParseMemberKey1 attempt to parse the
// first choice in the memberkey rule.
struct Parser {
Parser(const Parser&) = delete;
Parser& operator=(const Parser&) = delete;
const char* data;
std::vector<std::unique_ptr<AstNode>> nodes;
};
AstNode* AddNode(Parser* p,
AstNode::Type type,
absl::string_view text,
AstNode* children = nullptr) {
p->nodes.emplace_back(new AstNode);
AstNode* node = p->nodes.back().get();
node->children = children;
node->sibling = nullptr;
node->type = type;
node->text = std::string(text);
return node;
}
bool IsBinaryDigit(char x) {
return '0' == x || x == '1';
}
// Determines if the given character matches regex '[a-zA-Z@_$]'.
bool IsExtendedAlpha(char x) {
return absl::ascii_isalpha(x) || x == '@' || x == '_' || x == '$';
}
bool IsNewline(char x) {
return x == '\r' || x == '\n';
}
bool IsWhitespaceOrSemicolon(char c) {
return c == ' ' || c == ';' || c == '\r' || c == '\n';
}
absl::string_view SkipNewline(absl::string_view view) {
size_t index = 0;
while (IsNewline(view[index])) {
++index;
}
return view.substr(index);
}
// Skips over a comment that makes up the remainder of the current line.
absl::string_view SkipComment(absl::string_view view) {
size_t index = 0;
if (view[index] == ';') {
++index;
while (!IsNewline(view[index]) && index < view.length()) {
CHECK(absl::ascii_isprint(view[index]));
++index;
}
while (IsNewline(view[index])) {
++index;
}
}
return view.substr(index);
}
void SkipWhitespace(Parser* p, bool skip_comments = true) {
if (!skip_comments) {
p->data = absl::StripLeadingAsciiWhitespace(p->data).data();
return;
}
absl::string_view view = p->data;
absl::string_view new_view;
while (true) {
new_view = SkipComment(view);
if (new_view.data() == view.data()) {
new_view = absl::StripLeadingAsciiWhitespace(view);
}
if (new_view == view) {
break;
}
view = new_view;
}
p->data = new_view.data();
}
bool TrySkipNewline(Parser* p) {
auto* new_view = SkipNewline(p->data).data();
bool is_changed = p->data == new_view;
p->data = new_view;
return is_changed;
}
bool TrySkipCharacter(Parser* p, char c) {
if (p->data[0] == c) {
p->data++;
return true;
}
return false;
}
enum class AssignType {
kInvalid = -1,
kAssign,
kAssignT,
kAssignG,
};
AssignType ParseAssignmentType(Parser* p) {
const char* it = p->data;
if (it[0] == '=') {
p->data = it + 1;
return AssignType::kAssign;
} else if (it[0] == '/') {
++it;
if (it[0] == '/' && it[1] == '=') {
p->data = it + 2;
return AssignType::kAssignG;
} else if (it[0] == '=') {
p->data = it + 1;
return AssignType::kAssignT;
}
}
return AssignType::kInvalid;
}
AstNode* ParseType1(Parser* p);
AstNode* ParseType(Parser* p, bool skip_comments = true);
AstNode* ParseId(Parser* p);
void SkipUint(Parser* p) {
absl::string_view view = p->data;
bool is_binary = false;
size_t index = 0;
if (absl::StartsWith(view, "0b")) {
is_binary = true;
index = 2;
} else if (absl::StartsWith(view, "0x")) {
index = 2;
}
while (index < view.length() && absl::ascii_isdigit(view[index])) {
if (is_binary) {
CHECK(IsBinaryDigit(view[index]));
}
++index;
}
p->data = view.substr(index).data();
}
AstNode* ParseNumber(Parser* p) {
Parser p_speculative{p->data};
if (!absl::ascii_isdigit(p_speculative.data[0]) &&
p_speculative.data[0] != '-') {
// TODO(btolsch): Add support for hexfloat, fraction, exponent.
return nullptr;
}
if (p_speculative.data[0] == '-') {
++p_speculative.data;
}
SkipUint(&p_speculative);
AstNode* node =
AddNode(p, AstNode::Type::kNumber,
absl::string_view(p->data, p_speculative.data - p->data));
p->data = p_speculative.data;
std::move(p_speculative.nodes.begin(), p_speculative.nodes.end(),
std::back_inserter(p->nodes));
return node;
}
AstNode* ParseText(Parser* p) {
return nullptr;
}
AstNode* ParseBytes(Parser* p) {
return nullptr;
}
// Returns whether |c| could be the first character in a valid "value" string.
// This is not a guarantee however, since 'h' and 'b' could also indicate the
// start of an ID, but value needs to be tried first.
bool IsValue(char c) {
return (c == '-' || absl::ascii_isdigit(c) || // FIRST(number)
c == '"' || // FIRST(text)
c == '\'' || c == 'h' || c == 'b'); // FIRST(bytes)
}
AstNode* ParseValue(Parser* p) {
AstNode* node = ParseNumber(p);
if (!node) {
node = ParseText(p);
}
if (!node) {
ParseBytes(p);
}
return node;
}
// Determines whether an occurrence operator (such as '*' or '?') prefacing
// the group definition occurs before the next whitespace character, and
// creates a new Occurrence node if so.
AstNode* ParseOccur(Parser* p) {
Parser p_speculative{p->data};
if (*p_speculative.data == '?' || *p_speculative.data == '+') {
p_speculative.data++;
} else {
SkipUint(&p_speculative);
if (*p_speculative.data++ != '*') {
return nullptr;
}
SkipUint(&p_speculative);
}
AstNode* node =
AddNode(p, AstNode::Type::kOccur,
absl::string_view(p->data, p_speculative.data - p->data));
p->data = p_speculative.data;
return node;
}
absl::optional<std::string> ParseTypeKeyFromComment(Parser* p) {
Parser p_speculative{p->data};
if (!TrySkipCharacter(&p_speculative, ';')) {
return absl::nullopt;
}
SkipWhitespace(&p_speculative, false);
const char kTypeKeyPrefix[] = "type key";
if (!absl::StartsWith(p_speculative.data, kTypeKeyPrefix)) {
return absl::nullopt;
}
p_speculative.data += strlen(kTypeKeyPrefix);
SkipWhitespace(&p_speculative, false);
Parser p_speculative2{p_speculative.data};
for (; absl::ascii_isdigit(p_speculative2.data[0]); p_speculative2.data++) {
}
auto result = absl::string_view(p_speculative.data,
p_speculative2.data - p_speculative.data);
p->data = p_speculative2.data;
return std::string(result.data()).substr(0, result.length());
}
AstNode* ParseMemberKeyFromComment(Parser* p) {
Parser p_speculative{p->data};
if (!TrySkipCharacter(&p_speculative, ';')) {
return nullptr;
}
SkipWhitespace(&p_speculative, false);
AstNode* value = ParseId(&p_speculative);
if (!value) {
return nullptr;
}
SkipWhitespace(&p_speculative, false);
if (!TrySkipNewline(&p_speculative)) {
return nullptr;
}
AstNode* node = AddNode(p, AstNode::Type::kMemberKey, value->text, value);
p->data = p_speculative.data;
std::move(p_speculative.nodes.begin(), p_speculative.nodes.end(),
std::back_inserter(p->nodes));
return node;
}
AstNode* ParseMemberKey1(Parser* p) {
Parser p_speculative{p->data};
if (!ParseType1(&p_speculative)) {
return nullptr;
}
SkipWhitespace(&p_speculative);
if (*p_speculative.data++ != '=' || *p_speculative.data++ != '>') {
return nullptr;
}
AstNode* node =
AddNode(p, AstNode::Type::kMemberKey,
absl::string_view(p->data, p_speculative.data - p->data));
p->data = p_speculative.data;
std::move(p_speculative.nodes.begin(), p_speculative.nodes.end(),
std::back_inserter(p->nodes));
return node;
}
AstNode* ParseMemberKey2(Parser* p) {
Parser p_speculative{p->data};
AstNode* id = ParseId(&p_speculative);
if (!id) {
return nullptr;
}
SkipWhitespace(&p_speculative);
if (*p_speculative.data++ != ':') {
return nullptr;
}
AstNode* node =
AddNode(p, AstNode::Type::kMemberKey,
absl::string_view(p->data, p_speculative.data - p->data), id);
p->data = p_speculative.data;
std::move(p_speculative.nodes.begin(), p_speculative.nodes.end(),
std::back_inserter(p->nodes));
return node;
}
AstNode* ParseMemberKey3(Parser* p) {
Parser p_speculative{p->data};
AstNode* value = ParseValue(&p_speculative);
if (!value) {
return nullptr;
}
SkipWhitespace(&p_speculative);
if (*p_speculative.data++ != ':') {
return nullptr;
}
AstNode* node =
AddNode(p, AstNode::Type::kMemberKey,
absl::string_view(p->data, p_speculative.data - p->data), value);
p->data = p_speculative.data;
std::move(p_speculative.nodes.begin(), p_speculative.nodes.end(),
std::back_inserter(p->nodes));
return node;
}
// Iteratively tries all valid member key formats, retuning a Node representing
// the member key if found or nullptr if not.
AstNode* ParseMemberKey(Parser* p) {
AstNode* node = ParseMemberKey1(p);
if (!node) {
node = ParseMemberKey2(p);
}
if (!node) {
node = ParseMemberKey3(p);
}
return node;
}
AstNode* ParseGroupEntry(Parser* p);
bool SkipOptionalComma(Parser* p) {
SkipWhitespace(p);
if (p->data[0] == ',') {
++p->data;
SkipWhitespace(p);
}
return true;
}
// Parse the group contained inside of other brackets. Since the brackets around
// the group are optional inside of other brackets, we can't directly call
// ParseGroupEntry(...) and instead need this wrapper around it.
AstNode* ParseGroupChoice(Parser* p) {
Parser p_speculative{p->data};
AstNode* tail = nullptr;
AstNode* group_node =
AddNode(&p_speculative, AstNode::Type::kGrpchoice, absl::string_view());
const char* group_node_text = p_speculative.data;
while (true) {
const char* orig = p_speculative.data;
AstNode* group_entry = ParseGroupEntry(&p_speculative);
if (!group_entry) {
p_speculative.data = orig;
if (!group_node->children) {
return nullptr;
}
group_node->text =
std::string(group_node_text, p_speculative.data - group_node_text);
p->data = p_speculative.data;
std::move(p_speculative.nodes.begin(), p_speculative.nodes.end(),
std::back_inserter(p->nodes));
return group_node;
}
if (!group_node->children) {
group_node->children = group_entry;
}
if (tail) {
tail->sibling = group_entry;
}
tail = group_entry;
if (!SkipOptionalComma(&p_speculative)) {
return nullptr;
}
}
return nullptr;
}
AstNode* ParseGroup(Parser* p) {
const char* orig = p->data;
AstNode* group_choice = ParseGroupChoice(p);
if (!group_choice) {
return nullptr;
}
return AddNode(p, AstNode::Type::kGroup,
absl::string_view(orig, p->data - orig), group_choice);
}
// Parse optional range operator .. (inlcusive) or ... (exclusive)
// ABNF rule: rangeop = "..." / ".."
AstNode* ParseRangeop(Parser* p) {
absl::string_view view(p->data);
if (absl::StartsWith(view, "...")) {
// rangeop ...
p->data += 3;
return AddNode(p, AstNode::Type::kRangeop, view.substr(0, 3));
} else if (absl::StartsWith(view, "..")) {
// rangeop ..
p->data += 2;
return AddNode(p, AstNode::Type::kRangeop, view.substr(0, 2));
}
return nullptr;
}
// Parse optional control operator .id
// ABNF rule: ctlop = "." id
AstNode* ParseCtlop(Parser* p) {
absl::string_view view(p->data);
if (!absl::StartsWith(view, ".")) {
return nullptr;
}
++p->data;
AstNode* id = ParseId(p);
if (!id) {
return nullptr;
}
return AddNode(p, AstNode::Type::kCtlop,
view.substr(0, p->data - view.begin()), id);
}
AstNode* ParseType2(Parser* p) {
const char* orig = p->data;
const char* it = p->data;
AstNode* node = AddNode(p, AstNode::Type::kType2, absl::string_view());
if (IsValue(it[0])) {
AstNode* value = ParseValue(p);
if (!value) {
if (it[0] == 'h' || it[0] == 'b') {
AstNode* id = ParseId(p);
if (!id) {
return nullptr;
}
id->type = AstNode::Type::kTypename;
node->children = id;
} else {
return nullptr;
}
} else {
node->children = value;
}
} else if (IsExtendedAlpha(it[0])) {
AstNode* id = ParseId(p);
if (!id) {
return nullptr;
}
if (p->data[0] == '<') {
std::cerr << "It looks like you're trying to use a generic argument, "
"which we don't support"
<< std::endl;
return nullptr;
}
id->type = AstNode::Type::kTypename;
node->children = id;
} else if (it[0] == '(') {
p->data = it + 1;
SkipWhitespace(p);
if (p->data[0] == ')') {
std::cerr << "It looks like you're trying to provide an empty Type (), "
"which we don't support"
<< std::endl;
return nullptr;
}
AstNode* type = ParseType(p);
if (!type) {
return nullptr;
}
SkipWhitespace(p);
if (p->data[0] != ')') {
return nullptr;
}
++p->data;
node->children = type;
} else if (it[0] == '{') {
p->data = it + 1;
SkipWhitespace(p);
if (p->data[0] == '}') {
std::cerr << "It looks like you're trying to provide an empty Group {}, "
"which we don't support"
<< std::endl;
return nullptr;
}
AstNode* group = ParseGroup(p);
if (!group) {
return nullptr;
}
SkipWhitespace(p);
if (p->data[0] != '}') {
return nullptr;
}
++p->data;
node->children = group;
} else if (it[0] == '[') {
p->data = it + 1;
SkipWhitespace(p);
AstNode* group = ParseGroup(p);
if (!group) {
return nullptr;
}
SkipWhitespace(p);
if (p->data[0] != ']') {
return nullptr;
}
++p->data;
node->children = group;
} else if (it[0] == '~') {
p->data = it + 1;
SkipWhitespace(p);
if (!ParseId(p)) {
return nullptr;
}
if (p->data[0] == '<') {
std::cerr << "It looks like you're trying to use a generic argument, "
"which we don't support"
<< std::endl;
return nullptr;
}
} else if (it[0] == '&') {
p->data = it + 1;
SkipWhitespace(p);
if (p->data[0] == '(') {
++p->data;
SkipWhitespace(p);
if (p->data[0] == ')') {
std::cerr << "It looks like you're trying to provide an empty Type &(),"
" which we don't support"
<< std::endl;
return nullptr;
}
AstNode* group = ParseGroup(p);
if (!group) {
return nullptr;
}
SkipWhitespace(p);
if (p->data[0] != ')') {
return nullptr;
}
++p->data;
node->children = group;
} else {
AstNode* id = ParseId(p);
if (id) {
if (p->data[0] == '<') {
std::cerr << "It looks like you're trying to use a generic argument, "
"which we don't support"
<< std::endl;
return nullptr;
}
id->type = AstNode::Type::kGroupname;
node->children = id;
} else {
return nullptr;
}
}
} else if (it[0] == '#') {
++it;
if (it[0] == '6') {
++it;
if (it[0] == '.') {
p->data = it + 1;
SkipUint(p);
it = p->data;
}
if (it[0] != '(') {
return nullptr;
}
p->data = ++it;
SkipWhitespace(p);
AstNode* type = ParseType(p);
if (!type) {
return nullptr;
}
SkipWhitespace(p);
if (p->data[0] != ')') {
return nullptr;
}
++p->data;
node->children = type;
} else if (absl::ascii_isdigit(it[0])) {
std::cerr << "# MAJOR unimplemented" << std::endl;
return nullptr;
} else {
p->data = it;
}
} else {
return nullptr;
}
node->text = std::string(orig, p->data - orig);
return node;
}
AstNode* ParseType1(Parser* p) {
const char* orig = p->data;
AstNode* type2 = ParseType2(p);
if (!type2) {
return nullptr;
}
SkipWhitespace(p, false);
AstNode* rangeop_or_ctlop = ParseRangeop(p);
if (!rangeop_or_ctlop) {
rangeop_or_ctlop = ParseCtlop(p);
}
if (rangeop_or_ctlop) {
SkipWhitespace(p, false);
AstNode* param = ParseType2(p);
if (!param) {
return nullptr;
}
type2->sibling = rangeop_or_ctlop;
rangeop_or_ctlop->sibling = param;
}
return AddNode(p, AstNode::Type::kType1,
absl::string_view(orig, p->data - orig), type2);
}
// Different valid types for a call are specified as type1 / type2, so we split
// at the '/' character and process each allowed type separately.
AstNode* ParseType(Parser* p, bool skip_comments) {
Parser p_speculative{p->data};
// Parse all allowed types into a linked list starting in type1's sibling ptr.
AstNode* type1 = ParseType1(&p_speculative);
if (!type1) {
return nullptr;
}
SkipWhitespace(&p_speculative, skip_comments);
AstNode* tail = type1;
while (*p_speculative.data == '/') {
++p_speculative.data;
SkipWhitespace(&p_speculative, skip_comments);
AstNode* next_type1 = ParseType1(&p_speculative);
if (!next_type1) {
return nullptr;
}
tail->sibling = next_type1;
tail = next_type1;
SkipWhitespace(&p_speculative, skip_comments);
}
// Create a new AstNode with all parsed types.
AstNode* node =
AddNode(p, AstNode::Type::kType,
absl::string_view(p->data, p_speculative.data - p->data), type1);
p->data = p_speculative.data;
std::move(p_speculative.nodes.begin(), p_speculative.nodes.end(),
std::back_inserter(p->nodes));
return node;
}
AstNode* ParseId(Parser* p) {
const char* id = p->data;
// If the id doesnt start with a valid name character, return null.
if (!IsExtendedAlpha(id[0])) {
return nullptr;
}
// Read through the name character by character and make sure it's valid.
const char* it = id + 1;
while (true) {
if (it[0] == '-' || it[0] == '.') {
++it;
if (!IsExtendedAlpha(it[0]) && !absl::ascii_isdigit(it[0])) {
return nullptr;
}
++it;
} else if (IsExtendedAlpha(it[0]) || absl::ascii_isdigit(it[0])) {
++it;
} else {
break;
}
}
// Create and return a new node with the parsed data.
AstNode* node =
AddNode(p, AstNode::Type::kId, absl::string_view(p->data, it - p->data));
p->data = it;
return node;
}
AstNode* UpdateNodesForGroupEntry(Parser* p,
Parser* p_speculative,
AstNode* occur,
AstNode* member_key,
AstNode* type) {
AstNode* node = AddNode(p, AstNode::Type::kGrpent, absl::string_view());
if (occur) {
node->children = occur;
if (member_key) {
occur->sibling = member_key;
member_key->sibling = type;
} else {
occur->sibling = type;
}
} else if (member_key) {
node->children = member_key;
member_key->sibling = type;
} else {
node->children = type;
}
node->text = std::string(p->data, p_speculative->data - p->data);
p->data = p_speculative->data;
std::move(p_speculative->nodes.begin(), p_speculative->nodes.end(),
std::back_inserter(p->nodes));
return node;
}
// Parse a group entry of form <id_num>: <type> ; <name>
AstNode* ParseGroupEntryWithNameInComment(Parser* p) {
Parser p_speculative{p->data};
AstNode* occur = ParseOccur(&p_speculative);
if (occur) {
SkipWhitespace(&p_speculative, false);
}
AstNode* member_key_num = ParseValue(&p_speculative);
if (!member_key_num) {
return nullptr;
}
SkipWhitespace(&p_speculative, false);
if (*p_speculative.data++ != ':') {
return nullptr;
}
SkipWhitespace(&p_speculative, false);
AstNode* type = ParseType(&p_speculative, false);
if (!type) {
return nullptr;
}
SkipWhitespace(&p_speculative, false);
AstNode* member_key = ParseMemberKeyFromComment(&p_speculative);
if (!member_key) {
return nullptr;
}
member_key->integer_member_key_text = member_key_num->text;
return UpdateNodesForGroupEntry(p, &p_speculative, occur, member_key, type);
}
AstNode* ParseGroupEntryWithNameAsId(Parser* p) {
Parser p_speculative{p->data};
AstNode* occur = ParseOccur(&p_speculative);
if (occur) {
SkipWhitespace(&p_speculative);
}
AstNode* member_key = ParseMemberKey(&p_speculative);
if (member_key) {
SkipWhitespace(&p_speculative);
}
AstNode* type = ParseType(&p_speculative);
if (!type) {
return nullptr;
}
return UpdateNodesForGroupEntry(p, &p_speculative, occur, member_key, type);
}
// NOTE: This should probably never be hit, why is it in the grammar?
AstNode* ParseGroupEntryWithGroupReference(Parser* p) {
Parser p_speculative{p->data};
// Check for an occurance indicator ('?', '*', "+") before the sub-group
// definition.
AstNode* occur = ParseOccur(&p_speculative);
if (occur) {
SkipWhitespace(&p_speculative);
}
// Parse the ID of the sub-group.
AstNode* id = ParseId(&p_speculative);
if (!id) {
return nullptr;
}
id->type = AstNode::Type::kGroupname;
if (*p_speculative.data == '<') {
std::cerr << "It looks like you're trying to use a generic argument, "
"which we don't support"
<< std::endl;
return nullptr;
}
// Create a new node containing this sub-group reference.
AstNode* node = AddNode(p, AstNode::Type::kGrpent, absl::string_view());
if (occur) {
occur->sibling = id;
node->children = occur;
} else {
node->children = id;
}
node->text = std::string(p->data, p_speculative.data - p->data);
p->data = p_speculative.data;
std::move(p_speculative.nodes.begin(), p_speculative.nodes.end(),
std::back_inserter(p->nodes));
return node;
}
// Recursively parse a group entry that's an inline-defined group of the form
// '(...<some contents>...)'.
AstNode* ParseGroupEntryWithInlineGroupDefinition(Parser* p) {
Parser p_speculative{p->data};
AstNode* occur = ParseOccur(&p_speculative);
if (occur) {
SkipWhitespace(&p_speculative);
}
if (*p_speculative.data != '(') {
return nullptr;
}
++p_speculative.data;
SkipWhitespace(&p_speculative);
AstNode* group = ParseGroup(&p_speculative); // Recursive call here.
if (!group) {
return nullptr;
}
SkipWhitespace(&p_speculative);
if (*p_speculative.data != ')') {
return nullptr;
}
++p_speculative.data;
AstNode* node = AddNode(p, AstNode::Type::kGrpent, absl::string_view());
if (occur) {
node->children = occur;
occur->sibling = group;
} else {
node->children = group;
}
node->text = std::string(p->data, p_speculative.data - p->data);
p->data = p_speculative.data;
std::move(p_speculative.nodes.begin(), p_speculative.nodes.end(),
std::back_inserter(p->nodes));
return node;
}
// Recursively parse the group assignemnt.
AstNode* ParseGroupEntry(Parser* p) {
// Parse a group entry of form '#: type ; name'
AstNode* node = ParseGroupEntryWithNameInComment(p);
// Parse a group entry of form 'id: type'.
if (!node) {
node = ParseGroupEntryWithNameAsId(p);
}
// Parse a group entry of form 'subgroupName'.
if (!node) {
node = ParseGroupEntryWithGroupReference(p);
}
// Parse a group entry of the form: '(' <some contents> ')'.
// NOTE: This is the method hit during the top-level group parsing, and the
// recursive call occurs inside this method.
if (!node) {
node = ParseGroupEntryWithInlineGroupDefinition(p);
}
// Return the results of the recursive call.
return node;
}
AstNode* ParseRule(Parser* p) {
const char* start = p->data;
// Parse the type key, if it's present
absl::optional<std::string> type_key = ParseTypeKeyFromComment(p);
SkipWhitespace(p);
// Use the parser to extract the id and data.
AstNode* id = ParseId(p);
if (!id) {
Logger::Error("No id found!");
return nullptr;
}
if (p->data[0] == '<') {
std::cerr << "It looks like you're trying to use a generic parameter, "
"which we don't support"
<< std::endl;
return nullptr;
}
// Determine the type of assignment being done to this variable name (ie '=').
SkipWhitespace(p);
const char* assign_start = p->data;
AssignType assign_type = ParseAssignmentType(p);
if (assign_type != AssignType::kAssign) {
Logger::Error("No assignment operator found! assign_type: %d", assign_type);
return nullptr;
}
AstNode* assign_node = AddNode(
p,
(assign_type == AssignType::kAssign)
? AstNode::Type::kAssign
: (assign_type == AssignType::kAssignT) ? AstNode::Type::kAssignT
: AstNode::Type::kAssignG,
absl::string_view(assign_start, p->data - assign_start));
id->sibling = assign_node;
// Parse the object type being assigned.
SkipWhitespace(p);
AstNode* type = ParseType(p, false); // Try to parse it as a type.
id->type = AstNode::Type::kTypename;
if (!type) { // If it's not a type, try and parse it as a group.
type = ParseGroupEntry(p);
id->type = AstNode::Type::kGroupname;
}
if (!type) { // if it's not a type or a group, exit as failure.
Logger::Error("No node type found!");
return nullptr;
}
assign_node->sibling = type;
SkipWhitespace(p, false);
// Return the results.
auto rule_node = AddNode(p, AstNode::Type::kRule,
absl::string_view(start, p->data - start), id);
rule_node->type_key = type_key;
return rule_node;
}
// Iteratively parse the CDDL spec into a tree structure.
ParseResult ParseCddl(absl::string_view data) {
if (data[0] == 0) {
return {nullptr, {}};
}
Parser p{(char*)data.data()};
SkipWhitespace(&p);
AstNode* root = nullptr;
AstNode* tail = nullptr;
do {
AstNode* next = ParseRule(&p);
if (!next) {
Logger::Error("Failed to parse next node. Failed starting at: '%s'",
p.data);
return {nullptr, {}};
} else {
Logger::Log("Processed text \"%s\" into node: ", next->text);
DumpAst(next);
}
if (!root) {
root = next;
}
if (tail) {
tail->sibling = next;
}
tail = next;
} while (p.data[0]);
return {root, std::move(p.nodes)};
}
// Recursively print out the AstNode graph.
void DumpAst(AstNode* node, int indent_level) {
while (node) {
// Prefix with '-'s so the levels of the graph are clear.
std::string node_text = "";
for (int i = 0; i <= indent_level; ++i) {
node_text += "--";
}
// Print the type.
switch (node->type) {
case AstNode::Type::kRule:
node_text += "kRule";
break;
case AstNode::Type::kTypename:
node_text += "kTypename";
break;
case AstNode::Type::kGroupname:
node_text += "kGroupname";
break;
case AstNode::Type::kAssign:
node_text += "kAssign";
break;
case AstNode::Type::kAssignT:
node_text += "kAssignT";
break;
case AstNode::Type::kAssignG:
node_text += "kAssignG";
break;
case AstNode::Type::kType:
node_text += "kType";
break;
case AstNode::Type::kGrpent:
node_text += "kGrpent";
break;
case AstNode::Type::kType1:
node_text += "kType1";
break;
case AstNode::Type::kType2:
node_text += "kType2";
break;
case AstNode::Type::kValue:
node_text += "kValue";
break;
case AstNode::Type::kGroup:
node_text += "kGroup";
break;
case AstNode::Type::kUint:
node_text += "kUint";
break;
case AstNode::Type::kDigit:
node_text += "kDigit";
break;
case AstNode::Type::kRangeop:
node_text += "kRangeop";
break;
case AstNode::Type::kCtlop:
node_text += "kCtlop";
break;
case AstNode::Type::kGrpchoice:
node_text += "kGrpchoice";
break;
case AstNode::Type::kOccur:
node_text += "kOccur";
break;
case AstNode::Type::kMemberKey:
node_text += "kMemberKey";
break;
case AstNode::Type::kId:
node_text += "kId";
break;
case AstNode::Type::kNumber:
node_text += "kNumber";
break;
case AstNode::Type::kText:
node_text += "kText";
break;
case AstNode::Type::kBytes:
node_text += "kBytes";
break;
case AstNode::Type::kOther:
node_text += "kOther";
break;
}
if (node->type_key != absl::nullopt) {
node_text += " (type key=\"" + node->type_key.value() + "\")";
}
node_text += ": ";
// Print the contents.
int size = static_cast<int>(node->text.size());
absl::string_view text = node->text.data();
for (int i = 0; i < size; ++i) {
if (text[i] == ' ' || text[i] == '\n') {
node_text += " ";
while (i < size - 1 && (text[i + 1] == ' ' || text[i + 1] == '\n')) {
++i;
}
continue;
} else {
node_text += text[i];
}
}
Logger::Log(node_text);
// Recursively print children then iteratively print siblings.
DumpAst(node->children, indent_level + 1);
node = node->sibling;
}
}
| 27.055655 | 80 | 0.594758 | gtalis |
eef6b8619dfa29eef8ca4341b43f7ed480f3349f | 8,563 | hpp | C++ | src/model/FuelFactors.hpp | muehleisen/OpenStudio | 3bfe89f6c441d1e61e50b8e94e92e7218b4555a0 | [
"blessing"
] | 354 | 2015-01-10T17:46:11.000Z | 2022-03-29T10:00:00.000Z | src/model/FuelFactors.hpp | muehleisen/OpenStudio | 3bfe89f6c441d1e61e50b8e94e92e7218b4555a0 | [
"blessing"
] | 3,243 | 2015-01-02T04:54:45.000Z | 2022-03-31T17:22:22.000Z | src/model/FuelFactors.hpp | muehleisen/OpenStudio | 3bfe89f6c441d1e61e50b8e94e92e7218b4555a0 | [
"blessing"
] | 157 | 2015-01-07T15:59:55.000Z | 2022-03-30T07:46:09.000Z | /***********************************************************************************************************************
* OpenStudio(R), Copyright (c) 2008-2021, Alliance for Sustainable Energy, LLC, and other contributors. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
* following conditions are met:
*
* (1) Redistributions of source code must retain the above copyright notice, this list of conditions and the following
* disclaimer.
*
* (2) Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided with the distribution.
*
* (3) Neither the name of the copyright holder nor the names of any contributors may be used to endorse or promote products
* derived from this software without specific prior written permission from the respective party.
*
* (4) Other than as required in clauses (1) and (2), distributions in any form of modifications or other derivative works
* may not use the "OpenStudio" trademark, "OS", "os", or any other confusingly similar designation without specific prior
* written permission from Alliance for Sustainable Energy, LLC.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) AND ANY CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER(S), ANY CONTRIBUTORS, THE UNITED STATES GOVERNMENT, OR THE UNITED
* STATES DEPARTMENT OF ENERGY, NOR ANY OF THEIR EMPLOYEES, BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
* USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
***********************************************************************************************************************/
#ifndef MODEL_FUELFACTORS_HPP
#define MODEL_FUELFACTORS_HPP
#include <model/ModelAPI.hpp>
#include "ModelObject.hpp"
namespace openstudio {
namespace model {
class Schedule;
namespace detail {
class FuelFactors_Impl;
} // namespace detail
/** FuelFactors is a ModelObject that wraps the OpenStudio IDD object 'OS:FuelFactors'. */
class MODEL_API FuelFactors : public ModelObject
{
public:
/** @name Constructors and Destructors */
//@{
explicit FuelFactors(const Model& model);
virtual ~FuelFactors() {}
//@}
static IddObjectType iddObjectType();
static std::vector<std::string> existingFuelResourceNameValues();
/** @name Getters */
//@{
std::string existingFuelResourceName() const;
double sourceEnergyFactor() const;
boost::optional<Schedule> sourceEnergySchedule() const;
double cO2EmissionFactor() const;
boost::optional<Schedule> cO2EmissionFactorSchedule() const;
double cOEmissionFactor() const;
boost::optional<Schedule> cOEmissionFactorSchedule() const;
double cH4EmissionFactor() const;
boost::optional<Schedule> cH4EmissionFactorSchedule() const;
double nOxEmissionFactor() const;
boost::optional<Schedule> nOxEmissionFactorSchedule() const;
double n2OEmissionFactor() const;
boost::optional<Schedule> n2OEmissionFactorSchedule() const;
double sO2EmissionFactor() const;
boost::optional<Schedule> sO2EmissionFactorSchedule() const;
double pMEmissionFactor() const;
boost::optional<Schedule> pMEmissionFactorSchedule() const;
double pM10EmissionFactor() const;
boost::optional<Schedule> pM10EmissionFactorSchedule() const;
double pM25EmissionFactor() const;
boost::optional<Schedule> pM25EmissionFactorSchedule() const;
double nH3EmissionFactor() const;
boost::optional<Schedule> nH3EmissionFactorSchedule() const;
double nMVOCEmissionFactor() const;
boost::optional<Schedule> nMVOCEmissionFactorSchedule() const;
double hgEmissionFactor() const;
boost::optional<Schedule> hgEmissionFactorSchedule() const;
double pbEmissionFactor() const;
boost::optional<Schedule> pbEmissionFactorSchedule() const;
double waterEmissionFactor() const;
boost::optional<Schedule> waterEmissionFactorSchedule() const;
double nuclearHighLevelEmissionFactor() const;
boost::optional<Schedule> nuclearHighLevelEmissionFactorSchedule() const;
double nuclearLowLevelEmissionFactor() const;
boost::optional<Schedule> nuclearLowLevelEmissionFactorSchedule() const;
//@}
/** @name Setters */
//@{
bool setExistingFuelResourceName(const std::string& existingFuelResourceName);
bool setSourceEnergyFactor(double sourceEnergyFactor);
bool setSourceEnergySchedule(Schedule& schedule);
void resetSourceEnergySchedule();
bool setCO2EmissionFactor(double cO2EmissionFactor);
bool setCO2EmissionFactorSchedule(Schedule& schedule);
void resetCO2EmissionFactorSchedule();
bool setCOEmissionFactor(double cOEmissionFactor);
bool setCOEmissionFactorSchedule(Schedule& schedule);
void resetCOEmissionFactorSchedule();
bool setCH4EmissionFactor(double cH4EmissionFactor);
bool setCH4EmissionFactorSchedule(Schedule& schedule);
void resetCH4EmissionFactorSchedule();
bool setNOxEmissionFactor(double nOxEmissionFactor);
bool setNOxEmissionFactorSchedule(Schedule& schedule);
void resetNOxEmissionFactorSchedule();
bool setN2OEmissionFactor(double n2OEmissionFactor);
bool setN2OEmissionFactorSchedule(Schedule& schedule);
void resetN2OEmissionFactorSchedule();
bool setSO2EmissionFactor(double sO2EmissionFactor);
bool setSO2EmissionFactorSchedule(Schedule& schedule);
void resetSO2EmissionFactorSchedule();
bool setPMEmissionFactor(double pMEmissionFactor);
bool setPMEmissionFactorSchedule(Schedule& schedule);
void resetPMEmissionFactorSchedule();
bool setPM10EmissionFactor(double pM10EmissionFactor);
bool setPM10EmissionFactorSchedule(Schedule& schedule);
void resetPM10EmissionFactorSchedule();
bool setPM25EmissionFactor(double pM25EmissionFactor);
bool setPM25EmissionFactorSchedule(Schedule& schedule);
void resetPM25EmissionFactorSchedule();
bool setNH3EmissionFactor(double nH3EmissionFactor);
bool setNH3EmissionFactorSchedule(Schedule& schedule);
void resetNH3EmissionFactorSchedule();
bool setNMVOCEmissionFactor(double nMVOCEmissionFactor);
bool setNMVOCEmissionFactorSchedule(Schedule& schedule);
void resetNMVOCEmissionFactorSchedule();
bool setHgEmissionFactor(double hgEmissionFactor);
bool setHgEmissionFactorSchedule(Schedule& schedule);
void resetHgEmissionFactorSchedule();
bool setPbEmissionFactor(double pbEmissionFactor);
bool setPbEmissionFactorSchedule(Schedule& schedule);
void resetPbEmissionFactorSchedule();
bool setWaterEmissionFactor(double waterEmissionFactor);
bool setWaterEmissionFactorSchedule(Schedule& schedule);
void resetWaterEmissionFactorSchedule();
bool setNuclearHighLevelEmissionFactor(double nuclearHighLevelEmissionFactor);
bool setNuclearHighLevelEmissionFactorSchedule(Schedule& schedule);
void resetNuclearHighLevelEmissionFactorSchedule();
bool setNuclearLowLevelEmissionFactor(double nuclearLowLevelEmissionFactor);
bool setNuclearLowLevelEmissionFactorSchedule(Schedule& schedule);
void resetNuclearLowLevelEmissionFactorSchedule();
//@}
/** @name Other */
//@{
//@}
protected:
/// @cond
typedef detail::FuelFactors_Impl ImplType;
explicit FuelFactors(std::shared_ptr<detail::FuelFactors_Impl> impl);
friend class detail::FuelFactors_Impl;
friend class Model;
friend class IdfObject;
friend class openstudio::detail::IdfObject_Impl;
/// @endcond
private:
REGISTER_LOGGER("openstudio.model.FuelFactors");
};
/** \relates FuelFactors*/
typedef boost::optional<FuelFactors> OptionalFuelFactors;
/** \relates FuelFactors*/
typedef std::vector<FuelFactors> FuelFactorsVector;
} // namespace model
} // namespace openstudio
#endif // MODEL_FUELFACTORS_HPP
| 32.934615 | 125 | 0.745183 | muehleisen |
eef83394a8eae91eea5d49a63d9e11772aa01260 | 348,659 | cpp | C++ | libraries/Talkie/src/Vocab_US_Large.cpp | kgranat/nookduino-arduino | ac98c43cd7cba1485e9992f6b972b6a1683c975d | [
"CC0-1.0"
] | null | null | null | libraries/Talkie/src/Vocab_US_Large.cpp | kgranat/nookduino-arduino | ac98c43cd7cba1485e9992f6b972b6a1683c975d | [
"CC0-1.0"
] | null | null | null | libraries/Talkie/src/Vocab_US_Large.cpp | kgranat/nookduino-arduino | ac98c43cd7cba1485e9992f6b972b6a1683c975d | [
"CC0-1.0"
] | 1 | 2021-09-06T06:20:07.000Z | 2021-09-06T06:20:07.000Z | // Talkie library
// Copyright 2011 Peter Knight
// This code is released under GPLv2 license.
//
// Armin Joachimsmeyer 11/2018 converted to .c and .h files and made them unique.
//
// The following phrases are derived from VM61002/3/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 <Arduino.h>
// Numbers and letters from different ROMs
// Prefix sp2_ means from VM61002 ROM, sp3 from VM61003 ROM etc.
extern const uint8_t sp2_ZERO[] 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};
extern const uint8_t sp2_ONE[] 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};
extern const uint8_t sp2_TWO[] 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};
extern const uint8_t sp2_THREE[] 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};
extern const uint8_t sp2_FOUR[] 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};
extern const uint8_t sp2_FIVE[] 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};
extern const uint8_t sp2_SIX[] 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};
extern const uint8_t sp2_SEVEN[] 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};
extern const uint8_t sp2_EIGHT[] 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};
extern const uint8_t sp2_NINE[] 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};
extern const uint8_t sp2_TEN[] 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};
extern const uint8_t sp2_ELEVEN[] 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};
extern const uint8_t sp2_TWELVE[] 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};
extern const uint8_t sp2_THIR_[] 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};
extern const uint8_t sp2_FIF_[] 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};
extern const uint8_t sp2__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};
extern const uint8_t sp2_TWENTY[] 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};
extern const uint8_t sp2_HUNDRED[] 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};
extern const uint8_t sp2_THOUSAND[] 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};
extern const uint8_t sp3_ZERO[] 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};
extern const uint8_t sp3_ONE[] 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};
extern const uint8_t sp3_TWO[] 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};
extern const uint8_t sp3_THREE[] 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};
extern const uint8_t sp3_FOUR[] 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};
extern const uint8_t sp3_FIVE[] 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};
extern const uint8_t sp3_SIX[] 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};
extern const uint8_t sp3_SEVEN[] 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};
extern const uint8_t sp3_EIGHT[] 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};
extern const uint8_t sp3_NINE[] 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};
extern const uint8_t sp3_TEN[] 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};
extern const uint8_t sp3_ELEVEN[] 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};
extern const uint8_t sp3_TWELVE[] 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};
extern const uint8_t sp3_THIRTEEN[] 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};
extern const uint8_t sp3_FOURTEEN[] 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};
extern const uint8_t sp3_FIFTEEN[] 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};
extern const uint8_t sp3_SIXTEEN[] 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};
extern const uint8_t sp3_SEVENTEEN[] 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};
extern const uint8_t sp3_EIGHTEEN[] 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};
extern const uint8_t sp3_NINETEEN[] 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};
extern const uint8_t sp3_TWENTY[] 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};
extern const uint8_t sp3_THIRTY[] 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};
extern const uint8_t sp3_FOURTY[] 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};
extern const uint8_t sp3_FIFTY[] 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};
extern const uint8_t sp3_SIXTY[] 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};
extern const uint8_t sp3_SEVENTY[] 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};
extern const uint8_t sp3_EIGHTY[] 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};
extern const uint8_t sp3_NINETY[] 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};
extern const uint8_t sp3_HUNDRED[] 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};
extern const uint8_t sp3_THOUSAND[] 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};
extern const uint8_t sp3_MILLION[] 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};
extern const uint8_t sp2_A[] 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};
extern const uint8_t sp2_B[] 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};
extern const uint8_t sp2_C[] 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};
extern const uint8_t sp2_D[] 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};
extern const uint8_t sp2_E[] 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};
extern const uint8_t sp2_F[] 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};
extern const uint8_t sp2_G[] 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};
extern const uint8_t sp2_H[] 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};
extern const uint8_t sp2_I[] 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};
extern const uint8_t sp2_L[] 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};
extern const uint8_t sp2_J[] 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};
extern const uint8_t sp2_K[] 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};
extern const uint8_t sp2_M[] 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};
extern const uint8_t sp2_N[] 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};
extern const uint8_t sp2_O[] 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};
extern const uint8_t sp2_P[] 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};
extern const uint8_t sp2_Q[] 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};
extern const uint8_t sp2_R[] 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};
extern const uint8_t sp2_S[] 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};
extern const uint8_t sp2_T[] 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};
extern const uint8_t sp2_U[] 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};
extern const uint8_t sp2_V[] 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};
extern const uint8_t sp2_W[] 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};
extern const uint8_t sp2_X[] 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};
extern const uint8_t sp2_Y[] 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};
extern const uint8_t sp2_Z[] 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};
extern const uint8_t sp2_ALPHA[] 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};
extern const uint8_t sp2_BRAVO[] 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};
extern const uint8_t sp2_CHARLIE[] 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};
extern const uint8_t sp2_DELTA[] 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};
extern const uint8_t sp2_ECHO[] 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};
extern const uint8_t sp2_FOXTROT[] 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};
extern const uint8_t sp2_GOLF[] 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};
extern const uint8_t sp2_HENRY[] 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};
extern const uint8_t sp2_INDIA[] 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};
extern const uint8_t sp2_JULIET[] 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};
extern const uint8_t sp2_KILO[] 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};
extern const uint8_t sp2_LIMA[] 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};
extern const uint8_t sp2_MIKE[] 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};
extern const uint8_t sp2_NOVEMBER[] 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};
extern const uint8_t sp2_OSCAR[] 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};
extern const uint8_t sp2_PAPA[] 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};
extern const uint8_t sp2_QUEBEC[] 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};
extern const uint8_t sp2_ROMEO[] 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};
extern const uint8_t sp2_SIERRA[] 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};
extern const uint8_t sp2_TANGO[] 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};
extern const uint8_t sp2_UNIFORM[] 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};
extern const uint8_t sp2_VICTOR[] 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};
extern const uint8_t sp2_WHISKY[] 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};
extern const uint8_t sp2_XRAY[] 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};
extern const uint8_t sp2_YANKEE[] 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};
extern const uint8_t sp2_ZULU[] 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};
extern const uint8_t sp4_ALPHA[] 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};
extern const uint8_t sp4_BRAVO[] 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};
extern const uint8_t sp4_CHARLIE[] 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};
extern const uint8_t sp4_DELTA[] 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};
extern const uint8_t sp4_ECHO[] 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};
extern const uint8_t sp4_FOXTROT[] 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};
extern const uint8_t sp4_GOLF[] 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};
extern const uint8_t sp4_HOTEL[] 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};
extern const uint8_t sp4_INDIA[] 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};
extern const uint8_t sp4_JULIET[] 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};
extern const uint8_t sp4_KILO[] 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};
extern const uint8_t sp4_LIMA[] 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};
extern const uint8_t sp4_MIKE[] 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};
extern const uint8_t sp4_NOVEMBER[] 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};
extern const uint8_t sp4_OSCAR[] 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};
extern const uint8_t sp4_PAPA[] 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};
extern const uint8_t sp4_QUEBEC[] 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};
extern const uint8_t sp4_ROMEO[] 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};
extern const uint8_t sp4_SIERRA[] 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};
extern const uint8_t sp4_TANGO[] 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};
extern const uint8_t sp4_UNIFORM[] 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};
extern const uint8_t sp4_VICTOR[] 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};
extern const uint8_t sp4_WHISKEY[] 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};
extern const uint8_t sp4_XRAY[] 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};
extern const uint8_t sp4_ZULU[] 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};
extern const uint8_t sp4_ABEAN[] 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};
extern const uint8_t sp2_ABORT[] 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};
extern const uint8_t sp4_ABORT[] 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};
extern const uint8_t sp2_ABOUT[] 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};
extern const uint8_t sp5_ABOVE[] 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};
extern const uint8_t sp5_ACCELERATED[] 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};
extern const uint8_t sp5_ACKNOWLEDGE[] 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};
extern const uint8_t sp4_ACTION[] 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};
extern const uint8_t sp5_ADIS[] 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};
extern const uint8_t sp2_ADJUST[] 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};
extern const uint8_t sp4_ADVISE[] 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};
extern const uint8_t sp5_AERIAL[] 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};
extern const uint8_t sp3_AERIAL[] 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};
extern const uint8_t sp3_AFFIRMATIVE[] 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};
extern const uint8_t sp4_AFFIRMATIVE[] 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};
extern const uint8_t sp5_AIRCRAFT[] 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};
extern const uint8_t sp5_AIRPORT[] 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};
extern const uint8_t sp5_AIRSPEED[] 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};
extern const uint8_t sp3_AIR[] 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};
extern const uint8_t sp5_AIR_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};
extern const uint8_t sp2_ALERT[] 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};
extern const uint8_t sp4_ALERT[] 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};
extern const uint8_t sp2_ALL[] 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};
extern const uint8_t sp4_ALL[] 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};
extern const uint8_t sp3_ALOFT[] 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};
extern const uint8_t sp3_ALTERNATE[] 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};
extern const uint8_t sp5_ALTIMETER[] 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};
extern const uint8_t sp5_ALTITUDE[] 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};
extern const uint8_t sp2_AMPS[] 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};
extern const uint8_t sp2_AND[] 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};
extern const uint8_t sp3_AND[] 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};
extern const uint8_t sp4_AND[] 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};
extern const uint8_t sp3_ANSWER[] 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};
extern const uint8_t sp5_APPROACHES[] 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};
extern const uint8_t sp5_APPROACH[] 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};
extern const uint8_t sp2_AREA[] 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};
extern const uint8_t sp4_AREA[] 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};
extern const uint8_t sp5_ARRIVAL[] 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};
extern const uint8_t sp5_AS[] 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};
extern const uint8_t sp5_ATU[] 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};
extern const uint8_t sp2_AT[] 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};
extern const uint8_t sp3_AT[] 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};
extern const uint8_t sp2_AUTOMATIC[] 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};
extern const uint8_t sp5_AUTOPILOT[] 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};
extern const uint8_t sp3_A_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};
extern const uint8_t sp5_BANK[] 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};
extern const uint8_t sp5_BARKER[] 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};
extern const uint8_t sp4_BASE[] 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};
extern const uint8_t sp3_BELOW[] 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};
extern const uint8_t sp4_BELOW[] 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};
extern const uint8_t sp2_BETWEEN[] 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};
extern const uint8_t sp3_BLOWING[] 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};
extern const uint8_t sp5_BOOST[] 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};
extern const uint8_t sp5_BRAKE[] 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};
extern const uint8_t sp5_BREAKING[] 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};
extern const uint8_t sp2_BREAK[] 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};
extern const uint8_t sp3_BROKEN[] 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};
extern const uint8_t sp2_BUTTON[] 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};
extern const uint8_t sp3_BY[] 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};
extern const uint8_t sp5_CABIN[] 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};
extern const uint8_t sp2_CALIBRATE[] 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};
extern const uint8_t sp2_CALL[] 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};
extern const uint8_t sp5_CALL[] 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};
extern const uint8_t sp5_CALM[] 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};
extern const uint8_t sp2_CANCEL[] 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};
extern const uint8_t sp4_CANCEL[] 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};
extern const uint8_t sp2_CAUTION[] 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};
extern const uint8_t sp4_CAUTION[] 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};
extern const uint8_t sp3_CEILING[] 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};
extern const uint8_t sp5_CEILING[] 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};
extern const uint8_t sp3_CELCIUS[] 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};
extern const uint8_t sp4_CENTRE[] 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};
extern const uint8_t sp2_CHANGE[] 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};
extern const uint8_t sp2_CHECK[] 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};
extern const uint8_t sp4_CHECK[] 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};
extern const uint8_t sp4_CHECK_1[] 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};
extern const uint8_t sp2_CIRCUIT[] 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};
extern const uint8_t sp5_CLEARANCE[] 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};
extern const uint8_t sp5_CLEARANCE_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};
extern const uint8_t sp3_CLEAR[] 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};
extern const uint8_t sp5_CLIMB[] 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};
extern const uint8_t sp2_CLOCK[] 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};
extern const uint8_t sp4_CLOSE[] 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};
extern const uint8_t sp2_COMPLETE[] 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};
extern const uint8_t sp2_CONNECT[] 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};
extern const uint8_t sp4_CONTACT[] 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};
extern const uint8_t sp2_CONTROL[] 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};
extern const uint8_t sp4_CONTROL[] 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};
extern const uint8_t sp5_CONVERGING[] 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};
extern const uint8_t sp4_COURSE[] 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};
extern const uint8_t sp5_COWL[] 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};
extern const uint8_t sp2_CRANE[] 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};
extern const uint8_t sp5_CROCS[] 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};
extern const uint8_t sp5_CROSSWIND[] 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};
extern const uint8_t sp5_CRYSTALS[] 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};
extern const uint8_t sp3_CURRENT[] 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};
extern const uint8_t sp2_CYCLE[] 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};
extern const uint8_t sp5_CYCLE[] 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};
extern const uint8_t sp4_CYLINDER[] 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};
extern const uint8_t sp5_CYLINDER[] 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};
extern const uint8_t sp2_DANGER[] 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};
extern const uint8_t sp4_DANGER[] 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};
extern const uint8_t sp4_DECREASE[] 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};
extern const uint8_t sp3_DECREASING[] 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};
extern const uint8_t sp2_DEGREES[] 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};
extern const uint8_t sp3_DEGREES[] 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};
extern const uint8_t sp4_DEGREE[] 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};
extern const uint8_t sp5_DEGREE[] 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};
extern const uint8_t sp5_DEPARTURE[] 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};
extern const uint8_t sp5_DEPARTURE_1[] 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};
extern const uint8_t sp2_DEVICE[] 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};
extern const uint8_t sp2_DIRECTION[] 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};
extern const uint8_t sp2_DISPLAY[] 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};
extern const uint8_t sp3_DIVIDED[] 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};
extern const uint8_t sp5_DOORS[] 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};
extern const uint8_t sp5_DOWNWIND[] 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};
extern const uint8_t sp5_DOWN[] 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};
extern const uint8_t sp3_DRIZZLE[] 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};
extern const uint8_t sp4_D[] 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};
extern const uint8_t sp2_EAST[] 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};
extern const uint8_t sp3_EAST[] 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};
extern const uint8_t sp2_ELECTRICIAN[] 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};
extern const uint8_t sp5_ELEVATION[] 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};
extern const uint8_t sp4_EMERGENCY[] 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};
extern const uint8_t sp5_ENGINE[] 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};
extern const uint8_t sp2_ENTER[] 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};
extern const uint8_t sp3_EQUALS[] 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};
extern const uint8_t sp2_EQUAL[] 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};
extern const uint8_t sp4_ERROR2[] 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};
extern const uint8_t sp3_ERROR[] 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};
extern const uint8_t sp3_ESTIMATED[] 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};
extern const uint8_t sp5_ETA[] 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};
extern const uint8_t sp4_EVACUATE[] 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};
extern const uint8_t sp5_EVACUATION[] 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};
extern const uint8_t sp2_EXIT[] 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};
extern const uint8_t sp4_EXPECT[] 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};
extern const uint8_t sp4_FAILURE[] 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};
extern const uint8_t sp2_FAIL[] 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};
extern const uint8_t sp2_FARAD[] 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};
extern const uint8_t sp3_FARENHEIT[] 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};
extern const uint8_t sp2_FAST[] 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};
extern const uint8_t sp2_FEET[] 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};
extern const uint8_t sp4_FILED[] 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};
extern const uint8_t sp4_FINAL[] 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};
extern const uint8_t sp2_FIRE[] 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};
extern const uint8_t sp5_FLAK_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};
extern const uint8_t sp5_FLAME_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};
extern const uint8_t sp5_FLAPS[] 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};
extern const uint8_t sp5_FLIGHTWATCH[] 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};
extern const uint8_t sp5_FLIGHT[] 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};
extern const uint8_t sp5_FLIGHT_1[] 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};
extern const uint8_t sp2_FLOW[] 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};
extern const uint8_t sp3_FOG[] 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};
extern const uint8_t sp3_FOR[] 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};
extern const uint8_t sp4_FOR[] 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};
extern const uint8_t sp5_FREEDOM[] 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};
extern const uint8_t sp3_FREEZING[] 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};
extern const uint8_t sp2_FREQUENCY[] 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};
extern const uint8_t sp2_FROM[] 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};
extern const uint8_t sp4_FRONT[] 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};
extern const uint8_t sp5_FSS[] 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};
extern const uint8_t sp4_FUEL[] 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};
extern const uint8_t sp5_FUEL[] 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};
extern const uint8_t sp5_FULL[] 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};
extern const uint8_t sp5_GALLEY[] 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};
extern const uint8_t sp2_GALLONS[] 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};
extern const uint8_t sp2_GAP[] 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};
extern const uint8_t sp4_GAS[] 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};
extern const uint8_t sp2_GATE[] 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};
extern const uint8_t sp2_GAUGE[] 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};
extern const uint8_t sp5_GEAR[] 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};
extern const uint8_t sp4_GLIDE[] 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};
extern const uint8_t sp2_GO[] 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};
extern const uint8_t sp4_GREAT2[] 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};
extern const uint8_t sp4_GREAT[] 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};
extern const uint8_t sp3_GREENWICH[] 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};
extern const uint8_t sp2_GREEN[] 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};
extern const uint8_t sp3_GREEN[] 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};
extern const uint8_t sp5_GROUND[] 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};
extern const uint8_t sp4_GUNDISH[] 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};
extern const uint8_t sp3_GUSTING_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};
extern const uint8_t sp3_GUST[] 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};
extern const uint8_t sp3_HAIL[] 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};
extern const uint8_t sp4_HAVE[] 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};
extern const uint8_t sp3_HAZE[] 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};
extern const uint8_t sp5_HEADING[] 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};
extern const uint8_t sp3_HEAT[] 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};
extern const uint8_t sp3_HEAVY[] 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};
extern const uint8_t sp2_HERTZ[] 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};
extern const uint8_t sp4_HERTZ[] 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};
extern const uint8_t sp2_HIGH[] 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};
extern const uint8_t sp3_HIGH[] 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};
extern const uint8_t sp2_HOLD[] 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};
extern const uint8_t sp4_HOLD[] 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};
extern const uint8_t sp2_HOURS[] 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};
extern const uint8_t sp3_HOURS[] 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};
extern const uint8_t sp3_HOUR[] 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};
extern const uint8_t sp3_ICE[] 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};
extern const uint8_t sp4_ICING[] 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};
extern const uint8_t sp4_IDEMTIFY[] 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};
extern const uint8_t sp5_IDLE[] 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};
extern const uint8_t sp5_IFR[] 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};
extern const uint8_t sp5_IGNITE[] 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};
extern const uint8_t sp4_IGNITION[] 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};
extern const uint8_t sp5_ILS[] 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};
extern const uint8_t sp4_IMMEDIATELY[] 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};
extern const uint8_t sp5_INBOUND[] 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};
extern const uint8_t sp2_INCH[] 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};
extern const uint8_t sp5_INCREASE[] 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};
extern const uint8_t sp3_INCREASING[] 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};
extern const uint8_t sp3_INCREASING_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};
extern const uint8_t sp3_INDICATED[] 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};
extern const uint8_t sp5_INFLIGHT[] 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};
extern const uint8_t sp4_INFORMATION[] 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};
extern const uint8_t sp5_INNER[] 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};
extern const uint8_t sp2_INSPECTOR[] 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};
extern const uint8_t sp5_INSTRUMENTS[] 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};
extern const uint8_t sp2_INTRUDER[] 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};
extern const uint8_t sp3_IN[] 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};
extern const uint8_t sp2_IS[] 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};
extern const uint8_t sp3_IS[] 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};
extern const uint8_t sp4_IS[] 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};
extern const uint8_t sp4_KEY[] 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};
extern const uint8_t sp4_KNOTS[] 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};
extern const uint8_t sp5_LANDING[] 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};
extern const uint8_t sp5_LANDING_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};
extern const uint8_t sp3_LAND[] 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};
extern const uint8_t sp5_LAUNCH[] 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};
extern const uint8_t sp5_LEAN[] 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};
extern const uint8_t sp2_LEFT[] 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};
extern const uint8_t sp4_LEFT[] 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};
extern const uint8_t sp5_LEG[] 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};
extern const uint8_t sp3_LESS_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};
extern const uint8_t sp4_LEVEL[] 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};
extern const uint8_t sp4_LEVEL_1[] 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};
extern const uint8_t sp5_LEVEL_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};
extern const uint8_t sp4_LIGHTS[] 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};
extern const uint8_t sp2_LIGHT[] 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};
extern const uint8_t sp4_LIGHT[] 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};
extern const uint8_t sp2_LINE[] 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};
extern const uint8_t sp5_LIST[] 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};
extern const uint8_t sp5_LOCALIZER[] 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};
extern const uint8_t sp4_LONG[] 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};
extern const uint8_t sp4_LONG_1[] 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};
extern const uint8_t sp3_LOW2[] 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};
extern const uint8_t sp4_LOWER[] 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};
extern const uint8_t sp2_LOW[] 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};
extern const uint8_t sp3_LOW[] 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};
extern const uint8_t sp2_MACHINE[] 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};
extern const uint8_t sp5_MAGNETOS[] 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};
extern const uint8_t sp5_MAINTAIN[] 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};
extern const uint8_t sp2_MANUAL[] 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};
extern const uint8_t sp4_MAYDAY[] 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};
extern const uint8_t sp3_MEAN[] 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};
extern const uint8_t sp4_MEASURED[] 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};
extern const uint8_t sp2_MEASURE[] 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};
extern const uint8_t sp2_MEGA[] 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};
extern const uint8_t sp2_METER[] 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};
extern const uint8_t sp2_MICRO[] 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};
extern const uint8_t sp5_MIDDLE[] 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};
extern const uint8_t sp5_MIDPOINT[] 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};
extern const uint8_t sp4_MIG[] 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};
extern const uint8_t sp3_MILES[] 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};
extern const uint8_t sp2_MILLI[] 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};
extern const uint8_t sp2_MILL[] 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};
extern const uint8_t sp2_MINUS[] 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};
extern const uint8_t sp3_MINUS[] 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};
extern const uint8_t sp2_MINUTES[] 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};
extern const uint8_t sp3_MINUTES[] 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};
extern const uint8_t sp3_MIST[] 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};
extern const uint8_t sp4_MIXTURE[] 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};
extern const uint8_t sp3_MODERATE[] 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};
extern const uint8_t sp3_MORE_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};
extern const uint8_t sp2_MOTOR[] 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};
extern const uint8_t sp2_MOVE[] 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};
extern const uint8_t sp3_MOVING[] 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};
extern const uint8_t sp4_MUCH[] 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};
extern const uint8_t sp4_NEAR[] 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};
extern const uint8_t sp3_NEGATIVE[] 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};
extern const uint8_t sp4_NEGATIVE[] 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};
extern const uint8_t sp5_NEW[] 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};
extern const uint8_t sp5_NINER[] 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};
extern const uint8_t sp3_NORTHEAST[] 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};
extern const uint8_t sp3_NORTHWEST[] 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};
extern const uint8_t sp2_NORTH[] 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};
extern const uint8_t sp3_NORTH[] 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};
extern const uint8_t sp2_NOR[] 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};
extern const uint8_t sp5_NOTEM[] 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};
extern const uint8_t sp2_NOT[] 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};
extern const uint8_t sp4_NO[] 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};
extern const uint8_t sp5_NO_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};
extern const uint8_t sp2_NUMBER[] 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};
extern const uint8_t sp3_OBSCURED[] 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};
extern const uint8_t sp3_OCLOCK[] 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};
extern const uint8_t sp2_OFF[] 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};
extern const uint8_t sp4_OFF[] 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};
extern const uint8_t sp3_OF[] 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};
extern const uint8_t sp2_OHMS[] 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};
extern const uint8_t sp4_OIL[] 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};
extern const uint8_t sp2_ON[] 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};
extern const uint8_t sp4_ON[] 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};
extern const uint8_t sp2_OPEN[] 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};
extern const uint8_t sp4_OPEN[] 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};
extern const uint8_t sp4_OPEN_1[] 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};
extern const uint8_t sp2_OPERATOR[] 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};
extern const uint8_t sp4_OTHER[] 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};
extern const uint8_t sp5_OUTER[] 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};
extern const uint8_t sp2_OUT[] 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};
extern const uint8_t sp4_OUT[] 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};
extern const uint8_t sp3_OVERCAST[] 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};
extern const uint8_t sp5_OVERSPEED[] 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};
extern const uint8_t sp2_OVER[] 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};
extern const uint8_t sp3_OVER[] 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};
extern const uint8_t sp5_PAKM[] 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};
extern const uint8_t sp3_PARTIALLY[] 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};
extern const uint8_t sp2_PASS[] 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};
extern const uint8_t sp2_PAST[] 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};
extern const uint8_t sp3_PATH[] 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};
extern const uint8_t sp3_PELLETS[] 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};
extern const uint8_t sp2_PERCENT[] 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};
extern const uint8_t sp3_PERCENT[] 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};
extern const uint8_t sp3_PER[] 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};
extern const uint8_t sp2_PHASE[] 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};
extern const uint8_t sp2_PICO[] 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};
extern const uint8_t sp4_PLAN[] 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};
extern const uint8_t sp4_PLEASE[] 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};
extern const uint8_t sp2_PLUS[] 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};
extern const uint8_t sp3_PLUS[] 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};
extern const uint8_t sp2_POINT[] 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};
extern const uint8_t sp3_POINT[] 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};
extern const uint8_t sp2_POSITION[] 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};
extern const uint8_t sp2_POWER[] 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};
extern const uint8_t sp4_POWER[] 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};
extern const uint8_t sp2_PRESSURE[] 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};
extern const uint8_t sp3_PRESSURE[] 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};
extern const uint8_t sp4_PRESSURE[] 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};
extern const uint8_t sp2_PRESS[] 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};
extern const uint8_t sp2_PROBE[] 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};
extern const uint8_t sp2_PULL[] 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};
extern const uint8_t sp4_PUMPS[] 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};
extern const uint8_t sp2_PUSH[] 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};
extern const uint8_t sp3_P_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};
extern const uint8_t sp4_RADAR[] 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};
extern const uint8_t sp5_RADIAL[] 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};
extern const uint8_t sp4_RADIAL[] 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};
extern const uint8_t sp4_RADIOS[] 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};
extern const uint8_t sp3_RAIN[] 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};
extern const uint8_t sp4_RAIN[] 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};
extern const uint8_t sp5_RAISE[] 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};
extern const uint8_t sp2_RANGE[] 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};
extern const uint8_t sp2_READY[] 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};
extern const uint8_t sp4_READY[] 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};
extern const uint8_t sp3_READY[] 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,};
extern const uint8_t sp4_REAR[] 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};
extern const uint8_t sp2_RED[] 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};
extern const uint8_t sp3_RED[] 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};
extern const uint8_t sp5_REFUELLING[] 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};
extern const uint8_t sp4_RELEASE[] 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};
extern const uint8_t sp5_REMARK[] 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};
extern const uint8_t sp2_REPAIR[] 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};
extern const uint8_t sp4_REPAIR[] 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};
extern const uint8_t sp2_REPEAT[] 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};
extern const uint8_t sp4_RICH[] 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};
extern const uint8_t sp2_RIGHT[] 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};
extern const uint8_t sp4_RIGHT[] 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};
extern const uint8_t sp4_ROGER[] 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};
extern const uint8_t sp5_ROLL_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};
extern const uint8_t sp5_RVRS[] 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};
extern const uint8_t sp4_R_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};
extern const uint8_t sp2_SAFE[] 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};
extern const uint8_t sp3_SAND[] 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};
extern const uint8_t sp3_SCATTERED[] 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};
extern const uint8_t sp2_SECONDS[] 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};
extern const uint8_t sp4_SECURITY[] 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};
extern const uint8_t sp5_SELCAL[] 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};
extern const uint8_t sp4_SELECT[] 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};
extern const uint8_t sp4_SEQUENCE[] 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};
extern const uint8_t sp2_SERVICE[] 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};
extern const uint8_t sp4_SERVICE[] 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};
extern const uint8_t sp2_SET[] 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};
extern const uint8_t sp5_SET[] 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};
extern const uint8_t sp3_SEVERE[] 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};
extern const uint8_t sp5_SHORT[] 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};
extern const uint8_t sp3_SHOWERS[] 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};
extern const uint8_t sp2_SHUT[] 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};
extern const uint8_t sp4_SIDE[] 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};
extern const uint8_t sp5_SIGNET[] 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};
extern const uint8_t sp3_SLEET[] 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};
extern const uint8_t sp5_SLOKE[] 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};
extern const uint8_t sp2_SLOW[] 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};
extern const uint8_t sp4_SLOW[] 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};
extern const uint8_t sp4_SLOW_1[] 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};
extern const uint8_t sp2_SMOKE[] 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};
extern const uint8_t sp3_SMOKE[] 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};
extern const uint8_t sp3_SNOW[] 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};
extern const uint8_t sp3_SOUTHEAST[] 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};
extern const uint8_t sp3_SOUTHWEST[] 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};
extern const uint8_t sp2_SOUTH[] 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};
extern const uint8_t sp3_SOUTH[] 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};
extern const uint8_t sp2_SPEED[] 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};
extern const uint8_t sp4_SPEED[] 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};
extern const uint8_t sp5_SPOILERS[] 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};
extern const uint8_t sp5_SQUALKING[] 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};
extern const uint8_t sp5_SQUALK[] 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};
extern const uint8_t sp5_STABILISER[] 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};
extern const uint8_t sp5_STALL[] 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};
extern const uint8_t sp2_START[] 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};
extern const uint8_t sp3_START[] 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};
extern const uint8_t sp4_START[] 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};
extern const uint8_t sp2_STOP[] 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};
extern const uint8_t sp3_STOP[] 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};
extern const uint8_t sp3_STORM[] 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};
extern const uint8_t sp4_STRAY[] 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};
extern const uint8_t sp2_SWITCH[] 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};
extern const uint8_t sp4_TARGET[] 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};
extern const uint8_t sp4_TARGET_1[] 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};
extern const uint8_t sp5_TAXI[] 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};
extern const uint8_t sp5_TELEPHONE[] 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};
extern const uint8_t sp2_TEMPERATURE[] 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};
extern const uint8_t sp3_TEMPERATURE[] 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};
extern const uint8_t sp4_TERMINAL[] 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};
extern const uint8_t sp2_TEST[] 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};
extern const uint8_t sp3_THEE[] 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};
extern const uint8_t sp2_THE[] 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};
extern const uint8_t sp3_THE[] 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};
extern const uint8_t sp4_THE[] 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};
extern const uint8_t sp3_THINLY[] 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};
extern const uint8_t sp3_THIN[] 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};
extern const uint8_t sp3_THUNDERSTORM[] 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};
extern const uint8_t sp2_TIMER[] 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};
extern const uint8_t sp3_TIMES[] 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};
extern const uint8_t sp2_TIME[] 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};
extern const uint8_t sp3_TIME[] 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};
extern const uint8_t sp2_TOOL[] 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};
extern const uint8_t sp4_TOO_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};
extern const uint8_t sp3_TORNADO[] 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};
extern const uint8_t sp5_TOUCHDOWN[] 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};
extern const uint8_t sp5_TOWER[] 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};
extern const uint8_t sp4_TO[] 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};
extern const uint8_t sp4_TRAFFIC[] 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};
extern const uint8_t sp5_TRIM[] 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};
extern const uint8_t sp4_TRUE[] 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};
extern const uint8_t sp3_TURBULANCE[] 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};
extern const uint8_t sp2_TURN[] 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};
extern const uint8_t sp4_TURN[] 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};
extern const uint8_t sp2_UH[] 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};
extern const uint8_t sp5_UNDERCARRIAGE[] 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};
extern const uint8_t sp2_UNDER[] 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};
extern const uint8_t sp5_UNICOM[] 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};
extern const uint8_t sp2_UNIT[] 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};
extern const uint8_t sp3_UNLIMITED[] 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};
extern const uint8_t sp2_UP[] 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};
extern const uint8_t sp5_UP[] 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};
extern const uint8_t sp4_USE2[] 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};
extern const uint8_t sp4_USE[] 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};
extern const uint8_t sp4_VACUUM[] 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};
extern const uint8_t sp2_VALVE[] 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};
extern const uint8_t sp2_VAL[] 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};
extern const uint8_t sp4_VECTORS[] 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};
extern const uint8_t sp4_VERIFY[] 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};
extern const uint8_t sp5_VFR[] 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};
extern const uint8_t sp5_VHE[] 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};
extern const uint8_t sp3_VISIBILITY[] 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};
extern const uint8_t sp2_VOLTS[] 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};
extern const uint8_t sp5_VORTAC[] 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};
extern const uint8_t sp5_VOR[] 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};
extern const uint8_t sp5_WAKE[] 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};
extern const uint8_t sp4_WARNING[] 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};
extern const uint8_t sp4_WATCH[] 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};
extern const uint8_t sp2_WATTS[] 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};
extern const uint8_t sp4_WAY[] 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};
extern const uint8_t sp3_WEATHER[] 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};
extern const uint8_t sp2_WEIGHT[] 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};
extern const uint8_t sp2_WEST[] 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};
extern const uint8_t sp3_WEST[] 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};
extern const uint8_t sp3_WHITE[] 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};
extern const uint8_t sp4_WINDOWS[] 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};
extern const uint8_t sp3_WIND[] 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};
extern const uint8_t sp2_YELLOW[] 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};
extern const uint8_t sp3_YELLOW[] 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};
extern const uint8_t sp4_YOU[] 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};
extern const uint8_t sp4_ZONE[] 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};
| 549.935331 | 1,499 | 0.795141 | kgranat |
eef84bdb66fe3dcf516de4188d684250987ca952 | 3,513 | cpp | C++ | search/search_tests/house_numbers_matcher_test.cpp | benwixen/tripfinger-ios | bbca1c83269a7015100d43997569b543025a4087 | [
"Apache-2.0"
] | null | null | null | search/search_tests/house_numbers_matcher_test.cpp | benwixen/tripfinger-ios | bbca1c83269a7015100d43997569b543025a4087 | [
"Apache-2.0"
] | 13 | 2015-09-28T13:59:23.000Z | 2015-10-08T20:12:45.000Z | search/search_tests/house_numbers_matcher_test.cpp | prebenl/tripfinger | bbca1c83269a7015100d43997569b543025a4087 | [
"Apache-2.0"
] | null | null | null | #include "testing/testing.hpp"
#include "search/v2/house_numbers_matcher.hpp"
#include "std/vector.hpp"
#include "base/string_utils.hpp"
using namespace strings;
using namespace search::v2;
namespace
{
void NormalizeHouseNumber(string const & s, vector<string> & ts)
{
vector<strings::UniString> tokens;
search::v2::NormalizeHouseNumber(strings::MakeUniString(s), tokens);
for (auto const & token : tokens)
ts.push_back(strings::ToUtf8(token));
}
bool HouseNumbersMatch(string const & houseNumber, string const & query)
{
return search::v2::HouseNumbersMatch(strings::MakeUniString(houseNumber),
strings::MakeUniString(query));
}
bool CheckTokenizer(string const & utf8s, vector<string> const & expected)
{
UniString utf32s = MakeUniString(utf8s);
vector<HouseNumberTokenizer::Token> tokens;
HouseNumberTokenizer::Tokenize(utf32s, tokens);
vector<string> actual;
for (auto const & token : tokens)
actual.push_back(ToUtf8(token.m_token));
return actual == expected;
}
bool CheckNormalizer(string const & utf8s, string const & expected)
{
vector<string> tokens;
NormalizeHouseNumber(utf8s, tokens);
string actual;
for (size_t i = 0; i < tokens.size(); ++i)
{
actual.append(tokens[i]);
if (i + 1 != tokens.size())
actual.push_back(' ');
}
return actual == expected;
}
} // namespace
UNIT_TEST(HouseNumberTokenizer_Smoke)
{
TEST(CheckTokenizer("123Б", {"123", "Б"}), ());
TEST(CheckTokenizer("123/Б", {"123", "Б"}), ());
TEST(CheckTokenizer("123/34 корп. 4 стр1", {"123", "34", "корп", "4", "стр", "1"}), ());
}
UNIT_TEST(HouseNumberNormalizer_Smoke)
{
TEST(CheckNormalizer("123Б", "123б"), ());
TEST(CheckNormalizer("123/4 Литер А", "123 4 а"), ());
TEST(CheckNormalizer("123а корп. 2б", "123а 2б"), ());
TEST(CheckNormalizer("123к4", "123 4"), ());
TEST(CheckNormalizer("123к Корпус 2", "123к 2"), ());
TEST(CheckNormalizer("9 литер А корпус 2", "9 2 а"), ());
TEST(CheckNormalizer("39с79", "39 79"), ());
TEST(CheckNormalizer("9 литер аб1", "9 аб1"), ());
}
UNIT_TEST(HouseNumbersMatcher_Smoke)
{
TEST(HouseNumbersMatch("39с79", "39"), ());
TEST(HouseNumbersMatch("39с79", "39 Строение 79"), ());
TEST(HouseNumbersMatch("39с79", "39 к. 79"), ());
TEST(HouseNumbersMatch("39 - 79", "39 строение 79"), ());
TEST(HouseNumbersMatch("39/79", "39 строение 79"), ());
TEST(HouseNumbersMatch("127а корпус 2", "127а"), ());
TEST(HouseNumbersMatch("127а корпус 2", "127а кор. 2"), ());
TEST(HouseNumbersMatch("1234abcdef", "1234 abcdef"), ());
TEST(HouseNumbersMatch("10/42 корпус 2", "10"), ());
TEST(HouseNumbersMatch("10 к2 с2", "10 корпус 2"), ());
TEST(HouseNumbersMatch("10 к2 с2", "10 корпус 2 с 2"), ());
TEST(HouseNumbersMatch("10 корпус 2 строение 2", "10 к2 с2"), ());
TEST(HouseNumbersMatch("10 корпус 2 строение 2", "10к2с2"), ());
TEST(HouseNumbersMatch("10к2а", "10 2а"), ());
TEST(HouseNumbersMatch("10 к2с", "10 2с"), ());
TEST(!HouseNumbersMatch("39", "39 с 79"), ());
TEST(!HouseNumbersMatch("127а корпус 2", "127"), ());
TEST(!HouseNumbersMatch("6 корпус 2", "7"), ());
TEST(!HouseNumbersMatch("10/42 корпус 2", "42"), ());
TEST(!HouseNumbersMatch("--...--.-", "--.....-"), ());
}
UNIT_TEST(HouseNumbersMatcher_TwoStages)
{
strings::UniString number = strings::MakeUniString("10 к2 с2");
vector<strings::UniString> tokens;
NormalizeHouseNumber(number, tokens);
TEST(HouseNumbersMatch(number, tokens), (number, tokens));
}
| 32.831776 | 90 | 0.658127 | benwixen |
eef8a10b3f041d31bff8c79ba1c89ce3f4ee9c0e | 12,533 | cpp | C++ | src/ui_dialog.cpp | libtcod/treeburner | ace0eab18d55db77475f509f1bcd8b647cc46c3b | [
"MIT"
] | null | null | null | src/ui_dialog.cpp | libtcod/treeburner | ace0eab18d55db77475f509f1bcd8b647cc46c3b | [
"MIT"
] | null | null | null | src/ui_dialog.cpp | libtcod/treeburner | ace0eab18d55db77475f509f1bcd8b647cc46c3b | [
"MIT"
] | null | null | null |
/*
* Copyright (c) 2010 Jice
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * The name of Jice may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY Jice ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL Jice BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "main.hpp"
void Widget::sendEvent(EWidgetEvent event) {
for (UIListener **it=listeners.begin(); it != listeners.end(); it++) {
if ((*it)->onWidgetEvent(this,event)) break;
}
}
Button::Button() : label(NULL) {}
Button::Button(const char *label, int x, int y) : Widget(x,y) {
if (label) {
this->label = strdup(label);
setSize(strlen(label),1);
} else setSize(0,0);
}
Button::~Button() {
if ( label ) free(label);
}
void Button::setLabel(const char *label) {
if ( this->label ) free(this->label);
if ( label ) {
this->label = strdup(label);
setSize(strlen(label),1);
} else {
setSize(0,0);
this->label=NULL;
}
}
void Button::render(TCODConsole *con) {
con->setDefaultBackground(mouseHover && ! pressed ? guiHighlightedBackground : guiBackground );
con->setDefaultForeground(pressed ? guiHighlightedText : guiText);
con->printEx(x,y,TCOD_BKGND_SET,TCOD_LEFT,label);
}
void Button::update(float elapsed, TCOD_key_t &k, TCOD_mouse_t &mouse, int rectx, int recty) {
int mx=mouse.cx-x-rectx;
int my=mouse.cy-y-recty;
mouseHover=pressed=false;
if ( mx >= 0 && mx < w && my >= 0 && my < h ) {
mouseHover=true;
pressed = mouse.lbutton;
if ( mouse.lbutton_pressed ) {
sendEvent(WE_BUTTON_CLICKED);
}
}
}
Tabs::Tabs() {
curTab=0;
mouseTab=-1;
}
Tabs::~Tabs() {
for (const char **it=labels.begin(); it!=labels.end(); it++) {
free((void *)*it);
}
}
int Tabs::addTab(const char *label) {
labels.push(strdup(label));
tabpos.push(0);
tablen.push(strlen(label));
return labels.size()-1;
}
void Tabs::setLabel(int id, const char *label) {
const char *oldLabel=labels.get(id);
if ( oldLabel && strcmp(oldLabel,label) == 0 ) return;
if ( oldLabel ) free((void *)oldLabel);
labels.set(strdup(label),id);
tablen.set(strlen(label),id);
}
void Tabs::render(TCODConsole *con, int rectx, int recty) {
int tx=2+rectx;
for (int i=0; i< labels.size(); i++) {
if ( i > 0 ) {
con->setDefaultForeground(guiText);
con->print(tx++,recty+1,"\xB3");
}
tabpos.set(tx,i);
con->setDefaultBackground(mouseTab==i && curTab != i ? guiHighlightedBackground : guiBackground );
con->setDefaultForeground(TCODColor::white);
const char *label=labels.get(i);
con->printEx(tx++,recty+1,TCOD_BKGND_SET,TCOD_LEFT,"%c",label[0]);
con->setDefaultForeground(curTab==i ? guiHighlightedText : guiText);
con->printEx(tx,recty+1,TCOD_BKGND_SET,TCOD_LEFT,&label[1]);
tx += tablen.get(i)-1;
}
}
void Tabs::update(float elapsed, TCOD_key_t &k, TCOD_mouse_t &mouse, int rectx, int recty) {
mouseTab = -1;
int mx=mouse.cx-rectx;
int my=mouse.cy-recty;
if ( my == 1 ) {
for (int i=0; i< labels.size(); i++) {
if ( mx >= tabpos.get(i) && mx < tabpos.get(i) + tablen.get(i)) {
mouseTab=i;
if ( mouse.lbutton ) curTab=mouseTab;
break;
}
}
}
}
Scroller::Scroller(Scrollable * scrollable, int width, int height, bool inverted)
: inverted(inverted), width(width), height(height), scrollable(scrollable) {
scrollFocus=scrollDrag=false;
scrollOffset=0;
}
void Scroller::render(TCODConsole *con, int x, int y) {
int nbMessages = scrollable->getScrollTotalSize();
int ypos = inverted ? MAX(0,height-nbMessages-scrollOffset) : 0;
int count= inverted ? height-ypos : MIN(height,nbMessages-scrollOffset);
int idx = nbMessages-count-scrollOffset;
for (; count > 0; idx++,ypos++,count--) {
TCODColor fore,back;
scrollable->getScrollColor(idx,&fore,&back);
con->setDefaultForeground(fore);
con->setDefaultBackground(back);
con->printEx(width/2,y+ypos,TCOD_BKGND_SET,TCOD_CENTER,scrollable->getScrollText(idx));
}
}
void Scroller::renderScrollbar(TCODConsole *con, int x, int y) {
int nbMessages = scrollable->getScrollTotalSize();
int nbDisplayed = MIN(height,nbMessages-scrollOffset);
if ( nbMessages > 0 && nbDisplayed < nbMessages ) {
// scrollbar
int firstDisplayed = nbMessages - scrollOffset - nbDisplayed;
int start = ((height-1) * firstDisplayed)/nbMessages;
int end = ((height-1) * (firstDisplayed + nbDisplayed))/nbMessages;
end=MIN(height-1,end);
con->setDefaultBackground(scrollFocus || scrollDrag ? guiText : guiText*0.8f);
con->rect(x+width-2,y+start,2,end-start+1,true,TCOD_BKGND_SET);
}
}
void Scroller::update(float elapsed,TCOD_key_t &k, TCOD_mouse_t &mouse, int rectx, int recty) {
int nbMessages = scrollable->getScrollTotalSize();
int nbDisplayed = MIN(height,nbMessages-scrollOffset);
int firstDisplayed = nbMessages - scrollOffset - nbDisplayed;
// scrollbar focus
if ( nbDisplayed < nbMessages ) {
bool up=false,down=false,left=false,right=false;
Player::getMoveKey(k,&up,&down,&left,&right);
if ( ( up || left ) && scrollOffset < nbMessages - height) {
scrollOffset += 5;
scrollOffset = MIN(nbMessages-height,scrollOffset);
} else if ( (down || right ) && scrollOffset > 0 ) {
scrollOffset -= MIN(5,scrollOffset);
}
int start = ((height-1) * firstDisplayed)/nbMessages;
int end = ((height-1) * (firstDisplayed + nbDisplayed))/nbMessages;
scrollFocus = ( mouse.cx >= rectx+width-2 && mouse.cx < rectx+width && mouse.cy >= recty+start && mouse.cy <= recty+end );
if ( ! scrollDrag && scrollFocus && mouse.lbutton ) {
scrollDrag=true;
scrollStartDrag=mouse.cy;
scrollStartOffset=start;
} else if (scrollDrag && mouse.lbutton) {
int delta = mouse.cy - scrollStartDrag;
int newStart=scrollStartOffset + delta;
int newFirst = newStart * nbMessages / height;
newFirst = MAX(0,newFirst);
newFirst = MIN(nbMessages-height,newFirst);
scrollOffset = nbMessages - nbDisplayed - newFirst;
} else if (scrollDrag && ! mouse.lbutton ) {
scrollDrag=false;
}
}
}
void Scroller::save(TCODZip *zip) {
zip->putInt(scrollOffset);
}
void Scroller::load(TCODZip *zip) {
scrollOffset=zip->getInt();
}
bool Dialog::update() {
static float timeScale=config.getFloatProperty("config.gameplay.timeScale");
float elapsed = TCODSystem::getLastFrameLength() * timeScale;
if ( isMaximizable() && minimiseButton.mouseDown && ! waitRelease) {
if (isMinimized) setMaximized();
else setMinimized();
waitRelease=true;
} else if (! minimiseButton.mouseDown) waitRelease=false;
if ( isClosable() && closeButton.mouseDown ) {
return false;
}
if (!UmbraWidget::update()) return false;
internalUpdate();
return update(elapsed, key,ms);
}
void Dialog::activate() {
UmbraWidget::activate();
if ( isModal() ) gameEngine->pauseGame();
}
void Dialog::deactivate() {
UmbraWidget::deactivate();
if ( isModal() ) gameEngine->resumeGame();
}
void Dialog::setMaximized() {
// if draggable, save position
if ( isDraggable()) {
minimizedRect.x=rect.x;
minimizedRect.y=rect.y;
}
rect=maximizedRect;
minimiseButton.set(rect.w-2,0);
isMinimized=false;
canDrag=false;
if (gameEngine && ! gameEngine->isGamePaused()) gameEngine->pauseGame();
if ( gameEngine ) gameEngine->gui.setMode(GUI_MAXIMIZED);
}
void Dialog::setMinimized() {
rect=minimizedRect;
minimiseButton.set(rect.w-2,0);
isMinimized=true;
canDrag=isDraggable() || isMultiPos();
if ( isDraggable() || isMultiPos()) {
setDragZone(0,0,minimizedRect.w-3,1);
}
if (gameEngine && gameEngine->isGamePaused() ) gameEngine->resumeGame();
if ( gameEngine ) gameEngine->gui.mode=GUI_NONE;
}
void Dialog::renderFrame(float alpha, const char *title) {
con->setDefaultBackground(guiBackground);
con->setDefaultForeground(guiText);
con->rect(0,0,rect.w,1,true,TCOD_BKGND_SET);
con->printEx(rect.w/2,0,TCOD_BKGND_NONE, TCOD_CENTER, title);
if ( isMinimized && (isDraggable() || isMultiPos()) ) {
// draw dragging handle
int l=strlen(title);
for (int x=0; x < rect.w/2-l/2-1; x++ ) con->putChar(x,0,TCOD_CHAR_BLOCK2,TCOD_BKGND_NONE);
for (int x=rect.w/2+l/2+1 + (l&1); x < rect.w; x++ ) con->putChar(x,0,TCOD_CHAR_BLOCK2,TCOD_BKGND_NONE);
}
if ( isAnyClosable() ) {
con->setDefaultForeground(closeButton.mouseHover ? guiHighlightedText : guiText);
con->putChar(closeButton.x,closeButton.y,'x',TCOD_BKGND_NONE);
}
if (isMaximizable()) {
con->setDefaultForeground(minimiseButton.mouseHover ? guiHighlightedText : guiText);
con->putChar(minimiseButton.x,minimiseButton.y,
isMinimized?TCOD_CHAR_ARROW2_N:TCOD_CHAR_ARROW2_S,TCOD_BKGND_NONE);
}
if ( alpha < 1.0f ) blitSemiTransparent(con,0,0,rect.w,1,TCODConsole::root,rect.x,rect.y, alpha,alpha);
else TCODConsole::blit(con,0,0,rect.w,1,TCODConsole::root,rect.x,rect.y);
}
void Dialog::internalUpdate() {
if ( isModal() && !gameEngine->isGamePaused() ) {
gameEngine->pauseGame();
}
}
void MultiPosDialog::renderFrame(float alpha, const char *title) {
if (isMultiPos() && isDragging && isMinimized ) {
renderTargetFrame();
}
Dialog::renderFrame(alpha,title);
}
void MultiPosDialog::internalUpdate() {
Dialog::internalUpdate();
if (isMultiPos() && isDragging && isMinimized ) {
targetx=rect.x;
targety=rect.y;
if (! isDraggable() ) {
// cancel actual dragging
rect.x=minimizedRect.x;
rect.y=minimizedRect.y;
}
// find nearest position
int dist=10000,best=0;
for (int i=0; i < possiblePos.size(); i++ ) {
UmbraRect curRect=*possiblePos.get(i);
int curDist=(curRect.x-targetx)*(curRect.x-targetx)+(curRect.y-targety)*(curRect.y-targety);
if ( curDist < dist ) {
dist=curDist;
best=i;
}
}
targetx=possiblePos.get(best)->x;
targety=possiblePos.get(best)->y;
}
}
void MultiPosDialog::onDragEnd() {
minimizedRect.x=targetx;
minimizedRect.y=targety;
setPos(targetx,targety);
// alter the dialogs of the set
int posnum=0;
int bestdist=100000;
int bestpos=0;
// find the best set position
for (posnum=0; posnum < possiblePos.size(); posnum++ ) {
UmbraRect curRect=*possiblePos.get(posnum);
if ( rect.x == curRect.x && rect.y == curRect.y ) {
int dist=0;
for ( MultiPosDialog **it=set.begin();it!=set.end(); it++) {
if ( *it != this ) {
UmbraRect *prect = (*it)->possiblePos.get(posnum);
int dx = prect->x - (*it)->rect.x;
int dy = prect->y - (*it)->rect.y;
dist += dx*dx+dy*dy;
}
}
if ( dist < bestdist ) {
bestdist=dist;
bestpos=posnum;
}
}
}
for ( MultiPosDialog **it=set.begin();it!=set.end(); it++) {
if ( *it != this ) {
UmbraRect *bestp=(*it)->possiblePos.get(bestpos);
(*it)->rect = (*it)->minimizedRect = *bestp;
(*it)->setPos(bestp->x,bestp->y);
}
}
}
void MultiPosDialog::renderTargetFrame() {
TCODConsole::root->setDefaultForeground(guiText);
TCODConsole::root->printFrame(targetx,targety,rect.w,rect.h,false,TCOD_BKGND_NONE,NULL);
}
| 34.149864 | 125 | 0.659698 | libtcod |
eeff81085e8dcd68914fa29ef6614c43b9f15b25 | 970 | cpp | C++ | src/Bus.cpp | ecrandz/IoTManager | 5d0eb71cfccccf9020b28be8c9fa5837988fb6ba | [
"MIT"
] | 37 | 2020-08-17T10:39:06.000Z | 2022-02-17T16:18:47.000Z | src/Bus.cpp | ecrandz/IoTManager | 5d0eb71cfccccf9020b28be8c9fa5837988fb6ba | [
"MIT"
] | 11 | 2020-10-20T14:48:07.000Z | 2022-02-04T07:05:05.000Z | src/Bus.cpp | ecrandz/IoTManager | 5d0eb71cfccccf9020b28be8c9fa5837988fb6ba | [
"MIT"
] | 43 | 2020-06-19T22:40:14.000Z | 2022-03-05T05:29:07.000Z | #include "Bus.h"
#include "Class/NotAsync.h"
#include "Global.h"
void busInit() {
myNotAsyncActions->add(
do_BUSSCAN, [&](void*) {
String tmp = i2c_scan();
if (tmp == "error") {
tmp = i2c_scan();
Serial.println(tmp);
jsonWriteStr(configLiveJson, "i2c", tmp);
}
else {
Serial.println(tmp);
jsonWriteStr(configLiveJson, "i2c", tmp);
}
},
nullptr);
SerialPrint("I", F("Bus"), F("Bus Init"));
}
String i2c_scan() {
String out;
byte count = 0;
Wire.begin();
for (byte i = 8; i < 120; i++) {
Wire.beginTransmission(i);
if (Wire.endTransmission() == 0) {
count++;
out += String(count) + ". 0x" + String(i, HEX) + "; ";
delay(1);
}
}
if (count == 0) {
return "error";
}
else {
return out;
}
} | 23.658537 | 66 | 0.442268 | ecrandz |
e100bd2ea767e4333201cc64650afd07cd801c88 | 1,204 | cpp | C++ | src/engine/ui/src/ui/widgets/ui_paged_pane.cpp | lye/halley | 16b6c9783e4b21377f902a9d02366c1f19450a21 | [
"Apache-2.0"
] | 1 | 2019-11-27T20:23:45.000Z | 2019-11-27T20:23:45.000Z | src/engine/ui/src/ui/widgets/ui_paged_pane.cpp | lye/halley | 16b6c9783e4b21377f902a9d02366c1f19450a21 | [
"Apache-2.0"
] | null | null | null | src/engine/ui/src/ui/widgets/ui_paged_pane.cpp | lye/halley | 16b6c9783e4b21377f902a9d02366c1f19450a21 | [
"Apache-2.0"
] | null | null | null | #include <halley/ui/widgets/ui_paged_pane.h>
using namespace Halley;
UIPagedPane::UIPagedPane(String id, int nPages, Vector2f minSize)
: UIWidget(id, minSize, UISizer())
{
pages.reserve(nPages);
for (int i = 0; i < nPages; ++i) {
addPage();
}
setPage(0);
}
void UIPagedPane::addPage()
{
pages.push_back(std::make_shared<UIWidget>("page" + toString(pages.size()), getMinimumSize(), UISizer()));
UIWidget::add(pages.back(), 1);
}
void UIPagedPane::setPage(int n)
{
currentPage = clamp(n, 0, int(getNumberOfPages()) - 1);
for (int i = 0; i < getNumberOfPages(); ++i) {
const bool active = i == n;
if (pages[i]->isActive() != active) {
pages[i]->setActive(active);
sendEventDown(UIEvent(active ? UIEventType::TabbedIn : UIEventType::TabbedOut, getId(), active));
}
}
}
int UIPagedPane::getCurrentPage() const
{
return currentPage;
}
int UIPagedPane::getNumberOfPages() const
{
return int(pages.size());
}
Vector2f UIPagedPane::getLayoutMinimumSize(bool force) const
{
Vector2f size;
for (auto& p: pages) {
size = Vector2f::max(size, p->getLayoutMinimumSize(true));
}
return size;
}
std::shared_ptr<UIWidget> UIPagedPane::getPage(int n) const
{
return pages.at(n);
}
| 21.122807 | 107 | 0.686877 | lye |
e1022e833de59ed3edbaa717553130aea9605bf2 | 3,181 | hpp | C++ | Include/FishEngine/GameObject.hpp | yushroom/FishEngine_-Experiment | 81e4c06f20f6b94dc561b358f8a11a092678aeeb | [
"MIT"
] | 1 | 2018-12-20T02:38:44.000Z | 2018-12-20T02:38:44.000Z | Include/FishEngine/GameObject.hpp | yushroom/FishEngine_-Experiment | 81e4c06f20f6b94dc561b358f8a11a092678aeeb | [
"MIT"
] | null | null | null | Include/FishEngine/GameObject.hpp | yushroom/FishEngine_-Experiment | 81e4c06f20f6b94dc561b358f8a11a092678aeeb | [
"MIT"
] | 1 | 2018-10-25T19:40:22.000Z | 2018-10-25T19:40:22.000Z | #pragma once
#include "FishEngine.hpp"
#include "Object.hpp"
#include "Component.hpp"
#include "Transform.hpp"
#include <list>
#include <vector>
#include <type_traits>
#include <typeinfo>
namespace FishEngine
{
class Component;
class Transform;
class RectTransform;
class Scene;
class Prefab;
enum class GameObjectConstructionFlag
{
WithTransform,
WithRectTransform,
Empty,
};
class GameObject : public Object
{
public:
DeclareObject(GameObject, 1);
GameObject(const std::string& name = "GameObject", GameObjectConstructionFlag flag = GameObjectConstructionFlag::WithTransform);
~GameObject();
Transform* GetTransform() const
{
return m_Transform;
}
const std::list<Component*>& GetAllComponents() const
{
return m_Component;
}
void AddComponent(Component* comp);
template<class T>
T* GetComponent()
{
static_assert(std::is_base_of<Component, T>::value, "T must be a Component");
for (Component* t : m_Component)
{
if (t->Is<T>())
{
return dynamic_cast<T*>(t);
}
}
return nullptr;
}
Component* GetComponent(int classID)
{
for (Component* t : m_Component)
{
if (t->GetClassID() == classID)
{
return t;
}
}
return nullptr;
}
// Returns the component of Type type in the GameObject or any of its children using depth first search.
// A component is returned only if it is found on an active GameObject.
template<class T>
T* GetComponentInChildren()
{
// find self
auto c = GetComponent<T>();
if (c != nullptr)
return c;
// find children
for (auto child : m_Transform->GetChildren())
{
auto ret = child->GetGameObject()->GetComponentInChildren<T>();
if (ret != nullptr)
return ret;
}
return nullptr;
}
// Returns all components of Type type in the GameObject or any of its children.
template<class T>
void GetComponentsInChildren(std::vector<T*>& components)
{
// find self
auto c = GetComponent<T>();
if (c != nullptr)
components.push_back(c);
// find children
for (auto child : m_Transform->GetChildren())
{
child->GetGameObject()->GetComponentsInChildren<T>(components);
}
}
Scene* GetScene() const
{
return m_Scene;
}
const std::string& GetTag() const { return m_TagString; }
// The local active state of this GameObject.
bool IsActive() const { return m_IsActive; }
void SetActive(bool active) { m_IsActive = active; }
// Is the GameObject active in the scene?
bool IsActiveInHierarchy() const;
GameObject* GetPrefabParentObject() const { return m_PrefabParentObject; }
void SetPrefabParentObject(GameObject* value) { m_PrefabParentObject = value; }
Prefab* GetPrefabInternal() const { return m_PrefabInternal; }
void SetPrefabInternal(Prefab* value) { m_PrefabInternal = value; }
protected:
GameObject * m_PrefabParentObject = nullptr;
Prefab * m_PrefabInternal = nullptr;
Scene* m_Scene = nullptr;
Transform* m_Transform = nullptr;
std::list<Component*> m_Component;
int m_Layer;
std::string m_TagString;
bool m_IsActive = true; // activeSelf
};
}
| 22.401408 | 130 | 0.674002 | yushroom |
e1031ef31be38de1c9e4f031142efcef594e8310 | 1,246 | cpp | C++ | plugins/x11input/src/focus/looked_up_string.cpp | cpreh/spacegameengine | 313a1c34160b42a5135f8223ffaa3a31bc075a01 | [
"BSL-1.0"
] | 2 | 2016-01-27T13:18:14.000Z | 2018-05-11T01:11:32.000Z | plugins/x11input/src/focus/looked_up_string.cpp | cpreh/spacegameengine | 313a1c34160b42a5135f8223ffaa3a31bc075a01 | [
"BSL-1.0"
] | null | null | null | plugins/x11input/src/focus/looked_up_string.cpp | cpreh/spacegameengine | 313a1c34160b42a5135f8223ffaa3a31bc075a01 | [
"BSL-1.0"
] | 3 | 2018-05-11T01:11:34.000Z | 2021-04-24T19:47:45.000Z | // Copyright Carl Philipp Reh 2006 - 2019.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#include <sge/input/key/code.hpp>
#include <sge/x11input/focus/char_vector.hpp>
#include <sge/x11input/focus/looked_up_string.hpp>
#include <fcppt/config/external_begin.hpp>
#include <utility>
#include <fcppt/config/external_end.hpp>
sge::x11input::focus::looked_up_string::looked_up_string(
sge::x11input::focus::char_vector &&_char_codes, sge::input::key::code const _key_code) noexcept
: char_codes_(std::move(_char_codes)), key_code_(_key_code)
{
}
sge::x11input::focus::looked_up_string::looked_up_string(looked_up_string &&) noexcept = default;
sge::x11input::focus::looked_up_string &
sge::x11input::focus::looked_up_string::operator=(looked_up_string &&) noexcept = default;
sge::x11input::focus::looked_up_string::~looked_up_string() noexcept = default;
sge::x11input::focus::char_vector const &
sge::x11input::focus::looked_up_string::char_codes() const noexcept
{
return char_codes_;
}
sge::input::key::code sge::x11input::focus::looked_up_string::key_code() const noexcept
{
return key_code_;
}
| 34.611111 | 100 | 0.752006 | cpreh |
e1055f1be42413fee23c4b05d61a057c8cc3481d | 3,171 | hpp | C++ | core/futex.hpp | luluxing/LiveGraph | eea5a40ce6ee443f901e44323c1119f59113eaf3 | [
"Apache-2.0"
] | 17 | 2021-02-25T03:21:47.000Z | 2022-03-14T10:14:51.000Z | core/futex.hpp | luluxing/LiveGraph | eea5a40ce6ee443f901e44323c1119f59113eaf3 | [
"Apache-2.0"
] | 1 | 2021-04-05T02:44:01.000Z | 2021-04-05T14:37:41.000Z | core/futex.hpp | luluxing/LiveGraph | eea5a40ce6ee443f901e44323c1119f59113eaf3 | [
"Apache-2.0"
] | 5 | 2021-03-10T22:39:54.000Z | 2021-08-16T03:22:32.000Z | /* Copyright 2020 Guanyu Feng, Tsinghua University
*
* 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
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* 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.
*/
#pragma once
#include <chrono>
#include <stdexcept>
#include <errno.h>
#include <linux/futex.h>
#include <sys/syscall.h>
#include <unistd.h>
namespace livegraph
{
class Futex
{
public:
void lock()
{
while (true)
{
__sync_fetch_and_add(&num_using, 1);
if (__sync_bool_compare_and_swap(&futexp, 0, 1))
break;
int ret = futex(&futexp, FUTEX_WAIT, 1, nullptr, nullptr, 0);
__sync_fetch_and_sub(&num_using, 1);
if (ret == -1 && errno != EAGAIN)
throw std::runtime_error("Futex wait error.");
}
}
template <class Rep, class Period> bool try_lock_for(const std::chrono::duration<Rep, Period> &timeout_duration)
{
const struct timespec timeout = {.tv_sec = timeout_duration / std::chrono::seconds(1),
.tv_nsec = (timeout_duration % std::chrono::seconds(1)) /
std::chrono::nanoseconds(1)};
while (true)
{
__sync_fetch_and_add(&num_using, 1);
if (__sync_bool_compare_and_swap(&futexp, 0, 1))
break;
int ret = futex(&futexp, FUTEX_WAIT, 1, &timeout, nullptr, 0);
__sync_fetch_and_sub(&num_using, 1);
if (ret == -1 && errno != EAGAIN && errno != ETIMEDOUT)
throw std::runtime_error("Futex wait error.");
if (ret != 0 && errno == ETIMEDOUT)
return false;
}
return true;
}
void unlock()
{
if (__sync_bool_compare_and_swap(&futexp, 1, 0))
{
if (__sync_sub_and_fetch(&num_using, 1) == 0)
return;
int ret = futex(&futexp, FUTEX_WAKE, 1, nullptr, nullptr, 0);
if (ret == -1)
throw std::runtime_error("Futex wake error.");
}
}
void clear()
{
futexp = 0;
num_using = 0;
}
Futex() : futexp(0), num_using(0) {}
private:
int futexp;
int num_using;
inline static int
futex(int *uaddr, int futex_op, int val, const struct timespec *timeout, int *uaddr2, int val3)
{
return syscall(SYS_futex, uaddr, futex_op, val, timeout, uaddr2, val3);
}
};
} // namespace livegraph
| 33.378947 | 120 | 0.534216 | luluxing |
e1093f033d35e2d512c8ce6855b3ef357662c325 | 7,138 | cpp | C++ | swri_profiler/src/profiler.cpp | swri-robotics/swri_profiler | 5d8fd4ef9604c8038dadf885c70864de5f4194e8 | [
"BSD-3-Clause"
] | 55 | 2016-03-03T10:35:11.000Z | 2022-02-16T06:30:08.000Z | swri_profiler/src/profiler.cpp | swri-robotics/swri_profiler | 5d8fd4ef9604c8038dadf885c70864de5f4194e8 | [
"BSD-3-Clause"
] | 12 | 2016-03-03T18:50:20.000Z | 2022-01-10T14:23:13.000Z | swri_profiler/src/profiler.cpp | swri-robotics/swri_profiler | 5d8fd4ef9604c8038dadf885c70864de5f4194e8 | [
"BSD-3-Clause"
] | 17 | 2015-12-10T23:28:04.000Z | 2021-12-22T18:09:45.000Z | #include <ros/this_node.h>
#include <swri_profiler/profiler.h>
#include <ros/publisher.h>
#include <swri_profiler_msgs/ProfileIndex.h>
#include <swri_profiler_msgs/ProfileIndexArray.h>
#include <swri_profiler_msgs/ProfileData.h>
#include <swri_profiler_msgs/ProfileDataArray.h>
namespace spm = swri_profiler_msgs;
namespace swri_profiler
{
// Define/initialize static member variables for the Profiler class.
std::unordered_map<std::string, Profiler::ClosedInfo> Profiler::closed_blocks_;
std::unordered_map<std::string, Profiler::OpenInfo> Profiler::open_blocks_;
boost::thread_specific_ptr<Profiler::TLS> Profiler::tls_;
SpinLock Profiler::lock_;
// Declare some more variables. These are essentially more private
// static members for the Profiler, but by using static global
// variables instead we are able to keep more of the implementation
// isolated.
static bool profiler_initialized_ = false;
static ros::Publisher profiler_index_pub_;
static ros::Publisher profiler_data_pub_;
static boost::thread profiler_thread_;
// collectAndPublish resets the closed_blocks_ member after each
// update to reduce the amount of copying done (which might block the
// threads doing actual work). The incremental snapshots are
// collected here in all_closed_blocks_;
static std::unordered_map<std::string, spm::ProfileData> all_closed_blocks_;
static ros::Duration durationFromWall(const ros::WallDuration &src)
{
return ros::Duration(src.sec, src.nsec);
}
static ros::Time timeFromWall(const ros::WallTime &src)
{
return ros::Time(src.sec, src.nsec);
}
void Profiler::initializeProfiler()
{
SpinLockGuard guard(lock_);
if (profiler_initialized_) {
return;
}
ROS_INFO("Initializing swri_profiler...");
ros::NodeHandle nh;
profiler_index_pub_ = nh.advertise<spm::ProfileIndexArray>("/profiler/index", 1, true);
profiler_data_pub_ = nh.advertise<spm::ProfileDataArray>("/profiler/data", 100, false);
profiler_thread_ = boost::thread(Profiler::profilerMain);
profiler_initialized_ = true;
}
void Profiler::initializeTLS()
{
if (tls_.get()) {
ROS_ERROR("Attempt to initialize thread local storage again.");
return;
}
tls_.reset(new TLS());
tls_->stack_depth = 0;
tls_->stack_str = "";
char buffer[256];
snprintf(buffer, sizeof(buffer), "%p/", tls_.get());
tls_->thread_prefix = std::string(buffer);
initializeProfiler();
}
void Profiler::profilerMain()
{
ROS_DEBUG("swri_profiler thread started.");
while (ros::ok()) {
// Align updates to approximately every second.
ros::WallTime now = ros::WallTime::now();
ros::WallTime next(now.sec+1,0);
(next-now).sleep();
collectAndPublish();
}
ROS_DEBUG("swri_profiler thread stopped.");
}
void Profiler::collectAndPublish()
{
static bool first_run = true;
static ros::WallTime last_now = ros::WallTime::now();
// Grab a snapshot of the current state.
std::unordered_map<std::string, ClosedInfo> new_closed_blocks;
std::unordered_map<std::string, OpenInfo> threaded_open_blocks;
ros::WallTime now = ros::WallTime::now();
ros::Time ros_now = ros::Time::now();
{
SpinLockGuard guard(lock_);
new_closed_blocks.swap(closed_blocks_);
for (auto &pair : open_blocks_) {
threaded_open_blocks[pair.first].t0 = pair.second.t0;
pair.second.last_report_time = now;
}
}
// Reset all relative max durations.
for (auto &pair : all_closed_blocks_) {
pair.second.rel_total_duration = ros::Duration(0);
pair.second.rel_max_duration = ros::Duration(0);
}
// Flag to indicate if a new item was added.
bool update_index = false;
// Merge the new stats into the absolute stats
for (auto const &pair : new_closed_blocks) {
const auto &label = pair.first;
const auto &new_info = pair.second;
auto &all_info = all_closed_blocks_[label];
if (all_info.key == 0) {
update_index = true;
all_info.key = all_closed_blocks_.size();
}
all_info.abs_call_count += new_info.count;
all_info.abs_total_duration += durationFromWall(new_info.total_duration);
all_info.rel_total_duration += durationFromWall(new_info.rel_duration);
all_info.rel_max_duration = std::max(all_info.rel_max_duration,
durationFromWall(new_info.max_duration));
}
// Combine the open blocks from all threads into a single
// map.
std::unordered_map<std::string, spm::ProfileData> combined_open_blocks;
for (auto const &pair : threaded_open_blocks) {
const auto &threaded_label = pair.first;
const auto &threaded_info = pair.second;
size_t slash_index = threaded_label.find('/');
if (slash_index == std::string::npos) {
ROS_ERROR("Missing expected slash in label: %s", threaded_label.c_str());
continue;
}
ros::Duration duration = durationFromWall(now - threaded_info.t0);
const auto label = threaded_label.substr(slash_index+1);
auto &new_info = combined_open_blocks[label];
if (new_info.key == 0) {
auto &all_info = all_closed_blocks_[label];
if (all_info.key == 0) {
update_index = true;
all_info.key = all_closed_blocks_.size();
}
new_info.key = all_info.key;
}
new_info.abs_call_count++;
new_info.abs_total_duration += duration;
if (first_run) {
new_info.rel_total_duration += duration;
} else {
new_info.rel_total_duration += std::min(
durationFromWall(now - last_now), duration);
}
new_info.rel_max_duration = std::max(new_info.rel_max_duration, duration);
}
if (update_index) {
spm::ProfileIndexArray index;
index.header.stamp = timeFromWall(now);
index.header.frame_id = ros::this_node::getName();
index.data.resize(all_closed_blocks_.size());
for (auto const &pair : all_closed_blocks_) {
size_t i = pair.second.key - 1;
index.data[i].key = pair.second.key;
index.data[i].label = pair.first;
}
profiler_index_pub_.publish(index);
}
// Generate output message
spm::ProfileDataArray msg;
msg.header.stamp = timeFromWall(now);
msg.header.frame_id = ros::this_node::getName();
msg.rostime_stamp = ros_now;
msg.data.resize(all_closed_blocks_.size());
for (auto &pair : all_closed_blocks_) {
auto const &item = pair.second;
size_t i = item.key - 1;
msg.data[i].key = item.key;
msg.data[i].abs_call_count = item.abs_call_count;
msg.data[i].abs_total_duration = item.abs_total_duration;
msg.data[i].rel_total_duration = item.rel_total_duration;
msg.data[i].rel_max_duration = item.rel_max_duration;
}
for (auto &pair : combined_open_blocks) {
auto const &item = pair.second;
size_t i = item.key - 1;
msg.data[i].abs_call_count += item.abs_call_count;
msg.data[i].abs_total_duration += item.abs_total_duration;
msg.data[i].rel_total_duration += item.rel_total_duration;
msg.data[i].rel_max_duration = std::max(
msg.data[i].rel_max_duration,
item.rel_max_duration);
}
profiler_data_pub_.publish(msg);
first_run = false;
last_now = now;
}
} // namespace swri_profiler
| 31.724444 | 89 | 0.704399 | swri-robotics |
e10c26a08ce13e087fe240989db7e3acd6449885 | 2,559 | cpp | C++ | tests/poker/hand.test.cpp | chevtek/poker | 66a1c4274508e055c4b987ab8271fa3e95238fba | [
"MIT"
] | null | null | null | tests/poker/hand.test.cpp | chevtek/poker | 66a1c4274508e055c4b987ab8271fa3e95238fba | [
"MIT"
] | null | null | null | tests/poker/hand.test.cpp | chevtek/poker | 66a1c4274508e055c4b987ab8271fa3e95238fba | [
"MIT"
] | 3 | 2020-08-27T19:12:56.000Z | 2022-03-09T11:13:46.000Z | #include <doctest/doctest.h>
#include <iostream>
#include <poker/hand.hpp>
#include <poker/debug/card.hpp>
#include <poker/debug/hand.hpp>
TEST_CASE("high/low hand evaluation") {
// TODO: test .cards() and .strength()
std::array<poker::card, 7> all_cards[] = {
poker::debug::make_cards<7>("Ac Ac Ac Ac Kc 2c 2c"),
poker::debug::make_cards<7>("Ac Ac Ac Kc Kc 2c 2c"),
poker::debug::make_cards<7>("Ac Ac Ac Kc Kc Kc 2c"),
poker::debug::make_cards<7>("Ac Ac Kc Kc 3c 2c 2c"),
poker::debug::make_cards<7>("Ac Ac Kc Qc Jc Tc 2c"),
poker::debug::make_cards<7>("Ac Kc Qc Jc 9c 8c 7c"),
};
const poker::hand hands[] = {
poker::hand::_high_low_hand_eval(all_cards[0]),
poker::hand::_high_low_hand_eval(all_cards[1]),
poker::hand::_high_low_hand_eval(all_cards[2]),
poker::hand::_high_low_hand_eval(all_cards[3]),
poker::hand::_high_low_hand_eval(all_cards[4]),
poker::hand::_high_low_hand_eval(all_cards[5]),
};
constexpr poker::hand_ranking hand_rankings[] = {
poker::hand_ranking::four_of_a_kind,
poker::hand_ranking::full_house,
poker::hand_ranking::three_of_a_kind,
poker::hand_ranking::two_pair,
poker::hand_ranking::pair,
poker::hand_ranking::high_card,
};
for (auto i = 0; i < std::size(hands); ++i) {
REQUIRE_EQ(hands[i].ranking(), hand_rankings[i]);
}
}
TEST_CASE("straight/flush hand evaluation") {
std::array<poker::card, 7> all_cards[] = {
poker::debug::make_cards<7>("Ac Qc Tc 9c 7h 2c 3h"),
poker::debug::make_cards<7>("Ts 9c 8d 7c 6h 4c 5h"),
poker::debug::make_cards<7>("As 2c 3d 4c 5h Kc Qh"),
poker::debug::make_cards<7>("Ks Qs Ts Js 9s 8s 7s"),
poker::debug::make_cards<7>("As Ks Qs Js Ts 8s 7s"),
};
const poker::hand hands[] = {
*poker::hand::_straight_flush_eval(all_cards[0]),
*poker::hand::_straight_flush_eval(all_cards[1]),
*poker::hand::_straight_flush_eval(all_cards[2]),
*poker::hand::_straight_flush_eval(all_cards[3]),
*poker::hand::_straight_flush_eval(all_cards[4]),
};
constexpr poker::hand_ranking hand_rankings[] = {
poker::hand_ranking::flush,
poker::hand_ranking::straight,
poker::hand_ranking::straight,
poker::hand_ranking::straight_flush,
poker::hand_ranking::royal_flush,
};
for (auto i = 0; i < std::size(hands); ++i) {
REQUIRE_EQ(hands[i].ranking(), hand_rankings[i]);
}
}
| 39.369231 | 60 | 0.619383 | chevtek |
e10c6016a4e6220a0aa7f1d0759cdfd2f7dfcaa5 | 436 | cpp | C++ | Source/FSD/Private/TerrainScannerSplineMesh.cpp | trumank/DRG-Mods | 2febc879f2ffe83498ac913c114d0e933427e93e | [
"MIT"
] | 8 | 2021-07-10T20:06:05.000Z | 2022-03-04T19:03:50.000Z | Source/FSD/Private/TerrainScannerSplineMesh.cpp | trumank/DRG-Mods | 2febc879f2ffe83498ac913c114d0e933427e93e | [
"MIT"
] | 9 | 2022-01-13T20:49:44.000Z | 2022-03-27T22:56:48.000Z | Source/FSD/Private/TerrainScannerSplineMesh.cpp | trumank/DRG-Mods | 2febc879f2ffe83498ac913c114d0e933427e93e | [
"MIT"
] | 2 | 2021-07-10T20:05:42.000Z | 2022-03-14T17:05:35.000Z | #include "TerrainScannerSplineMesh.h"
class UHealthComponentBase;
void UTerrainScannerSplineMesh::SetVisibleOnScanner(bool InShowOnScanner) {
}
void UTerrainScannerSplineMesh::OnOwnerDeath(UHealthComponentBase* InHealthComponent) {
}
UTerrainScannerSplineMesh::UTerrainScannerSplineMesh() {
this->bVisibleAtBeginPlay = true;
this->bHideOnDeath = true;
this->bUseFogOfWar = false;
this->bVisibleOnScanner = false;
}
| 24.222222 | 87 | 0.793578 | trumank |
e10e37cf375694158d00e2fbfb92448f6d45f770 | 1,356 | hpp | C++ | Sources/Models/Shapes/ModelRectangle.hpp | liuping1997/Acid | 0b28d63d03ead41047d5881f08e3b693a4e6e63f | [
"MIT"
] | null | null | null | Sources/Models/Shapes/ModelRectangle.hpp | liuping1997/Acid | 0b28d63d03ead41047d5881f08e3b693a4e6e63f | [
"MIT"
] | null | null | null | Sources/Models/Shapes/ModelRectangle.hpp | liuping1997/Acid | 0b28d63d03ead41047d5881f08e3b693a4e6e63f | [
"MIT"
] | null | null | null | #pragma once
#include "Models/Model.hpp"
namespace acid
{
/**
* @brief Resource that represents a rectangle model.
*/
class ACID_EXPORT ModelRectangle :
public Model
{
public:
/**
* Creates a new rectangle model, or finds one with the same values.
* @param metadata The metadata to decode values from.
* @return The rectangle model with the requested values.
*/
static std::shared_ptr<ModelRectangle> Create(const Metadata &metadata);
/**
* Creates a new rectangle model, or finds one with the same values.
* @param min The minimum extents.
* @param max The maximum extents.
* @return The rectangle model with the requested values.
*/
static std::shared_ptr<ModelRectangle> Create(const float &min = 0.0f, const float &max = 1.0f);
/**
* Creates a new rectangle model.
* @param min The minimum extents.
* @param max The maximum extents.
* @param load If this resource will be loaded immediately, otherwise {@link ModelRectangle#Load} can be called later.
*/
explicit ModelRectangle(const float &min = 0.0f, const float &max = 1.0f, const bool &load = true);
void Load() override;
ACID_EXPORT friend const Metadata &operator>>(const Metadata &metadata, ModelRectangle &model);
ACID_EXPORT friend Metadata &operator<<(Metadata &metadata, const ModelRectangle &model);
private:
float m_min;
float m_max;
};
}
| 28.25 | 119 | 0.724926 | liuping1997 |
e1112baf41ec4b8cc2b0a8e137c092d5342b50a5 | 1,266 | cpp | C++ | Level 3/Tableaux avances/Carre magique/main.cpp | Wurlosh/France-ioi | f5fb36003cbfc56a2e7cf64ad43c4452f086f198 | [
"MIT"
] | 31 | 2018-10-30T09:54:23.000Z | 2022-03-02T21:45:51.000Z | Level 3/Tableaux avances/Carre magique/main.cpp | Wurlosh/France-ioi | f5fb36003cbfc56a2e7cf64ad43c4452f086f198 | [
"MIT"
] | 2 | 2016-12-24T23:39:20.000Z | 2017-07-02T22:51:28.000Z | Level 3/Tableaux avances/Carre magique/main.cpp | Wurlosh/France-ioi | f5fb36003cbfc56a2e7cf64ad43c4452f086f198 | [
"MIT"
] | 30 | 2018-10-25T12:28:36.000Z | 2022-01-31T14:31:02.000Z | #include <bits/stdc++.h>
#define N 100
using namespace std;
int tab[N][N];
int v[100000]={0};
int main()
{
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
cin>>n;
for(int i=0;i<n;++i)
for(int j=0;j<n;++j)
cin>>tab[i][j];
int sum=0;
for(int i=0;i<n;++i)
for(int j=0;j<n;++j)
sum+=tab[i][j];
if(sum%n!=0)
{
cout<<"no"<<endl;
return 0;
}
sum/=n;
for(int i=0;i<n;++i)
{
int s=0;
for(int j=0;j<n;++j)
{
s+=tab[i][j];
}
if(s!=sum)
{
cout<<"no"<<endl;
return 0;
}
}
for(int j=0;j<n;++j)
{
int s=0;
for(int i=0;i<n;++i)
s+=tab[i][j];
if(s!=sum)
{
cout<<"no"<<endl;
return 0;
}
}
int s1=0,s2=0;
for(int i=0;i<n;++i)
{
s1+=tab[i][i];
s2+=tab[i][n-i-1];
}
if(s1!=sum || s2!=sum)
{
cout<<"no"<<endl;
return 0;
}
for(int i=0;i<n;++i)
for(int j=0;j<n;++j)
if(tab[i][j]>=1 && tab[i][j]<=n*n)
v[tab[i][j]]++;
for(int i=1;i<=n*n;++i)
if(v[i]!=1)
{
cout<<"no"<<endl;
return 0;
}
cout<<"yes"<<endl;
return 0;
}
| 16.441558 | 43 | 0.375197 | Wurlosh |
e113f125c283860e3d2712da7620a96eb30d985f | 5,540 | cxx | C++ | main/sdext/source/presenter/PresenterPaintManager.cxx | Grosskopf/openoffice | 93df6e8a695d5e3eac16f3ad5e9ade1b963ab8d7 | [
"Apache-2.0"
] | 679 | 2015-01-06T06:34:58.000Z | 2022-03-30T01:06:03.000Z | main/sdext/source/presenter/PresenterPaintManager.cxx | Grosskopf/openoffice | 93df6e8a695d5e3eac16f3ad5e9ade1b963ab8d7 | [
"Apache-2.0"
] | 102 | 2017-11-07T08:51:31.000Z | 2022-03-17T12:13:49.000Z | main/sdext/source/presenter/PresenterPaintManager.cxx | Grosskopf/openoffice | 93df6e8a695d5e3eac16f3ad5e9ade1b963ab8d7 | [
"Apache-2.0"
] | 331 | 2015-01-06T11:40:55.000Z | 2022-03-14T04:07:51.000Z | /**************************************************************
*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you 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 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.
*
*************************************************************/
// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_sdext.hxx"
#include "PresenterPaintManager.hxx"
#include "PresenterPaneContainer.hxx"
#include <com/sun/star/awt/InvalidateStyle.hpp>
#include <com/sun/star/awt/XWindowPeer.hpp>
#include <boost/bind.hpp>
using namespace ::com::sun::star;
using namespace ::com::sun::star::uno;
namespace sdext { namespace presenter {
PresenterPaintManager::PresenterPaintManager (
const css::uno::Reference<css::awt::XWindow>& rxParentWindow,
const css::uno::Reference<css::drawing::XPresenterHelper>& rxPresenterHelper,
const rtl::Reference<PresenterPaneContainer>& rpPaneContainer)
: mxParentWindow(rxParentWindow),
mxParentWindowPeer(rxParentWindow, UNO_QUERY),
mxPresenterHelper(rxPresenterHelper),
mpPaneContainer(rpPaneContainer)
{
}
::boost::function<void(const css::awt::Rectangle& rRepaintBox)>
PresenterPaintManager::GetInvalidator (
const css::uno::Reference<css::awt::XWindow>& rxWindow,
const bool bSynchronous)
{
return ::boost::bind(
static_cast<void (PresenterPaintManager::*)(
const css::uno::Reference<css::awt::XWindow>&,
const css::awt::Rectangle&,
const bool)>(&PresenterPaintManager::Invalidate),
this,
rxWindow,
_1,
bSynchronous);
}
void PresenterPaintManager::Invalidate (
const css::uno::Reference<css::awt::XWindow>& rxWindow,
const bool bSynchronous)
{
sal_Int16 nInvalidateMode (awt::InvalidateStyle::CHILDREN);
if (bSynchronous)
nInvalidateMode |= awt::InvalidateStyle::UPDATE;
PresenterPaneContainer::SharedPaneDescriptor pDescriptor(
mpPaneContainer->FindContentWindow(rxWindow));
if (pDescriptor.get()==NULL || ! pDescriptor->mbIsOpaque)
nInvalidateMode |= awt::InvalidateStyle::TRANSPARENT;
else
nInvalidateMode |= awt::InvalidateStyle::NOTRANSPARENT;
Invalidate(rxWindow, nInvalidateMode);
}
void PresenterPaintManager::Invalidate (
const css::uno::Reference<css::awt::XWindow>& rxWindow,
const sal_Int16 nInvalidateFlags)
{
if ((nInvalidateFlags & awt::InvalidateStyle::TRANSPARENT) != 0)
{
// Window is transparent and parent window(s) have to be painted as
// well. Invalidate the parent explicitly.
if (mxPresenterHelper.is() && mxParentWindowPeer.is())
{
const awt::Rectangle aBBox (
mxPresenterHelper->getWindowExtentsRelative(rxWindow, mxParentWindow));
mxParentWindowPeer->invalidateRect(aBBox, nInvalidateFlags);
}
}
else
{
Reference<awt::XWindowPeer> xPeer (rxWindow, UNO_QUERY);
if (xPeer.is())
xPeer->invalidate(nInvalidateFlags);
}
}
void PresenterPaintManager::Invalidate (
const css::uno::Reference<css::awt::XWindow>& rxWindow,
const css::awt::Rectangle& rRepaintBox,
const bool bSynchronous)
{
sal_Int16 nInvalidateMode (awt::InvalidateStyle::CHILDREN);
if (bSynchronous)
nInvalidateMode |= awt::InvalidateStyle::UPDATE;
PresenterPaneContainer::SharedPaneDescriptor pDescriptor(
mpPaneContainer->FindContentWindow(rxWindow));
if (pDescriptor.get()==NULL || ! pDescriptor->mbIsOpaque)
nInvalidateMode |= awt::InvalidateStyle::TRANSPARENT;
else
nInvalidateMode |= awt::InvalidateStyle::NOTRANSPARENT;
Invalidate(rxWindow, rRepaintBox, nInvalidateMode);
}
void PresenterPaintManager::Invalidate (
const css::uno::Reference<css::awt::XWindow>& rxWindow,
const css::awt::Rectangle& rRepaintBox,
const sal_Int16 nInvalidateFlags)
{
if ((nInvalidateFlags & awt::InvalidateStyle::TRANSPARENT) != 0)
{
// Window is transparent and parent window(s) have to be painted as
// well. Invalidate the parent explicitly.
if (mxPresenterHelper.is() && mxParentWindowPeer.is())
{
const awt::Rectangle aBBox (
mxPresenterHelper->getWindowExtentsRelative(rxWindow, mxParentWindow));
mxParentWindowPeer->invalidateRect(
awt::Rectangle(
rRepaintBox.X + aBBox.X,
rRepaintBox.Y + aBBox.Y,
rRepaintBox.Width,
rRepaintBox.Height),
nInvalidateFlags);
}
}
else
{
Reference<awt::XWindowPeer> xPeer (rxWindow, UNO_QUERY);
if (xPeer.is())
xPeer->invalidateRect(rRepaintBox, nInvalidateFlags);
}
}
} }
| 32.209302 | 87 | 0.66444 | Grosskopf |
e11559364997b73adc6c936e04e5cfdde8fdf4a9 | 891 | cpp | C++ | Dynamic Programming/Longest Increasing Subsequence/SolutionbyPooja.cpp | Mdanish777/Programmers-Community | b5ca9582fc1cd4337baa7077ff62130a1052583f | [
"MIT"
] | 261 | 2019-09-30T19:47:29.000Z | 2022-03-29T18:20:07.000Z | Dynamic Programming/Longest Increasing Subsequence/SolutionbyPooja.cpp | Mdanish777/Programmers-Community | b5ca9582fc1cd4337baa7077ff62130a1052583f | [
"MIT"
] | 647 | 2019-10-01T16:51:29.000Z | 2021-12-16T20:39:44.000Z | Dynamic Programming/Longest Increasing Subsequence/SolutionbyPooja.cpp | Mdanish777/Programmers-Community | b5ca9582fc1cd4337baa7077ff62130a1052583f | [
"MIT"
] | 383 | 2019-09-30T19:32:07.000Z | 2022-03-24T16:18:26.000Z | /*
A Sequence is given and you need to find the length of the longest subsequence of a given sequence such that all elements of the subsequence are
sorted in increasing order.
Input : {3, 10, 2, 1, 20}
Output : 3
*/
#include <cstring>
#include <iostream>
using namespace std;
int t[1001][1001];
int max(int a, int b)
{
return a > b ? a : b;
}
int LIS(int* X, int m, int n)
{
if (m == 0 || n == 0)
return 0;
if (t[m][n] != -1)
return t[m][n];
if (X[n - 1] >= X[m - 1])
return t[m][n] = max(1 + LIS(X, m - 1, m), LIS(X, m - 1, n));
else
return t[m][n] = LIS(X, m - 1, n);
}
int main()
{
int N;
cout << "Size ? ";
cin >> N;
cout << "Enter Sequence ";
int* arr = new int[N];
memset(t, -1, sizeof(t));
for (int i = 0; i < N; i++)
cin >> arr[i];
cout << LIS(arr, N, N);
}
| 18.5625 | 148 | 0.494949 | Mdanish777 |
e11636f0f73d467d88bd28836a94f291a44e3766 | 28,577 | hpp | C++ | boost/lib/include/boost/geometry/index/detail/rtree/rstar/insert.hpp | mamil/demo | 32240d95b80175549e6a1904699363ce672a1591 | [
"MIT"
] | 101 | 2019-02-12T12:53:18.000Z | 2022-03-14T14:14:38.000Z | boost/lib/include/boost/geometry/index/detail/rtree/rstar/insert.hpp | mamil/demo | 32240d95b80175549e6a1904699363ce672a1591 | [
"MIT"
] | 157 | 2019-02-06T05:04:20.000Z | 2022-03-31T21:50:28.000Z | boost/lib/include/boost/geometry/index/detail/rtree/rstar/insert.hpp | mamil/demo | 32240d95b80175549e6a1904699363ce672a1591 | [
"MIT"
] | 15 | 2019-05-11T04:03:35.000Z | 2022-02-12T18:53:47.000Z | // Boost.Geometry Index
//
// R-tree R*-tree insert algorithm implementation
//
// Copyright (c) 2011-2015 Adam Wulkiewicz, Lodz, Poland.
//
// This file was modified by Oracle on 2019.
// Modifications copyright (c) 2019 Oracle and/or its affiliates.
// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
//
// Use, modification and distribution is subject to the Boost Software License,
// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#ifndef BOOST_GEOMETRY_INDEX_DETAIL_RTREE_RSTAR_INSERT_HPP
#define BOOST_GEOMETRY_INDEX_DETAIL_RTREE_RSTAR_INSERT_HPP
#include <boost/core/ignore_unused.hpp>
#include <boost/geometry/index/detail/algorithms/content.hpp>
namespace boost { namespace geometry { namespace index {
namespace detail { namespace rtree { namespace visitors {
namespace rstar {
// Utility to distinguish between default and non-default index strategy
template <typename Point1, typename Point2, typename Strategy>
struct comparable_distance_point_point
{
typedef typename Strategy::comparable_distance_point_point_strategy_type strategy_type;
typedef typename geometry::comparable_distance_result
<
Point1, Point2, strategy_type
>::type result_type;
static inline strategy_type get_strategy(Strategy const& strategy)
{
return strategy.get_comparable_distance_point_point_strategy();
}
};
template <typename Point1, typename Point2>
struct comparable_distance_point_point<Point1, Point2, default_strategy>
{
typedef default_strategy strategy_type;
typedef typename geometry::default_comparable_distance_result
<
Point1, Point2
>::type result_type;
static inline strategy_type get_strategy(default_strategy const& )
{
return strategy_type();
}
};
template <typename MembersHolder>
class remove_elements_to_reinsert
{
public:
typedef typename MembersHolder::box_type box_type;
typedef typename MembersHolder::parameters_type parameters_type;
typedef typename MembersHolder::translator_type translator_type;
typedef typename MembersHolder::allocators_type allocators_type;
typedef typename MembersHolder::node node;
typedef typename MembersHolder::internal_node internal_node;
typedef typename MembersHolder::leaf leaf;
//typedef typename Allocators::internal_node_pointer internal_node_pointer;
typedef internal_node * internal_node_pointer;
template <typename ResultElements, typename Node>
static inline void apply(ResultElements & result_elements,
Node & n,
internal_node_pointer parent,
size_t current_child_index,
parameters_type const& parameters,
translator_type const& translator,
allocators_type & allocators)
{
typedef typename rtree::elements_type<Node>::type elements_type;
typedef typename elements_type::value_type element_type;
typedef typename geometry::point_type<box_type>::type point_type;
typedef typename index::detail::strategy_type<parameters_type>::type strategy_type;
// TODO: awulkiew - change second point_type to the point type of the Indexable?
typedef rstar::comparable_distance_point_point
<
point_type, point_type, strategy_type
> comparable_distance_pp;
typedef typename comparable_distance_pp::result_type comparable_distance_type;
elements_type & elements = rtree::elements(n);
const size_t elements_count = parameters.get_max_elements() + 1;
const size_t reinserted_elements_count = (::std::min)(parameters.get_reinserted_elements(), elements_count - parameters.get_min_elements());
BOOST_GEOMETRY_INDEX_ASSERT(parent, "node shouldn't be the root node");
BOOST_GEOMETRY_INDEX_ASSERT(elements.size() == elements_count, "unexpected elements number");
BOOST_GEOMETRY_INDEX_ASSERT(0 < reinserted_elements_count, "wrong value of elements to reinsert");
// calculate current node's center
point_type node_center;
geometry::centroid(rtree::elements(*parent)[current_child_index].first, node_center);
// fill the container of centers' distances of children from current node's center
typedef typename index::detail::rtree::container_from_elements_type<
elements_type,
std::pair<comparable_distance_type, element_type>
>::type sorted_elements_type;
sorted_elements_type sorted_elements;
// If constructor is used instead of resize() MS implementation leaks here
sorted_elements.reserve(elements_count); // MAY THROW, STRONG (V, E: alloc, copy)
typename comparable_distance_pp::strategy_type
cdist_strategy = comparable_distance_pp::get_strategy(index::detail::get_strategy(parameters));
for ( typename elements_type::const_iterator it = elements.begin() ;
it != elements.end() ; ++it )
{
point_type element_center;
geometry::centroid( rtree::element_indexable(*it, translator), element_center);
sorted_elements.push_back(std::make_pair(
geometry::comparable_distance(node_center, element_center, cdist_strategy),
*it)); // MAY THROW (V, E: copy)
}
// sort elements by distances from center
std::partial_sort(
sorted_elements.begin(),
sorted_elements.begin() + reinserted_elements_count,
sorted_elements.end(),
distances_dsc<comparable_distance_type, element_type>); // MAY THROW, BASIC (V, E: copy)
// copy elements which will be reinserted
result_elements.clear();
result_elements.reserve(reinserted_elements_count); // MAY THROW, STRONG (V, E: alloc, copy)
for ( typename sorted_elements_type::const_iterator it = sorted_elements.begin() ;
it != sorted_elements.begin() + reinserted_elements_count ; ++it )
{
result_elements.push_back(it->second); // MAY THROW (V, E: copy)
}
BOOST_TRY
{
// copy remaining elements to the current node
elements.clear();
elements.reserve(elements_count - reinserted_elements_count); // SHOULDN'T THROW (new_size <= old size)
for ( typename sorted_elements_type::const_iterator it = sorted_elements.begin() + reinserted_elements_count;
it != sorted_elements.end() ; ++it )
{
elements.push_back(it->second); // MAY THROW (V, E: copy)
}
}
BOOST_CATCH(...)
{
elements.clear();
for ( typename sorted_elements_type::iterator it = sorted_elements.begin() ;
it != sorted_elements.end() ; ++it )
{
destroy_element<MembersHolder>::apply(it->second, allocators);
}
BOOST_RETHROW // RETHROW
}
BOOST_CATCH_END
::boost::ignore_unused(parameters);
}
private:
template <typename Distance, typename El>
static inline bool distances_asc(
std::pair<Distance, El> const& d1,
std::pair<Distance, El> const& d2)
{
return d1.first < d2.first;
}
template <typename Distance, typename El>
static inline bool distances_dsc(
std::pair<Distance, El> const& d1,
std::pair<Distance, El> const& d2)
{
return d1.first > d2.first;
}
};
template
<
size_t InsertIndex,
typename Element,
typename MembersHolder,
bool IsValue = boost::is_same<Element, typename MembersHolder::value_type>::value
>
struct level_insert_elements_type
{
typedef typename rtree::elements_type<
typename rtree::internal_node<
typename MembersHolder::value_type,
typename MembersHolder::parameters_type,
typename MembersHolder::box_type,
typename MembersHolder::allocators_type,
typename MembersHolder::node_tag
>::type
>::type type;
};
template <typename Value, typename MembersHolder>
struct level_insert_elements_type<0, Value, MembersHolder, true>
{
typedef typename rtree::elements_type<
typename rtree::leaf<
typename MembersHolder::value_type,
typename MembersHolder::parameters_type,
typename MembersHolder::box_type,
typename MembersHolder::allocators_type,
typename MembersHolder::node_tag
>::type
>::type type;
};
template <size_t InsertIndex, typename Element, typename MembersHolder>
struct level_insert_base
: public detail::insert<Element, MembersHolder>
{
typedef detail::insert<Element, MembersHolder> base;
typedef typename base::node node;
typedef typename base::internal_node internal_node;
typedef typename base::leaf leaf;
typedef typename level_insert_elements_type<InsertIndex, Element, MembersHolder>::type elements_type;
typedef typename index::detail::rtree::container_from_elements_type<
elements_type,
typename elements_type::value_type
>::type result_elements_type;
typedef typename MembersHolder::box_type box_type;
typedef typename MembersHolder::parameters_type parameters_type;
typedef typename MembersHolder::translator_type translator_type;
typedef typename MembersHolder::allocators_type allocators_type;
typedef typename allocators_type::node_pointer node_pointer;
typedef typename allocators_type::size_type size_type;
inline level_insert_base(node_pointer & root,
size_type & leafs_level,
Element const& element,
parameters_type const& parameters,
translator_type const& translator,
allocators_type & allocators,
size_type relative_level)
: base(root, leafs_level, element, parameters, translator, allocators, relative_level)
, result_relative_level(0)
{}
template <typename Node>
inline void handle_possible_reinsert_or_split_of_root(Node &n)
{
BOOST_GEOMETRY_INDEX_ASSERT(result_elements.empty(), "reinsert should be handled only once for level");
result_relative_level = base::m_leafs_level - base::m_traverse_data.current_level;
// overflow
if ( base::m_parameters.get_max_elements() < rtree::elements(n).size() )
{
// node isn't root node
if ( !base::m_traverse_data.current_is_root() )
{
// NOTE: exception-safety
// After an exception result_elements may contain garbage, don't use it
rstar::remove_elements_to_reinsert<MembersHolder>::apply(
result_elements, n,
base::m_traverse_data.parent, base::m_traverse_data.current_child_index,
base::m_parameters, base::m_translator, base::m_allocators); // MAY THROW, BASIC (V, E: alloc, copy)
}
// node is root node
else
{
BOOST_GEOMETRY_INDEX_ASSERT(&n == &rtree::get<Node>(*base::m_root_node), "node should be the root node");
base::split(n); // MAY THROW (V, E: alloc, copy, N: alloc)
}
}
}
template <typename Node>
inline void handle_possible_split(Node &n) const
{
// overflow
if ( base::m_parameters.get_max_elements() < rtree::elements(n).size() )
{
base::split(n); // MAY THROW (V, E: alloc, copy, N: alloc)
}
}
template <typename Node>
inline void recalculate_aabb_if_necessary(Node const& n) const
{
if ( !result_elements.empty() && !base::m_traverse_data.current_is_root() )
{
// calulate node's new box
recalculate_aabb(n);
}
}
template <typename Node>
inline void recalculate_aabb(Node const& n) const
{
base::m_traverse_data.current_element().first =
elements_box<box_type>(rtree::elements(n).begin(), rtree::elements(n).end(),
base::m_translator,
index::detail::get_strategy(base::m_parameters));
}
inline void recalculate_aabb(leaf const& n) const
{
base::m_traverse_data.current_element().first =
values_box<box_type>(rtree::elements(n).begin(), rtree::elements(n).end(),
base::m_translator,
index::detail::get_strategy(base::m_parameters));
}
size_type result_relative_level;
result_elements_type result_elements;
};
template
<
size_t InsertIndex,
typename Element,
typename MembersHolder,
bool IsValue = boost::is_same<Element, typename MembersHolder::value_type>::value
>
struct level_insert
: public level_insert_base<InsertIndex, Element, MembersHolder>
{
typedef level_insert_base<InsertIndex, Element, MembersHolder> base;
typedef typename base::node node;
typedef typename base::internal_node internal_node;
typedef typename base::leaf leaf;
typedef typename base::parameters_type parameters_type;
typedef typename base::translator_type translator_type;
typedef typename base::allocators_type allocators_type;
typedef typename base::node_pointer node_pointer;
typedef typename base::size_type size_type;
inline level_insert(node_pointer & root,
size_type & leafs_level,
Element const& element,
parameters_type const& parameters,
translator_type const& translator,
allocators_type & allocators,
size_type relative_level)
: base(root, leafs_level, element, parameters, translator, allocators, relative_level)
{}
inline void operator()(internal_node & n)
{
BOOST_GEOMETRY_INDEX_ASSERT(base::m_traverse_data.current_level < base::m_leafs_level, "unexpected level");
if ( base::m_traverse_data.current_level < base::m_level )
{
// next traversing step
base::traverse(*this, n); // MAY THROW (E: alloc, copy, N: alloc)
// further insert
if ( 0 < InsertIndex )
{
BOOST_GEOMETRY_INDEX_ASSERT(0 < base::m_level, "illegal level value, level shouldn't be the root level for 0 < InsertIndex");
if ( base::m_traverse_data.current_level == base::m_level - 1 )
{
base::handle_possible_reinsert_or_split_of_root(n); // MAY THROW (E: alloc, copy, N: alloc)
}
}
}
else
{
BOOST_GEOMETRY_INDEX_ASSERT(base::m_level == base::m_traverse_data.current_level, "unexpected level");
BOOST_TRY
{
// push new child node
rtree::elements(n).push_back(base::m_element); // MAY THROW, STRONG (E: alloc, copy)
}
BOOST_CATCH(...)
{
// NOTE: exception-safety
// if the insert fails above, the element won't be stored in the tree, so delete it
rtree::visitors::destroy<MembersHolder>::apply(base::m_element.second, base::m_allocators);
BOOST_RETHROW // RETHROW
}
BOOST_CATCH_END
// first insert
if ( 0 == InsertIndex )
{
base::handle_possible_reinsert_or_split_of_root(n); // MAY THROW (E: alloc, copy, N: alloc)
}
// not the first insert
else
{
base::handle_possible_split(n); // MAY THROW (E: alloc, N: alloc)
}
}
base::recalculate_aabb_if_necessary(n);
}
inline void operator()(leaf &)
{
BOOST_GEOMETRY_INDEX_ASSERT(false, "this visitor can't be used for a leaf");
}
};
template <size_t InsertIndex, typename Value, typename MembersHolder>
struct level_insert<InsertIndex, Value, MembersHolder, true>
: public level_insert_base<InsertIndex, typename MembersHolder::value_type, MembersHolder>
{
typedef level_insert_base<InsertIndex, typename MembersHolder::value_type, MembersHolder> base;
typedef typename base::node node;
typedef typename base::internal_node internal_node;
typedef typename base::leaf leaf;
typedef typename MembersHolder::value_type value_type;
typedef typename base::parameters_type parameters_type;
typedef typename base::translator_type translator_type;
typedef typename base::allocators_type allocators_type;
typedef typename base::node_pointer node_pointer;
typedef typename base::size_type size_type;
inline level_insert(node_pointer & root,
size_type & leafs_level,
value_type const& v,
parameters_type const& parameters,
translator_type const& translator,
allocators_type & allocators,
size_type relative_level)
: base(root, leafs_level, v, parameters, translator, allocators, relative_level)
{}
inline void operator()(internal_node & n)
{
BOOST_GEOMETRY_INDEX_ASSERT(base::m_traverse_data.current_level < base::m_leafs_level, "unexpected level");
BOOST_GEOMETRY_INDEX_ASSERT(base::m_traverse_data.current_level < base::m_level, "unexpected level");
// next traversing step
base::traverse(*this, n); // MAY THROW (V, E: alloc, copy, N: alloc)
BOOST_GEOMETRY_INDEX_ASSERT(0 < base::m_level, "illegal level value, level shouldn't be the root level for 0 < InsertIndex");
if ( base::m_traverse_data.current_level == base::m_level - 1 )
{
base::handle_possible_reinsert_or_split_of_root(n); // MAY THROW (E: alloc, copy, N: alloc)
}
base::recalculate_aabb_if_necessary(n);
}
inline void operator()(leaf & n)
{
BOOST_GEOMETRY_INDEX_ASSERT(base::m_traverse_data.current_level == base::m_leafs_level,
"unexpected level");
BOOST_GEOMETRY_INDEX_ASSERT(base::m_level == base::m_traverse_data.current_level ||
base::m_level == (std::numeric_limits<size_t>::max)(),
"unexpected level");
rtree::elements(n).push_back(base::m_element); // MAY THROW, STRONG (V: alloc, copy)
base::handle_possible_split(n); // MAY THROW (V: alloc, copy, N: alloc)
}
};
template <typename Value, typename MembersHolder>
struct level_insert<0, Value, MembersHolder, true>
: public level_insert_base<0, typename MembersHolder::value_type, MembersHolder>
{
typedef level_insert_base<0, typename MembersHolder::value_type, MembersHolder> base;
typedef typename base::node node;
typedef typename base::internal_node internal_node;
typedef typename base::leaf leaf;
typedef typename MembersHolder::value_type value_type;
typedef typename base::parameters_type parameters_type;
typedef typename base::translator_type translator_type;
typedef typename base::allocators_type allocators_type;
typedef typename base::node_pointer node_pointer;
typedef typename base::size_type size_type;
inline level_insert(node_pointer & root,
size_type & leafs_level,
value_type const& v,
parameters_type const& parameters,
translator_type const& translator,
allocators_type & allocators,
size_type relative_level)
: base(root, leafs_level, v, parameters, translator, allocators, relative_level)
{}
inline void operator()(internal_node & n)
{
BOOST_GEOMETRY_INDEX_ASSERT(base::m_traverse_data.current_level < base::m_leafs_level,
"unexpected level");
BOOST_GEOMETRY_INDEX_ASSERT(base::m_traverse_data.current_level < base::m_level,
"unexpected level");
// next traversing step
base::traverse(*this, n); // MAY THROW (V: alloc, copy, N: alloc)
base::recalculate_aabb_if_necessary(n);
}
inline void operator()(leaf & n)
{
BOOST_GEOMETRY_INDEX_ASSERT(base::m_traverse_data.current_level == base::m_leafs_level,
"unexpected level");
BOOST_GEOMETRY_INDEX_ASSERT(base::m_level == base::m_traverse_data.current_level ||
base::m_level == (std::numeric_limits<size_t>::max)(),
"unexpected level");
rtree::elements(n).push_back(base::m_element); // MAY THROW, STRONG (V: alloc, copy)
base::handle_possible_reinsert_or_split_of_root(n); // MAY THROW (V: alloc, copy, N: alloc)
base::recalculate_aabb_if_necessary(n);
}
};
} // namespace rstar
// R*-tree insert visitor
// After passing the Element to insert visitor the Element is managed by the tree
// I.e. one should not delete the node passed to the insert visitor after exception is thrown
// because this visitor may delete it
template <typename Element, typename MembersHolder>
class insert<Element, MembersHolder, insert_reinsert_tag>
: public MembersHolder::visitor
{
typedef typename MembersHolder::parameters_type parameters_type;
typedef typename MembersHolder::translator_type translator_type;
typedef typename MembersHolder::allocators_type allocators_type;
typedef typename MembersHolder::node node;
typedef typename MembersHolder::internal_node internal_node;
typedef typename MembersHolder::leaf leaf;
typedef typename allocators_type::node_pointer node_pointer;
typedef typename allocators_type::size_type size_type;
public:
inline insert(node_pointer & root,
size_type & leafs_level,
Element const& element,
parameters_type const& parameters,
translator_type const& translator,
allocators_type & allocators,
size_type relative_level = 0)
: m_root(root), m_leafs_level(leafs_level), m_element(element)
, m_parameters(parameters), m_translator(translator)
, m_relative_level(relative_level), m_allocators(allocators)
{}
inline void operator()(internal_node & n)
{
boost::ignore_unused(n);
BOOST_GEOMETRY_INDEX_ASSERT(&n == &rtree::get<internal_node>(*m_root), "current node should be the root");
// Distinguish between situation when reinserts are required and use adequate visitor, otherwise use default one
if ( m_parameters.get_reinserted_elements() > 0 )
{
rstar::level_insert<0, Element, MembersHolder> lins_v(
m_root, m_leafs_level, m_element, m_parameters, m_translator, m_allocators, m_relative_level);
rtree::apply_visitor(lins_v, *m_root); // MAY THROW (V, E: alloc, copy, N: alloc)
if ( !lins_v.result_elements.empty() )
{
recursive_reinsert(lins_v.result_elements, lins_v.result_relative_level); // MAY THROW (V, E: alloc, copy, N: alloc)
}
}
else
{
visitors::insert<Element, MembersHolder, insert_default_tag> ins_v(
m_root, m_leafs_level, m_element, m_parameters, m_translator, m_allocators, m_relative_level);
rtree::apply_visitor(ins_v, *m_root);
}
}
inline void operator()(leaf & n)
{
boost::ignore_unused(n);
BOOST_GEOMETRY_INDEX_ASSERT(&n == &rtree::get<leaf>(*m_root), "current node should be the root");
// Distinguish between situation when reinserts are required and use adequate visitor, otherwise use default one
if ( m_parameters.get_reinserted_elements() > 0 )
{
rstar::level_insert<0, Element, MembersHolder> lins_v(
m_root, m_leafs_level, m_element, m_parameters, m_translator, m_allocators, m_relative_level);
rtree::apply_visitor(lins_v, *m_root); // MAY THROW (V, E: alloc, copy, N: alloc)
// we're in the root, so root should be split and there should be no elements to reinsert
BOOST_GEOMETRY_INDEX_ASSERT(lins_v.result_elements.empty(), "unexpected state");
}
else
{
visitors::insert<Element, MembersHolder, insert_default_tag> ins_v(
m_root, m_leafs_level, m_element, m_parameters, m_translator, m_allocators, m_relative_level);
rtree::apply_visitor(ins_v, *m_root);
}
}
private:
template <typename Elements>
inline void recursive_reinsert(Elements & elements, size_t relative_level)
{
typedef typename Elements::value_type element_type;
// reinsert children starting from the minimum distance
typename Elements::reverse_iterator it = elements.rbegin();
for ( ; it != elements.rend() ; ++it)
{
rstar::level_insert<1, element_type, MembersHolder> lins_v(
m_root, m_leafs_level, *it, m_parameters, m_translator, m_allocators, relative_level);
BOOST_TRY
{
rtree::apply_visitor(lins_v, *m_root); // MAY THROW (V, E: alloc, copy, N: alloc)
}
BOOST_CATCH(...)
{
++it;
for ( ; it != elements.rend() ; ++it)
rtree::destroy_element<MembersHolder>::apply(*it, m_allocators);
BOOST_RETHROW // RETHROW
}
BOOST_CATCH_END
BOOST_GEOMETRY_INDEX_ASSERT(relative_level + 1 == lins_v.result_relative_level, "unexpected level");
// non-root relative level
if ( lins_v.result_relative_level < m_leafs_level && !lins_v.result_elements.empty())
{
recursive_reinsert(lins_v.result_elements, lins_v.result_relative_level); // MAY THROW (V, E: alloc, copy, N: alloc)
}
}
}
node_pointer & m_root;
size_type & m_leafs_level;
Element const& m_element;
parameters_type const& m_parameters;
translator_type const& m_translator;
size_type m_relative_level;
allocators_type & m_allocators;
};
}}} // namespace detail::rtree::visitors
}}} // namespace boost::geometry::index
#endif // BOOST_GEOMETRY_INDEX_DETAIL_RTREE_RSTAR_INSERT_HPP
| 42.148968 | 154 | 0.608461 | mamil |
e116df43d7092dad93ba55cf5d14982f0b41c639 | 871 | hpp | C++ | src/include/guinsoodb/main/relation/subquery_relation.hpp | GuinsooLab/guinsoodb | f200538868738ae460f62fb89211deec946cefff | [
"MIT"
] | 1 | 2021-04-22T05:41:54.000Z | 2021-04-22T05:41:54.000Z | src/include/guinsoodb/main/relation/subquery_relation.hpp | GuinsooLab/guinsoodb | f200538868738ae460f62fb89211deec946cefff | [
"MIT"
] | null | null | null | src/include/guinsoodb/main/relation/subquery_relation.hpp | GuinsooLab/guinsoodb | f200538868738ae460f62fb89211deec946cefff | [
"MIT"
] | 1 | 2021-12-12T10:24:57.000Z | 2021-12-12T10:24:57.000Z | //===----------------------------------------------------------------------===//
// GuinsooDB
//
// guinsoodb/main/relation/subquery_relation.hpp
//
//
//===----------------------------------------------------------------------===//
#pragma once
#include "guinsoodb/main/relation.hpp"
namespace guinsoodb {
class SubqueryRelation : public Relation {
public:
SubqueryRelation(shared_ptr<Relation> child, string alias);
shared_ptr<Relation> child;
string alias;
public:
unique_ptr<QueryNode> GetQueryNode() override;
const vector<ColumnDefinition> &Columns() override;
string ToString(idx_t depth) override;
string GetAlias() override;
public:
bool InheritsColumnBindings() override {
return child->InheritsColumnBindings();
}
Relation *ChildRelation() override {
return child->ChildRelation();
}
};
} // namespace guinsoodb
| 22.333333 | 80 | 0.595867 | GuinsooLab |
e1170471f7a5a1e79d564a37e4febb3ea3e76907 | 6,427 | cpp | C++ | hackathon/zhi/IVSCC_scaling_swc/IVSCC_scaling_plugin.cpp | zzhmark/vaa3d_tools | 3ca418add85a59ac7e805d55a600b78330d7e53d | [
"MIT"
] | 1 | 2021-12-27T19:14:03.000Z | 2021-12-27T19:14:03.000Z | hackathon/zhi/IVSCC_scaling_swc/IVSCC_scaling_plugin.cpp | zzhmark/vaa3d_tools | 3ca418add85a59ac7e805d55a600b78330d7e53d | [
"MIT"
] | null | null | null | hackathon/zhi/IVSCC_scaling_swc/IVSCC_scaling_plugin.cpp | zzhmark/vaa3d_tools | 3ca418add85a59ac7e805d55a600b78330d7e53d | [
"MIT"
] | null | null | null | /* IVSCC_scaling_plugin.cpp
* This is a test plugin, you can use it as a demo.
* 2014-10-30 : by Zhi Zhou
*/
#include "v3d_message.h"
#include <vector>
#include "IVSCC_scaling_plugin.h"
#include <iostream>
#include "../IVSCC_sort_swc/openSWCDialog.h"
#include "ui_SWC_scaling.h"
using namespace std;
Q_EXPORT_PLUGIN2(IVSCC_scaling, IVSCC_scaling);
QStringList IVSCC_scaling::menulist() const
{
return QStringList()
<<("scale swc")
<<tr("about");
}
QStringList IVSCC_scaling::funclist() const
{
return QStringList()
<<tr("scale")
<<tr("fmost_scale")
<<tr("help");
}
void IVSCC_scaling::domenu(const QString &menu_name, V3DPluginCallback2 &callback, QWidget *parent)
{
if (menu_name == tr("scale swc")) // As per annotation team's request, an UI is added. MK, Oct, 2017.
{
swcScalingUI* inputForm = new swcScalingUI(0, &callback);
inputForm->exec();
inputForm->~swcScalingUI();
}
else if (menu_name == tr("about"))
{
v3d_msg(tr("This is a plugin for scaling swc files in IVSCC pipeline. \n"
"Developed by Zhi Zhou, 2014-10-30\n"
"Revised by MK, 2017-10-10"));
}
}
bool IVSCC_scaling::dofunc(const QString & func_name, const V3DPluginArgList & input, V3DPluginArgList & output, V3DPluginCallback2 & callback, QWidget * parent)
{
vector<char*> infiles, inparas, outfiles;
if(input.size() >= 1) infiles = *((vector<char*> *)input.at(0).p);
if(input.size() >= 2) inparas = *((vector<char*> *)input.at(1).p);
if(output.size() >= 1) outfiles = *((vector<char*> *)output.at(0).p);
if (func_name == tr("scale"))
{
cout<<"Welcome to IVSCC swc scaling processing plugin"<<endl;
if(infiles.empty())
{
cerr<<"Need input swc file"<<endl;
return false;
}
QString inswc_file = infiles[0];
QString outswc_file = outfiles[0];
double x_scale, y_scale, z_scale, r_scale;
if (input.size()>=2)
{
vector<char*> paras = (*(vector<char*> *)(input.at(1).p));
if(paras.size() >= 4)
{
cout<<paras.size()<<endl;
x_scale = atof(paras.at(0));
y_scale = atof(paras.at(1));
z_scale = atof(paras.at(2));
r_scale = atof(paras.at(3));
}
else
{
cerr<<"Need four scaling factors"<<endl;
return false;
}
}
else
{
cerr<<"Need four scaling factors"<<endl;
return false;
}
cout<<"inswc_file = "<<inswc_file.toStdString().c_str()<<endl;
cout<<"outswc_file = "<<outswc_file.toStdString().c_str()<<endl;
NeuronTree nt = readSWC_file(inswc_file);
NeuronTree nt_scaled;
QList <NeuronSWC> listNeuron;
QHash <int, int> hashNeuron;
listNeuron.clear();
hashNeuron.clear();
NeuronSWC S;
QList<NeuronSWC> list = nt.listNeuron;
for(V3DLONG i = 0; i < list.size();i++)
{
S.n = nt.listNeuron.at(i).n;
S.x = x_scale * nt.listNeuron.at(i).x;
S.y = y_scale * nt.listNeuron.at(i).y;
S.z = z_scale * nt.listNeuron.at(i).z;
S.r = r_scale * nt.listNeuron.at(i).r;
S.pn = nt.listNeuron.at(i).pn;
S.type = nt.listNeuron.at(i).type;
listNeuron.append(S);
hashNeuron.insert(S.n, listNeuron.size()-1);
}
nt_scaled.n = -1;
nt_scaled.on = true;
nt_scaled.listNeuron = listNeuron;
nt_scaled.hashNeuron = hashNeuron;
writeSWC_file(outswc_file,nt_scaled);
}else if (func_name == tr("fmost_scale"))
{
cout<<"Welcome to fMOST swc scaling processing plugin"<<endl;
if(infiles.empty())
{
cerr<<"Need input swc file"<<endl;
return false;
}
QString inswc_file = infiles[0];
QString outswc_file = outfiles[0];
double x_scale, y_scale, z_scale, r_scale;
if (input.size()>=2)
{
vector<char*> paras = (*(vector<char*> *)(input.at(1).p));
if(paras.size() >= 4)
{
cout<<paras.size()<<endl;
x_scale = atof(paras.at(0));
y_scale = atof(paras.at(1));
z_scale = atof(paras.at(2));
r_scale = atof(paras.at(3));
}
else
{
cerr<<"Need four scaling factors"<<endl;
return false;
}
}
else
{
cerr<<"Need four scaling factors"<<endl;
return false;
}
cout<<"inswc_file = "<<inswc_file.toStdString().c_str()<<endl;
cout<<"outswc_file = "<<outswc_file.toStdString().c_str()<<endl;
NeuronTree nt = readSWC_file(inswc_file);
QList<NeuronSWC> list = nt.listNeuron;
double max_y = -100000000, max_z = -100000000;
double min_y = 100000000,min_z = 100000000;
for(V3DLONG i = 0; i < list.size();i++)
{
nt.listNeuron[i].x = x_scale * nt.listNeuron.at(i).x;
nt.listNeuron[i].y = y_scale * nt.listNeuron.at(i).y;
nt.listNeuron[i].z = z_scale * nt.listNeuron.at(i).z;
nt.listNeuron[i].r = r_scale * nt.listNeuron.at(i).r;
if(nt.listNeuron[i].y >= max_y) max_y = nt.listNeuron[i].y;
if(nt.listNeuron[i].y <= min_y) min_y = nt.listNeuron[i].y;
if(nt.listNeuron[i].z >= max_z) max_z = nt.listNeuron[i].z;
if(nt.listNeuron[i].z <= min_z) min_z = nt.listNeuron[i].z;
}
for(V3DLONG i = 0; i < nt.listNeuron.size();i++)
{
nt.listNeuron[i].y = max_y + min_y - nt.listNeuron[i].y;
nt.listNeuron[i].z = max_z + min_z - nt.listNeuron[i].z;
}
writeSWC_file(outswc_file,nt);
}
else if (func_name == tr("help"))
{
cout<<"Usage : v3d -x dllname -f scale -i <inswc_folder> -o <outswc_file> -p <x_factor> <y_factor> <z_factor> <radius_factor>"<<endl;
cout<<endl;
}
else return false;
return true;
}
| 31.660099 | 162 | 0.526373 | zzhmark |
e124a838926bcb7405d64bc38b090f66d0243763 | 355 | cpp | C++ | 867-transpose-matrix/867-transpose-matrix.cpp | phaneesh707/LeetCode_Problems | e17db0454b21993aec734bbc5dd3a862c0229acb | [
"MIT"
] | null | null | null | 867-transpose-matrix/867-transpose-matrix.cpp | phaneesh707/LeetCode_Problems | e17db0454b21993aec734bbc5dd3a862c0229acb | [
"MIT"
] | null | null | null | 867-transpose-matrix/867-transpose-matrix.cpp | phaneesh707/LeetCode_Problems | e17db0454b21993aec734bbc5dd3a862c0229acb | [
"MIT"
] | null | null | null | class Solution {
public:
vector<vector<int>> transpose(vector<vector<int>>& matrix) {
int m = matrix.size(),n=matrix[0].size();
vector<vector<int>> a(n,vector<int> (m,0));
for(int i=0;i<m;i++){
for(int j=0;j<n;j++){
a[j][i] = matrix[i][j];
}
}
return a;
}
}; | 25.357143 | 64 | 0.44507 | phaneesh707 |
e125391549ed93e6a9314f6875e8d8600f000907 | 4,662 | hpp | C++ | include/codegen/include/System/Reflection/PropertyAttributes.hpp | Futuremappermydud/Naluluna-Modifier-Quest | bfda34370764b275d90324b3879f1a429a10a873 | [
"MIT"
] | 1 | 2021-11-12T09:29:31.000Z | 2021-11-12T09:29:31.000Z | include/codegen/include/System/Reflection/PropertyAttributes.hpp | Futuremappermydud/Naluluna-Modifier-Quest | bfda34370764b275d90324b3879f1a429a10a873 | [
"MIT"
] | null | null | null | include/codegen/include/System/Reflection/PropertyAttributes.hpp | Futuremappermydud/Naluluna-Modifier-Quest | bfda34370764b275d90324b3879f1a429a10a873 | [
"MIT"
] | 2 | 2021-10-03T02:14:20.000Z | 2021-11-12T09:29:36.000Z | // Autogenerated from CppHeaderCreator on 7/27/2020 3:09:43 PM
// Created by Sc2ad
// =========================================================================
#pragma once
#pragma pack(push, 8)
// Begin includes
// Including type: System.Enum
#include "System/Enum.hpp"
#include "utils/il2cpp-utils.hpp"
// Completed includes
// Begin forward declares
// Completed forward declares
// Type namespace: System.Reflection
namespace System::Reflection {
// Autogenerated type: System.Reflection.PropertyAttributes
struct PropertyAttributes : public System::Enum {
public:
// public System.Int32 value__
// Offset: 0x0
int value;
// static field const value: static public System.Reflection.PropertyAttributes None
static constexpr const int None = 0;
// Get static field: static public System.Reflection.PropertyAttributes None
static System::Reflection::PropertyAttributes _get_None();
// Set static field: static public System.Reflection.PropertyAttributes None
static void _set_None(System::Reflection::PropertyAttributes value);
// static field const value: static public System.Reflection.PropertyAttributes SpecialName
static constexpr const int SpecialName = 512;
// Get static field: static public System.Reflection.PropertyAttributes SpecialName
static System::Reflection::PropertyAttributes _get_SpecialName();
// Set static field: static public System.Reflection.PropertyAttributes SpecialName
static void _set_SpecialName(System::Reflection::PropertyAttributes value);
// static field const value: static public System.Reflection.PropertyAttributes ReservedMask
static constexpr const int ReservedMask = 62464;
// Get static field: static public System.Reflection.PropertyAttributes ReservedMask
static System::Reflection::PropertyAttributes _get_ReservedMask();
// Set static field: static public System.Reflection.PropertyAttributes ReservedMask
static void _set_ReservedMask(System::Reflection::PropertyAttributes value);
// static field const value: static public System.Reflection.PropertyAttributes RTSpecialName
static constexpr const int RTSpecialName = 1024;
// Get static field: static public System.Reflection.PropertyAttributes RTSpecialName
static System::Reflection::PropertyAttributes _get_RTSpecialName();
// Set static field: static public System.Reflection.PropertyAttributes RTSpecialName
static void _set_RTSpecialName(System::Reflection::PropertyAttributes value);
// static field const value: static public System.Reflection.PropertyAttributes HasDefault
static constexpr const int HasDefault = 4096;
// Get static field: static public System.Reflection.PropertyAttributes HasDefault
static System::Reflection::PropertyAttributes _get_HasDefault();
// Set static field: static public System.Reflection.PropertyAttributes HasDefault
static void _set_HasDefault(System::Reflection::PropertyAttributes value);
// static field const value: static public System.Reflection.PropertyAttributes Reserved2
static constexpr const int Reserved2 = 8192;
// Get static field: static public System.Reflection.PropertyAttributes Reserved2
static System::Reflection::PropertyAttributes _get_Reserved2();
// Set static field: static public System.Reflection.PropertyAttributes Reserved2
static void _set_Reserved2(System::Reflection::PropertyAttributes value);
// static field const value: static public System.Reflection.PropertyAttributes Reserved3
static constexpr const int Reserved3 = 16384;
// Get static field: static public System.Reflection.PropertyAttributes Reserved3
static System::Reflection::PropertyAttributes _get_Reserved3();
// Set static field: static public System.Reflection.PropertyAttributes Reserved3
static void _set_Reserved3(System::Reflection::PropertyAttributes value);
// static field const value: static public System.Reflection.PropertyAttributes Reserved4
static constexpr const int Reserved4 = 32768;
// Get static field: static public System.Reflection.PropertyAttributes Reserved4
static System::Reflection::PropertyAttributes _get_Reserved4();
// Set static field: static public System.Reflection.PropertyAttributes Reserved4
static void _set_Reserved4(System::Reflection::PropertyAttributes value);
// Creating value type constructor for type: PropertyAttributes
PropertyAttributes(int value_ = {}) : value{value_} {}
}; // System.Reflection.PropertyAttributes
}
DEFINE_IL2CPP_ARG_TYPE(System::Reflection::PropertyAttributes, "System.Reflection", "PropertyAttributes");
#pragma pack(pop)
| 62.16 | 106 | 0.775633 | Futuremappermydud |