This is a set of notes on programming GRAINS that might be useful to you if you're working on a GRAINS project.
There are three versions of the GRAINS AE Modular module in the wild:
-
The original GRAINS module had its AUDIO OUT socket attached to Pin 11 of the Atmel 328P as required by the original Ginkosynthese Grains design.
-
The revised GRAINS had a switch to set AUDIO OUT to Pin 11, or to Pin 9, as required by the Mozzi Library. Why the difference? Because Pin 9 has high-resolution PWM, resulting in much higher quality sound output. It's not clear why Ginkosynthese used Pin 11 in the first place.
-
A prototype version of "GRAINS v2.0", which I got from Robert and which many people have spied in my rack, exposes all the pins that the original GRAINS versions did not. This includes a few LEDs, some buttons, more digital ins/outs, and some analog ins. Critically, hardware serial transmit and receive are exposed as sockets (enabling better MIDI). Robert has also changed the USB port to USB C. I'd like to see a fourth pot as well but it's not in my prototype, and I think it's probably not going to happen.
This is just an early prototype. I do not know when, or even if, Robert will release a v2.0; he is focusing on other stuff for the time being. Who knows if it'll happen.
You have three coding options:
-
Use Mozzi. Mozzi is good for making oscillators, CV generators, and CV converters. It can be used to make audio converters (like filters or effects) but you (and the musician) have to modify your Mozzi library, and the sound is truly terrible. I'd not build audio converters with GRAINS. I have one in my collection, called BIT, which is intentionally noisy sounding.
-
Use the Ginkosynthese GRAINS library. I think Mozzi is superior to it in all ways, so I do not use it. However the Ginkosynthese GRAINS library does work on old GRAINS modules whereas Mozzi does not.
-
Code it yourself. If your output is digital, you easily can build it yourself without any library. Drum triggers, MIDI utilities, clocks, gate generators, etc. But if you need to output a real-valued signal, be it CV or audio, you'll need to use Mozzi or Ginkosynthese GRAINS, which handle the complexities of outputting filtered PWM.
Most of my projects are licensed as Apache 2.0, which isn't viral, so you can mostly use them as you like as long as you retain the license. Read the license to verify.
Some of my projects are GPL because they use viral GPL code and thus must be GPL.
Mozzi used to be distibuted under a broken, viral, non-open-source license: Creative Commons CC-BY-NC-SA 4.0. This license was not meant for code and has all manner of problems. Thankfully, Mozzi has seen the light and is now redistributed as LGPL.
Ginkosyntheses's GRAINS examples are all GPL.
The Arduino Library is LGPL.
All code below is licensed as Apache 2.0.
C's numerical types are vague. Is a short 16-bit or 32-bit? Is an int 16-bit, 32-bit, or 64-bit? Is a char unsigned? And so on.
Because the Arduino is an 8-bit machine with 16-bit and 32-bit options, its numerical type sizes are different from what you'd see on a 32-bit machine. Because the size of the type matters so much in signal processing, it's best not to refer to int, short, long, or char at all. Instead, you should refer to:
- uint8_t (an unsigned 8-bit value: an unsigned byte)
- int8_t (a signed 8-bit value: a signed byte)
- uint16_t (an unsigned 16-bit value)
- int16_t (a signed 16-bit value)
- uint32_t (an unsigned 32-bit value)
- int32_t (a signed 32-bit value)
- float (a 32-bit floating-point value)
Get used to using these religiously in Arduino code: they'll make your life much easier, especially for coding for GRAINS.
You can use bool to describe boolean values, but it's just the same thing as a uint8_t, and false is just the same thing as 0 while true is the same thing as 1 (or non-zero). I don't bother with that.
GRAINS is nothing more than an Atmel 328P: it's basically an Arduino Nano. If you're experienced with coding on the Arduino, then you're more than halfway there. But here are a few tips.
The 328P does not have floating point arithmetic in hardware. You should avoid floating-point when possible (and it's not always possible), as arithmetic with it will be very costly since it will have to be done entirely in software.
The 328P does not have integer division. Integer division is very expensive as it must be done in software. You can divide by constant powers of 2, which GCC ought to convert to right shifts, thus the following are equivalent:
a = x / 8;
a = x >> 3;
This sounds great, but there's a catch: the 328P can only right-shift by one in assembly code. So to shift by 3, it must shift by 1 three times.
This isn't so bad: for example, shifting by 9 is just a shift by 8 (moving a byte over) followed by a shift by 1. And shifting by 4 can be done with a special swap instruction. Unfortunately GCC doesn't do many of these tricks yet. Still, better than nothing.
If you want to divide by constants OTHER than powers of 2, it might make sense to use certain classic tricks:
// Range of 0...255. No 32-bit arithmetic.
inline uint8_t div3Byte(uint8_t dividend)
{
uint16_t invDivisor = 0x55;
uint8_t div = (uint8_t) ((invDivisor * (dividend + 1)) >> 8);
return div;
}
// Range of 0...65535
inline uint16_t div3(uint16_t dividend)
{
uint32_t invDivisor = 0x5555;
uint16_t div = (uint16_t) ((invDivisor * (dividend + 1)) >> 16);
return div;
}
// Range of 0...255. No 32-bit arithmetic.
inline uint8_t div5Byte(uint8_t dividend)
{
uint16_t invDivisor = 0x33;
uint8_t div = (uint8_t) ((invDivisor * (dividend + 1)) >> 8);
return div;
}
// Range of 0...65535
inline uint16_t div5(uint16_t dividend)
{
uint32_t invDivisor = 0x3333;
uint16_t div = (uint16_t) ((invDivisor * (dividend + 1)) >> 16);
return div;
}
// Range of 0...16385
// Note, (div3(dividend) >> 1) has range 0...65535 but a tiny bit slower
// Note, (div3Byte(dividend) >> 1) has range 0...255 and is much faster for bytes
inline uint16_t div6(uint16_t dividend)
{
uint32_t invDivisor = 0x2AAA;
uint16_t div = (uint16_t) ((invDivisor * (dividend + 1)) >> 16);
return div;
}
// Range of 0...32773
inline uint16_t div7(uint16_t dividend)
{
uint32_t invDivisor = 0x2492;
uint16_t div = (uint16_t) ((invDivisor * (dividend + 1)) >> 16);
return div;
}
// Range of 0...9369
// Note, I do not know if (div3Byte(div3Byte(dividend))), which has a range of 0..255,
// is a faster choice for bytes. It probably is.
inline uint16_t div9(uint16_t dividend)
{
uint32_t invDivisor = 0x1C71;
uint16_t div = (uint16_t) ((invDivisor * (dividend + 1)) >> 16);
return div;
}
// Range of 0...9369
// Note, (div5(dividend) >> 1) has range 0...65535 but a tiny bit slower
// Note, (div5Byte(dividend) >> 1) has a range of 0...255 and is much faster for bytes.
inline uint16_t div10(uint16_t dividend)
{
uint32_t invDivisor = 0x1999;
uint16_t div = (uint16_t) ((invDivisor * (dividend + 1)) >> 16);
return div;
}
// Range of 0...16391
// Note, (div3(dividend) >> 2) has range 0...65535 but a tiny bit slower
// Note, (div3Byte(dividend) >> 2) has a range 0...255 and is much faster for bytes.
uint16_t div12(uint16_t dividend)
{
uint32_t invDivisor = 0x1555;
uint16_t div = (uint16_t) ((invDivisor * (dividend + 1)) >> 16);
return div;
}
// Range of 0...4294967296 (full 32 bit range)
// Note: div10(div10(n)) has a range of 0...10999 and is likely to be faster.
uint32_t div100(uint32_t n)
{
uint32_t q, r;
q = (n >> 1) + (n >> 3) + (n >> 6) -
(n >> 10) + (n >> 12) + (n >> 13) - (n >> 16);
q = q + (q >> 20);
q = q >> 6;
r = n - q * 100;
// return q + ((r + 28) >> 7); // an alternative
return q + (r > 99);
}
One of the most common tasks you'll find yourself doing is scaling the analog inputs, which have a range 0...1023, into something smaller. If you were scaling into another power of 2, you could always do division or shifts. For example, scaling 0...1023 to 0...3 is just dividing by 256, otherwise known as shifting right by 8:
x = x / 256; // or
x = x >> 8;
If you need to scale by some other constant, the best way to do it is to MULTIPLY by the constant, then DIVIDE by 1024. For example, to scale to 0...5, you'd do:
x = (x * 6) / 1024; // or
x = (x * 6) >> 10;
Note that an unsigned 16-bit integer has is at most 64 times larger than 1024. So if you needed to scale to (say) 0...99, you don't have enough headroom. In this case, divide the 1024 by 2 to give you enough headroom, like this:
x = ((x / 2) * 100) / 512; // or
x = ((x >> 1) * 100) >> 9;
Work just like you'd want them to. You'll often scale 16-bit signed audio down to 8-bit etc. this way.
The 328P is an 8-bit processor with only one or two instructions to assist in 16-bit arithmetic. 16-bit and 32-bit arithmetic are faked with multiple 8-bit instructions. Generally they're 2x and 4x the cost of 8-bit arithmetic (you can google to find exact timings for Arduinos). You want to stay 8-bit (uint8_t) as much as you can, but you'll be doing a variety of things in 16-bit (uint16_t). Sometimes you have no choice but to bump to 32-bit (uint32_t) but you want to drop out of it as soon as you can.
Mozzi makes a lot of noise about its (very limited) fixed-point arithmetic package as a way to get much of the value of floating-point arithmetic with much less computational cost. But fixed-point arithmetic is really simple. It's just integer arithmetic where you imagine your integers as being some power of two times your decimal (or fractional) values.
For example, let's say you need two decimals worth of precision (100). The power of two that encompasses that is 7 bits or 128. So let's do 128. In this case if you have a 16-bit number, you have 9 bits left for the integer portion, or 512. So your biggest value is 511 + 127/128 or just below 512.
So how do you do this? Let's say you have 92.42. You convert it to your fixed-point number as:
uint16_t fixed1 = (uint16_t) (92.42 * 128);
128 is the scaling factor. It's the size of your fractional range.
You can add two fixed point numbers together, and you can multiply a fixed point number by a normal integer. To multiply two fixed point numbers together, you'll wind up with a fixed-point number with a squared scaling factor (128 * 128 = 16384). You'll ultimately need to divide it by 128 to get it back down to 128 again.
uint32_t fixed3 = (fixed2 * fixed1) / 128; // or
uint32_t fixed3 = (fixed2 * fixed1) >> 7;
Note that even though we're dividing by 128, by multiplying two 16-bit integers we're going to go into a 32-bit integer range.
You can get the integer portion of the fixed number by dividing by the scaling factor (128), as in:
uint16_t intportion = fixed1 / 128; // or
uint16_t intportion = fixed1 >> 7;
From there you can get the "fractional" portion so to speak. Our "fractional" portion is parts of 128, so you we can say:
uint16_t fracportion = fixed1 & 127;
This will be a value 0...127.
To go back to floating-point, you can do:
float result = fixed1 / 128.0; // Note 128.0 is a float
The examples I gave were for unsigned fixed-point numbers. But you can totally do signed numbers. But you should be consistent. And watch out for rolling over in addition or subtraction, you don't want that.
Anyway, the point is that fixed-point arithmetic isn't remotely as complex and mysterious as Mozzi's package makes it out to be.
POW and EXP are unbelievably expensive operations, potentially thousands of times more expensive than a multiply. Unfortunately, to convert pitch to frequency, you have to do them. But you can't afford it.
For example, let's say that your starting pitch is called 0 (perhaps it's C2, which is 32.703Hz). You go up N semitones from there. What's the frequency of pitch N?
pow(2.0, n/12.0) * 32.703
Ugh, exponentiation of 2 by a floating-point value. You can't do that realistically.
Instead, consider a lookup table. For example, in many of my GRAINS oscillators, I have a table called FREQUENCIES. It's a big table of 1536 values starting at 32.703. It rises with fractions of pitches. Specifically, AE Modular is 5V, thus 5 octaves, and since 5V on the arduino is 1023, C to C 5 octaves above (inclusive) would be 0...1024. So my 5 octaves of pitches range 0...1023. I just look it up in the table. The table is bigger than this to handle 2.5 octaves of additional transposition in case I need it.
You can't store 1536 32-bit floating-point values in 2K of RAM. What to do? You store it in the code space, using PROGMEM. We'll discuss that later.
Sine is also far too expensive. It's best to just store it as a lookup table. I'd store it as a lookup table of 8-bit or 16-bit integers. Mozzi has some tables like that if you don't want to generate them yourself.
Arduino's random number generator is really bad. It'll do for noise but it's not amazing. It's also a bit pokey. The traditional way to randomize is to call randomSeed(...) on an analog pin. The best pin choice for this in GRAINS is A5. You'd do this in setup().
Another way to get different random seeds each time you start up GRAINS is to load an unsigned 16-bit integer from the EEPROM, set it to 1 if it's 0, call randomSeed(...) on it, then increment it and save it back to EEPROM.
If you need a faster random() function, Mozzi has an xorshift library which will do okay. See mozzi_rand.h
xorshift is still 32-bit. If you just need a really fast 8-bit random number generator, you might use this simple one.
In some situations you might need a deterministic random number sequence, that is one that is always repeatable. Here is a table of 8192 random numbers.
// this is literally just a deterministic random number table
const PROGMEM uint8_t NOISE[8192] =
{
0xF1, 0xD2, 0xAC, 0x49, 0x3C, 0xC9, 0xF2, 0xA2, 0x09, 0x18, 0x98, 0x22, 0x64, 0xEA, 0xEA, 0x49, 0x3A, 0x7B, 0x56, 0xA5, 0x18, 0x9D, 0xBD, 0x38, 0xFE, 0x6D, 0x21, 0xE8, 0x4B, 0x33, 0xBC, 0xA2,
0x06, 0xFB, 0x41, 0xB6, 0xBA, 0xAC, 0x6E, 0x2C, 0x1E, 0x9D, 0xFB, 0x96, 0x6D, 0x9D, 0xDA, 0xE1, 0x6C, 0x04, 0xD4, 0xEC, 0x7E, 0x3C, 0xC1, 0x69, 0xE8, 0x74, 0x38, 0x8A, 0x2E, 0x1B, 0x72, 0xE6,
0xA3, 0xA1, 0x41, 0x03, 0xC4, 0xCD, 0x0C, 0xBB, 0x8D, 0xC7, 0xF9, 0xC0, 0x54, 0xE8, 0x29, 0x2A, 0x02, 0x2A, 0xFB, 0x13, 0x19, 0x9D, 0xDA, 0x2B, 0xC7, 0x7E, 0x0B, 0xD5, 0xC6, 0x17, 0x41, 0x52,
0x9B, 0xAB, 0x3B, 0x92, 0xA0, 0x67, 0x9D, 0x18, 0xF3, 0xA2, 0x05, 0x15, 0x13, 0xC2, 0x7D, 0xDB, 0xC2, 0xBB, 0x3A, 0x9B, 0xCD, 0x41, 0xAD, 0xE8, 0xF6, 0xF6, 0xB0, 0x39, 0xFC, 0x3E, 0x78, 0xAD,
0xF3, 0xE7, 0x6B, 0x98, 0x24, 0xA3, 0x17, 0xBA, 0xA5, 0xFF, 0xBC, 0xBB, 0x25, 0x9F, 0x44, 0x33, 0xCD, 0xC5, 0x89, 0x74, 0x17, 0x11, 0xAC, 0x59, 0x35, 0x71, 0x72, 0xC0, 0x93, 0xBD, 0x5E, 0x0B,
0x89, 0x97, 0xA1, 0x15, 0xB0, 0x4A, 0xC3, 0x84, 0x21, 0x21, 0x1F, 0x54, 0x32, 0x95, 0xFF, 0x24, 0x7A, 0xD3, 0x4F, 0xDB, 0x04, 0x71, 0x00, 0xEB, 0x24, 0xA1, 0x61, 0x8B, 0xC1, 0xC9, 0xBC, 0x15,
0x35, 0xB9, 0x09, 0xB9, 0xCE, 0x5B, 0xD8, 0x04, 0xB2, 0xA3, 0x22, 0x39, 0x59, 0x02, 0x62, 0x1F, 0xE4, 0x25, 0x6B, 0x34, 0xE2, 0xF5, 0xE3, 0x81, 0x55, 0x1D, 0x78, 0xAC, 0xA4, 0x3C, 0xFE, 0x9E,
0xB1, 0xD8, 0xD7, 0xCE, 0xB6, 0xBD, 0xB6, 0xE9, 0x09, 0xD4, 0xC8, 0xC0, 0xF0, 0xBE, 0x3F, 0x30, 0xF9, 0xF3, 0x5E, 0x4C, 0x80, 0xCD, 0x8E, 0x59, 0x10, 0xC6, 0x37, 0x7D, 0x1E, 0x6D, 0x28, 0xA9,
0x30, 0x60, 0xA9, 0x52, 0x92, 0x4D, 0x2C, 0xA2, 0x1D, 0x69, 0x04, 0x51, 0x50, 0xCA, 0x87, 0x9F, 0x90, 0xCF, 0xD3, 0x3C, 0x8B, 0x93, 0x82, 0xED, 0x19, 0xD1, 0x34, 0xEB, 0xFE, 0x2E, 0x84, 0x3C,
0x6F, 0xD4, 0xED, 0xCA, 0x58, 0x9F, 0xD5, 0x69, 0x73, 0xBC, 0x69, 0xA4, 0x51, 0x74, 0x40, 0xAA, 0x8E, 0xB6, 0xA3, 0xA8, 0xCE, 0x2D, 0x7F, 0x78, 0x69, 0x52, 0x25, 0x6B, 0x44, 0xDA, 0x03, 0x1E,
0x43, 0x8C, 0x5E, 0xC6, 0x16, 0xBF, 0x86, 0xE1, 0x99, 0x59, 0xBD, 0xB9, 0x57, 0xB7, 0x54, 0xE3, 0x89, 0x3B, 0x99, 0x86, 0x61, 0xE2, 0xDD, 0x09, 0x12, 0xED, 0x44, 0x81, 0x99, 0x76, 0x2A, 0x80,
0xBD, 0xA4, 0x74, 0xF6, 0xF6, 0x46, 0x50, 0xE9, 0x00, 0xFA, 0x56, 0x4D, 0xBA, 0x0B, 0xD4, 0x72, 0x15, 0xB4, 0xC0, 0xE6, 0x5D, 0xDC, 0x83, 0xC7, 0x80, 0x16, 0x01, 0x4C, 0x6C, 0x99, 0x36, 0x1B,
0xD0, 0xE0, 0xAB, 0xDF, 0x7A, 0xEB, 0xF5, 0x1A, 0xC7, 0x4C, 0xC7, 0xFF, 0x62, 0x75, 0x9B, 0x2C, 0x38, 0x9A, 0xB0, 0x17, 0xAB, 0xC0, 0xAA, 0xAA, 0xAE, 0xD8, 0xE6, 0x0A, 0xFC, 0x24, 0x43, 0x63,
0x09, 0x22, 0xE6, 0xEA, 0x09, 0x20, 0x76, 0xA6, 0x53, 0x17, 0x6C, 0x7A, 0x0A, 0x4A, 0xFE, 0x8F, 0x46, 0xF6, 0x8F, 0xC9, 0x33, 0x1E, 0x33, 0xEA, 0xF4, 0x12, 0x6A, 0x78, 0x9C, 0x06, 0x40, 0x6B,
0xC1, 0x3E, 0x5F, 0xDB, 0xEB, 0x30, 0x76, 0x38, 0x55, 0x24, 0x95, 0xEC, 0xA5, 0x0F, 0x96, 0x72, 0x7D, 0x07, 0xB9, 0xBC, 0x5D, 0x15, 0x12, 0x1E, 0x62, 0xB9, 0x39, 0x12, 0x1E, 0x09, 0x3F, 0x9F,
0xBC, 0x45, 0x8C, 0xB3, 0x42, 0x81, 0xFE, 0x7A, 0xFF, 0xF8, 0xDF, 0xBF, 0xF9, 0xE7, 0x69, 0x87, 0x55, 0x94, 0xA3, 0x1C, 0xB1, 0x88, 0x20, 0x24, 0xDD, 0x84, 0xF5, 0x4A, 0x1B, 0x22, 0x6C, 0x12,
0xE3, 0x84, 0xA8, 0xB7, 0x2E, 0xEE, 0x0D, 0x8F, 0xFC, 0x99, 0x9A, 0x2A, 0xA2, 0x4E, 0x79, 0x33, 0x47, 0xE4, 0x3C, 0x51, 0x6C, 0xE5, 0xE8, 0xE2, 0x03, 0xD7, 0x99, 0x9D, 0xD1, 0xAA, 0x78, 0x2C,
0xEB, 0xE0, 0xC5, 0xD7, 0x9B, 0x3B, 0xFC, 0x47, 0xE0, 0xBB, 0x03, 0x80, 0x87, 0x3C, 0x4F, 0x69, 0x61, 0x1B, 0x80, 0x9D, 0xEB, 0x4B, 0x00, 0xCB, 0xAA, 0xA0, 0xFB, 0x31, 0xA0, 0x68, 0x81, 0x64,
0x4C, 0x4E, 0xAB, 0x5F, 0x92, 0x5F, 0x3A, 0x3F, 0x22, 0xDD, 0xB3, 0x41, 0x53, 0xAA, 0x98, 0x17, 0x3F, 0x59, 0xF7, 0x73, 0xA3, 0x37, 0x56, 0x31, 0x48, 0xCE, 0xB7, 0x1A, 0x82, 0x41, 0x7C, 0xE6,
0xDC, 0x1F, 0x5A, 0x19, 0x00, 0x91, 0x6D, 0x20, 0xE6, 0x89, 0x3F, 0x57, 0xB0, 0x88, 0xC1, 0x74, 0x72, 0xE9, 0x2F, 0x17, 0x5E, 0x38, 0xC1, 0x6A, 0x10, 0x90, 0xF1, 0xE0, 0xB7, 0x0C, 0xE5, 0x35,
0x5B, 0xED, 0xBC, 0x91, 0xEC, 0x75, 0x7A, 0x96, 0xB1, 0x3D, 0xD7, 0xAB, 0x1C, 0xE7, 0x3E, 0x3B, 0x92, 0x3B, 0x53, 0x69, 0xD3, 0x71, 0x00, 0x52, 0x04, 0x5C, 0x7D, 0x69, 0xFD, 0xD7, 0xC3, 0x8B,
0xC1, 0xD4, 0xDD, 0x8D, 0xE6, 0x9E, 0x44, 0x2C, 0x82, 0xB2, 0x68, 0x17, 0x06, 0x2D, 0xEF, 0x7E, 0x81, 0x8E, 0xBB, 0x07, 0xA1, 0x9E, 0x50, 0xFC, 0x29, 0x06, 0x4F, 0x44, 0x7F, 0xAB, 0xFB, 0x4A,
0xDC, 0xDD, 0x22, 0xA4, 0x59, 0x26, 0x67, 0x39, 0x73, 0x42, 0x3E, 0xA7, 0xE8, 0x15, 0x38, 0x4B, 0x4D, 0x94, 0xF1, 0x00, 0x08, 0x95, 0xA3, 0x1F, 0x9B, 0x54, 0x02, 0xE6, 0x1F, 0x95, 0xA3, 0x40,
0xF7, 0xA8, 0x28, 0xCC, 0x25, 0x3D, 0xB6, 0xF9, 0x0E, 0xD2, 0xBB, 0x93, 0x80, 0xE5, 0x80, 0x18, 0xA6, 0x13, 0x3B, 0xE3, 0xDD, 0xE4, 0x24, 0x69, 0xCD, 0x0E, 0xFF, 0x82, 0xCC, 0x65, 0x63, 0xC2,
0x1C, 0x47, 0xB9, 0x70, 0x34, 0x63, 0xFE, 0x77, 0xEC, 0xD7, 0xF4, 0xCB, 0xEF, 0xFC, 0x9B, 0xC0, 0xFE, 0x4F, 0x79, 0xEC, 0x1E, 0xCE, 0xEF, 0xFA, 0x91, 0xDE, 0x6C, 0x2A, 0xF9, 0x66, 0xFD, 0xC3,
0xD8, 0xB0, 0x1C, 0xA3, 0x24, 0xD9, 0x4B, 0x88, 0xF2, 0xB1, 0xF0, 0x1F, 0x05, 0x1C, 0x4C, 0x66, 0x8D, 0x04, 0x39, 0xBE, 0x14, 0x2F, 0x97, 0x12, 0xA4, 0xE8, 0x68, 0xD0, 0x10, 0xC1, 0xD3, 0x2D,
0xBB, 0x42, 0x5F, 0x45, 0x8E, 0x70, 0x33, 0x1E, 0xDE, 0xEC, 0xFB, 0x0D, 0xA3, 0x99, 0xF6, 0x80, 0x29, 0x5D, 0x5F, 0x0E, 0x58, 0x4B, 0xF1, 0xFA, 0x55, 0x5D, 0x45, 0x33, 0xB3, 0xDC, 0x5F, 0x82,
0x37, 0xF6, 0xE8, 0xCF, 0xE7, 0x70, 0xD4, 0x95, 0x13, 0x86, 0x13, 0xCD, 0x71, 0x30, 0x72, 0x42, 0x55, 0x4E, 0x68, 0x1F, 0xCB, 0x74, 0x91, 0x29, 0xAA, 0x5A, 0x8B, 0x1D, 0x44, 0x90, 0xF8, 0xD9,
0xB4, 0x33, 0x7B, 0x6E, 0xD0, 0xC9, 0x7B, 0x15, 0x3F, 0x0B, 0x0F, 0xFC, 0xD7, 0x6B, 0x16, 0x4F, 0x4D, 0x1B, 0xB5, 0xA8, 0xE7, 0xD2, 0xFF, 0xF3, 0x34, 0x81, 0x85, 0xAD, 0x63, 0x31, 0x01, 0x0D,
0xA9, 0x8E, 0x88, 0x7A, 0x0F, 0x70, 0x99, 0xF0, 0x0C, 0x04, 0x06, 0x8E, 0x5B, 0x0E, 0x87, 0x29, 0xB5, 0x04, 0x87, 0x34, 0x8C, 0x9C, 0x6B, 0x84, 0x9B, 0xDD, 0xE2, 0x0A, 0x00, 0x01, 0x67, 0xAA,
0x39, 0x2D, 0x87, 0x96, 0x61, 0xEB, 0x1E, 0x3A, 0x20, 0x40, 0x72, 0x72, 0x62, 0x33, 0xF1, 0xCD, 0x11, 0x4C, 0x33, 0x19, 0xF3, 0xC4, 0xC2, 0x7E, 0xC1, 0xF4, 0x21, 0x95, 0x47, 0x8B, 0x6E, 0x55,
0x23, 0x48, 0xE1, 0x47, 0xD6, 0x91, 0xD4, 0xEE, 0xE0, 0xC4, 0xF3, 0xEC, 0x3C, 0xDF, 0x94, 0x93, 0x64, 0xD3, 0xB6, 0x3D, 0x42, 0x28, 0xF0, 0x6E, 0xC3, 0x17, 0xCC, 0x04, 0x4B, 0xA7, 0x7E, 0x8D,
0x2A, 0x02, 0xD6, 0x84, 0x35, 0xBB, 0x68, 0x9E, 0xC0, 0xE2, 0x10, 0x7C, 0xAC, 0xF1, 0x5A, 0xD6, 0x16, 0x06, 0xC6, 0x8F, 0x7A, 0x1F, 0xD4, 0xD6, 0x83, 0x1F, 0x33, 0xE4, 0x9B, 0x94, 0xA0, 0xD7,
0xD6, 0xD9, 0xA2, 0xDD, 0x28, 0xF3, 0xD5, 0xD7, 0xD5, 0x45, 0xBB, 0x0A, 0x08, 0x53, 0x02, 0x6A, 0x13, 0xCA, 0x12, 0x6C, 0xA2, 0x4D, 0x81, 0xBB, 0xF4, 0xBF, 0x85, 0xDE, 0x7C, 0x64, 0xF9, 0xF3,
0x9A, 0xF7, 0xEB, 0x8F, 0x26, 0x87, 0x81, 0x97, 0x77, 0xC1, 0x22, 0xFC, 0xEF, 0xAE, 0x19, 0xB7, 0x92, 0x30, 0x7A, 0x13, 0x13, 0xDE, 0x24, 0xF6, 0xFD, 0xE6, 0x46, 0xC2, 0xB8, 0x94, 0xA3, 0x1E,
0x3C, 0xDC, 0x63, 0x0D, 0x8D, 0x77, 0x98, 0xC7, 0x12, 0x11, 0x0D, 0xCD, 0x76, 0x01, 0xEE, 0xEA, 0x90, 0xC7, 0xA2, 0xD9, 0x9C, 0xCA, 0x6D, 0xF3, 0xDE, 0xFE, 0x96, 0x58, 0x84, 0xA5, 0xE2, 0x5D,
0x70, 0x01, 0xD4, 0x6C, 0x63, 0x42, 0x27, 0xF8, 0xDF, 0x0D, 0x8D, 0x37, 0x44, 0x2A, 0x97, 0xF6, 0x6F, 0xD1, 0x2B, 0xAD, 0xA3, 0x5E, 0x5D, 0xD0, 0x19, 0xFA, 0xDB, 0xF8, 0x48, 0x04, 0x05, 0x1C,
0xE7, 0x9F, 0x59, 0xBC, 0x10, 0x89, 0x2F, 0x92, 0x1F, 0xD6, 0x59, 0xEF, 0x7D, 0xD6, 0x32, 0xCD, 0x91, 0xD2, 0x31, 0x6A, 0x35, 0x6C, 0x4F, 0x26, 0x20, 0x8B, 0x13, 0x4C, 0x5F, 0x52, 0x47, 0x59,
0x8C, 0x90, 0xD6, 0x54, 0x22, 0x21, 0x8D, 0x9C, 0x58, 0x97, 0xF1, 0xC1, 0x3F, 0x46, 0x88, 0x91, 0xEB, 0x7F, 0x52, 0x85, 0x04, 0x81, 0x49, 0xA5, 0xFD, 0x8A, 0xE6, 0xD8, 0xE5, 0xB8, 0xCB, 0x10,
0xFD, 0x1B, 0x14, 0x46, 0x97, 0x8A, 0x21, 0x7B, 0x54, 0x21, 0x76, 0x14, 0x9E, 0xD0, 0xCF, 0xF1, 0x3C, 0xD4, 0x58, 0xAF, 0x70, 0x1C, 0x55, 0xA6, 0x4E, 0x5D, 0x21, 0x1C, 0xF8, 0x8E, 0xAB, 0x4F,
0xE1, 0x38, 0x78, 0x1C, 0x3C, 0xFA, 0x77, 0x21, 0xF9, 0x56, 0x6F, 0xF0, 0x27, 0xD3, 0xD8, 0x28, 0xC0, 0x9C, 0xF7, 0x1B, 0xA5, 0x5D, 0x05, 0x86, 0x8A, 0x0D, 0xDC, 0xA9, 0xA3, 0x40, 0x11, 0x6C,
0x87, 0xAE, 0x2E, 0x7D, 0xD2, 0x23, 0x0A, 0x03, 0x59, 0xDF, 0xDB, 0x5B, 0x3D, 0x01, 0xDB, 0x19, 0xF6, 0xAC, 0x52, 0x2A, 0x8C, 0x6C, 0x74, 0x25, 0x21, 0xCA, 0xA1, 0x68, 0xBA, 0xA4, 0x33, 0x31,
0xBD, 0xA2, 0x6B, 0x92, 0x3A, 0xAA, 0xEA, 0xEE, 0x37, 0xEF, 0xA2, 0xF3, 0x0B, 0xA2, 0xD0, 0x2F, 0xEC, 0xE6, 0xAD, 0x34, 0xF6, 0xCC, 0x01, 0x20, 0x34, 0xD0, 0xA2, 0xC3, 0x34, 0x45, 0x60, 0xC4,
0x69, 0xE1, 0xD1, 0x8E, 0x50, 0x9C, 0xC9, 0xA4, 0x55, 0x25, 0xA8, 0x16, 0x4C, 0xFC, 0x41, 0xEF, 0x56, 0x3A, 0x74, 0xB1, 0xB4, 0x5B, 0x70, 0x41, 0xB8, 0xB0, 0x61, 0x86, 0x67, 0x84, 0x83, 0x0C,
0x8D, 0x3B, 0xD8, 0xDA, 0x42, 0xEA, 0xA3, 0x1B, 0xCE, 0x95, 0xE7, 0xC8, 0x5B, 0x37, 0x18, 0x7E, 0x50, 0x92, 0x98, 0x03, 0x79, 0x0C, 0xDE, 0xCD, 0x7A, 0xC4, 0x00, 0x6F, 0xD9, 0xBC, 0x54, 0xDD,
0xAA, 0x7F, 0x64, 0xCA, 0xF0, 0xD5, 0x19, 0xE6, 0x5B, 0xCA, 0xB5, 0xA5, 0x44, 0xF5, 0x3E, 0x33, 0xAC, 0xD4, 0x60, 0x7E, 0x45, 0xE3, 0x7C, 0x73, 0x9F, 0x25, 0x78, 0x19, 0x59, 0x76, 0x71, 0xFA,
0xAC, 0x94, 0x67, 0x84, 0xFE, 0x04, 0xD0, 0xDD, 0xE8, 0x7F, 0x81, 0xD2, 0xB4, 0xC9, 0x67, 0x02, 0xB3, 0x88, 0xB6, 0x5F, 0xB0, 0xF7, 0x12, 0x76, 0x76, 0x62, 0x15, 0x80, 0xB4, 0xE4, 0xAD, 0x93,
0xC7, 0x15, 0x93, 0x6F, 0x95, 0x08, 0x5A, 0x74, 0x3A, 0x16, 0x77, 0x6F, 0x9E, 0xF0, 0xC1, 0xAB, 0x76, 0xB2, 0x32, 0xF7, 0xC4, 0x9D, 0xF1, 0x54, 0xC3, 0x6B, 0x3B, 0xBB, 0x97, 0xCF, 0x10, 0xE9,
0x56, 0x1D, 0xD8, 0x9C, 0x5B, 0x72, 0x71, 0xFF, 0x93, 0xFB, 0x95, 0x02, 0x72, 0x17, 0xCD, 0x33, 0x2C, 0xC8, 0x70, 0x31, 0x0F, 0x50, 0x48, 0x1E, 0x4D, 0xD5, 0x74, 0x8D, 0x46, 0x0D, 0x41, 0xB5,
0xD1, 0x3F, 0x80, 0x37, 0x99, 0x81, 0x7A, 0x3D, 0xC9, 0x75, 0xC7, 0x6E, 0xEC, 0x79, 0x1C, 0x4B, 0x01, 0x90, 0xFC, 0xEF, 0xCC, 0xAB, 0xA6, 0x97, 0xA5, 0xF5, 0xF7, 0xB3, 0xBF, 0xBB, 0x8E, 0x98,
0x01, 0x64, 0xC0, 0xF0, 0xE3, 0xDB, 0x3D, 0x3C, 0x65, 0x36, 0x8E, 0x76, 0xC0, 0xD6, 0x65, 0xCF, 0xE1, 0x05, 0x2B, 0x72, 0xD9, 0x5E, 0xE7, 0x9A, 0x6C, 0xF3, 0x21, 0x6C, 0xCB, 0x39, 0xAA, 0x42,
0xF4, 0xDF, 0x04, 0x18, 0xFE, 0xD7, 0x96, 0x11, 0xAB, 0x51, 0x00, 0x40, 0x6F, 0x63, 0x15, 0x88, 0x63, 0x1A, 0x22, 0x93, 0xEE, 0xDF, 0xE4, 0xE3, 0x92, 0x80, 0x6D, 0x51, 0xF9, 0x19, 0x07, 0xF8,
0x2C, 0x6C, 0x15, 0x48, 0xFF, 0x13, 0x7B, 0x85, 0x6D, 0x16, 0x63, 0xAD, 0xAA, 0xCC, 0x63, 0x3A, 0x69, 0x3D, 0x99, 0x16, 0x9B, 0xB5, 0xAA, 0xAE, 0x99, 0xD3, 0x47, 0x3A, 0x37, 0x89, 0xD8, 0x6B,
0x65, 0x79, 0xE0, 0x7E, 0xEA, 0xD1, 0x0A, 0xD3, 0xCC, 0x5E, 0xDE, 0x9C, 0x42, 0xE5, 0x55, 0x17, 0x97, 0x16, 0x90, 0xD6, 0x67, 0x3D, 0x36, 0x03, 0x40, 0x93, 0xB8, 0x05, 0x17, 0xA4, 0x62, 0x5D,
0x56, 0xE4, 0xA6, 0x45, 0xE7, 0xC1, 0x89, 0xAC, 0xAC, 0x63, 0xA7, 0x62, 0x75, 0xC5, 0x57, 0x93, 0xCA, 0xCA, 0xDA, 0x53, 0xE9, 0x0F, 0x7F, 0xA3, 0x77, 0xBA, 0x4E, 0xF9, 0x8F, 0xB7, 0xA7, 0x81,
0x9C, 0xE2, 0xDC, 0x2C, 0xC5, 0x99, 0x11, 0x87, 0x1B, 0xE7, 0xE3, 0x2C, 0x34, 0xD2, 0x1F, 0xB8, 0xE8, 0xC4, 0x04, 0x68, 0xEE, 0x8F, 0x20, 0x19, 0xAA, 0x53, 0x73, 0xC1, 0x28, 0xF4, 0x33, 0x0C,
0x00, 0xEB, 0x54, 0xD8, 0xF5, 0x22, 0xB1, 0xC4, 0x4F, 0xB8, 0x2A, 0xDA, 0x8D, 0x4F, 0x36, 0xC3, 0xB2, 0xFD, 0xB0, 0x9F, 0x08, 0x14, 0xD8, 0x51, 0xC3, 0xCD, 0xB3, 0xE7, 0xDC, 0x0E, 0x6F, 0x47,
0x3E, 0xA0, 0xB3, 0x5E, 0xA4, 0x37, 0x13, 0xF6, 0x1A, 0x74, 0xBB, 0xE2, 0xFE, 0xDC, 0x51, 0xCF, 0x24, 0x8E, 0x1B, 0xB9, 0x7E, 0xF0, 0x20, 0xEE, 0x6D, 0x44, 0x41, 0xBC, 0x35, 0xBB, 0xD8, 0xA3,
0xD2, 0x9D, 0x6C, 0x5A, 0x3B, 0xED, 0x34, 0x0A, 0x90, 0x85, 0xE1, 0x18, 0x3D, 0x20, 0x28, 0x02, 0x74, 0x83, 0xC8, 0xB2, 0x54, 0x8E, 0x9E, 0xFB, 0x35, 0x95, 0x27, 0xC0, 0xD3, 0xD9, 0x87, 0x5A,
0x1B, 0xAB, 0xCD, 0x95, 0x83, 0x19, 0x35, 0x49, 0x34, 0x1C, 0x43, 0xE7, 0xBF, 0xCB, 0x2B, 0xE6, 0x0E, 0x40, 0x3C, 0x3E, 0x17, 0x17, 0x33, 0x3F, 0x82, 0x34, 0x48, 0x0F, 0xFF, 0xCA, 0xFA, 0xC7,
0x79, 0x26, 0x4D, 0xFE, 0x6D, 0xF9, 0x34, 0x3F, 0x8E, 0x48, 0x71, 0x6A, 0xFE, 0xBE, 0x1F, 0x72, 0xBC, 0x8A, 0xC9, 0x52, 0x64, 0x2A, 0x64, 0xCA, 0xCB, 0xB2, 0x13, 0xC6, 0x22, 0xE6, 0xE6, 0x1D,
0x55, 0xAA, 0x31, 0x3B, 0x58, 0x89, 0xD3, 0xF2, 0x77, 0x24, 0x35, 0xDD, 0x3B, 0x56, 0x34, 0xAD, 0xCC, 0x2E, 0x0A, 0x61, 0x77, 0x9B, 0x04, 0xD9, 0x83, 0x06, 0x04, 0x67, 0x2F, 0x9F, 0x06, 0x28,
0x95, 0x07, 0x55, 0xB9, 0x9A, 0xF1, 0x2A, 0xD7, 0x37, 0x65, 0x66, 0xC3, 0x55, 0x08, 0xA1, 0x0C, 0x55, 0x7A, 0xC6, 0x2B, 0x32, 0x35, 0x30, 0x96, 0x97, 0x83, 0x51, 0x3C, 0xEC, 0x15, 0x09, 0x96,
0x20, 0x80, 0xF4, 0x89, 0xA2, 0x6A, 0x74, 0xC0, 0x75, 0x12, 0x41, 0x83, 0x2F, 0xF1, 0xF5, 0x0F, 0xBB, 0xDE, 0xE9, 0x33, 0x1C, 0xF4, 0x89, 0xBB, 0xD0, 0x71, 0x8D, 0x5B, 0xE3, 0x15, 0xC9, 0x7C,
0x8C, 0x81, 0x20, 0x4F, 0x8F, 0x5C, 0x3C, 0xEE, 0xAF, 0xED, 0x28, 0xB6, 0x8B, 0xFA, 0x50, 0xA2, 0xD4, 0x99, 0xF0, 0x68, 0x8F, 0xD6, 0xDB, 0x76, 0x52, 0x01, 0xC3, 0xCB, 0x9B, 0xB9, 0x7F, 0x01,
0xE6, 0x97, 0xB4, 0xCA, 0x16, 0xF5, 0x56, 0xD4, 0x95, 0x42, 0x49, 0x48, 0x98, 0xB8, 0x81, 0x1D, 0xF8, 0xE5, 0x90, 0x05, 0x3B, 0x7B, 0x9D, 0xCD, 0x81, 0x84, 0xD7, 0x53, 0x20, 0x53, 0x58, 0x6B,
0xCB, 0xEE, 0x8A, 0x58, 0x4C, 0x93, 0x53, 0xFA, 0x34, 0x56, 0x1D, 0xE9, 0xFF, 0xB5, 0x7A, 0x85, 0xF3, 0x36, 0x22, 0x0B, 0x20, 0x24, 0x27, 0x0F, 0x44, 0x9C, 0x70, 0x99, 0x58, 0x4B, 0x3C, 0x71,
0x70, 0x6C, 0x9D, 0x94, 0xE5, 0xFC, 0xF8, 0x18, 0xEE, 0x6D, 0x58, 0x8C, 0x47, 0x30, 0xA6, 0x83, 0x26, 0x8B, 0x4B, 0x53, 0xFB, 0x3F, 0xA4, 0xF4, 0xB5, 0x85, 0x6B, 0x50, 0x5B, 0x05, 0x9E, 0xEB,
0x30, 0xD3, 0xD3, 0x06, 0x97, 0x6F, 0xFE, 0x61, 0xDE, 0x73, 0xF4, 0xBE, 0x5B, 0x38, 0xEA, 0xD2, 0x63, 0xC8, 0x2A, 0x46, 0x68, 0x8F, 0x85, 0x17, 0xAD, 0xB7, 0xBE, 0xF0, 0x86, 0xBD, 0xF2, 0x1D,
0x7E, 0xE0, 0xD8, 0x06, 0x1D, 0x69, 0x47, 0x66, 0xF9, 0xEF, 0x63, 0xF7, 0x39, 0xA7, 0x39, 0x14, 0xDB, 0x0E, 0x63, 0x1C, 0xE4, 0x3B, 0xD5, 0xD7, 0x5F, 0x3E, 0x2A, 0x03, 0xE9, 0x63, 0x7F, 0xAC,
0x04, 0x36, 0x7A, 0xF2, 0xF7, 0xB2, 0x72, 0x55, 0x2B, 0x61, 0x41, 0x94, 0x4E, 0x6B, 0xE3, 0x7A, 0x6D, 0x9E, 0x69, 0xEA, 0x08, 0x5F, 0x74, 0x2A, 0xC3, 0xB1, 0x18, 0xB7, 0x1E, 0xC6, 0xE6, 0x08,
0x7B, 0xB2, 0xAE, 0x4B, 0xFA, 0xBA, 0xC1, 0x6B, 0x06, 0xEA, 0xCC, 0xBD, 0x07, 0x2A, 0x9D, 0x25, 0xAE, 0xDA, 0x5B, 0x69, 0x35, 0x58, 0x9E, 0xC2, 0x52, 0x1E, 0xF7, 0xC0, 0xC6, 0x12, 0x4C, 0xDA,
0xB1, 0x8C, 0x5F, 0x89, 0x9D, 0x04, 0x39, 0x93, 0x46, 0xE0, 0x2E, 0xB1, 0x24, 0x59, 0x96, 0xB3, 0x48, 0x5B, 0xA9, 0x0F, 0x30, 0x8C, 0x6F, 0xFF, 0x2E, 0x60, 0x4F, 0xB0, 0x46, 0xC3, 0x4E, 0x8B,
0xD9, 0x6B, 0x7B, 0x5F, 0xDC, 0x21, 0xC1, 0x85, 0x5C, 0xA4, 0x97, 0x2D, 0x66, 0x93, 0x1F, 0x6D, 0x16, 0xCE, 0xE7, 0x37, 0xB0, 0xCE, 0xAA, 0x03, 0x7F, 0x87, 0xD0, 0xFB, 0xE9, 0xEB, 0x15, 0x59,
0x90, 0x31, 0x95, 0xF2, 0x8A, 0xCA, 0x92, 0x1A, 0x8E, 0xDF, 0x5A, 0x63, 0x24, 0xD3, 0x36, 0x39, 0x57, 0x9A, 0x2E, 0x7C, 0x11, 0x0D, 0x9B, 0x81, 0xD6, 0x41, 0x01, 0x95, 0xFA, 0x03, 0xAC, 0x93,
0x11, 0x80, 0x46, 0x92, 0xC0, 0x8C, 0x51, 0x33, 0x43, 0xBA, 0x5E, 0xD8, 0x79, 0xA7, 0xC1, 0xE8, 0x10, 0x80, 0x3C, 0xA0, 0x2E, 0x91, 0x22, 0xB2, 0xAE, 0xD8, 0xC8, 0x00, 0x02, 0xDE, 0x81, 0xF9,
0x86, 0x67, 0x96, 0x1A, 0x7D, 0xAA, 0xAB, 0xCE, 0x53, 0x93, 0xE4, 0xE8, 0x29, 0x89, 0x3D, 0xCA, 0x2F, 0x45, 0x7A, 0x6D, 0xC7, 0xB7, 0xCC, 0x08, 0x8C, 0x61, 0x62, 0xDC, 0xB5, 0x16, 0xC0, 0x41,
0x93, 0xE6, 0x6E, 0x8A, 0xD1, 0xA3, 0xAE, 0xEA, 0x5A, 0x9C, 0xDF, 0x83, 0xE0, 0x60, 0x03, 0x2F, 0x9A, 0x2B, 0x4C, 0xA5, 0x39, 0xB3, 0xA0, 0x3B, 0xE1, 0xCA, 0x6D, 0x85, 0xD3, 0xC0, 0xB8, 0x07,
0x15, 0x37, 0x07, 0xE5, 0x80, 0x88, 0xDA, 0x63, 0x98, 0xE0, 0x49, 0x5E, 0x52, 0x5F, 0x0A, 0xF2, 0x20, 0x69, 0x89, 0x6B, 0xBF, 0xAE, 0xB6, 0xE4, 0xC4, 0x21, 0x68, 0xE0, 0x1D, 0x0D, 0x7C, 0x17,
0xF4, 0x95, 0xEC, 0xF3, 0x8F, 0xB4, 0xE9, 0xE2, 0x88, 0xCB, 0x2C, 0xE7, 0x53, 0x56, 0x74, 0x60, 0xF7, 0x8E, 0x35, 0x6E, 0x06, 0xE3, 0xCD, 0x5C, 0x4E, 0x2D, 0x9E, 0xB5, 0x62, 0xFB, 0x94, 0x3E,
0x6A, 0x0E, 0x51, 0x10, 0x7A, 0x5D, 0x45, 0x32, 0xC6, 0x10, 0xEC, 0x30, 0x23, 0xF8, 0xD9, 0xB8, 0x93, 0x0F, 0x7E, 0xF6, 0x6B, 0xA1, 0x42, 0xAA, 0x44, 0xFE, 0x6E, 0x43, 0xA5, 0xD8, 0xE0, 0xB7,
0x52, 0x23, 0x9C, 0xD5, 0x9A, 0x1A, 0x45, 0xCF, 0x97, 0x1B, 0x31, 0x3C, 0x99, 0x1C, 0x5C, 0x8C, 0x5D, 0x8D, 0x5B, 0x8D, 0xD5, 0x7A, 0xD7, 0xC3, 0x6A, 0x6F, 0xE6, 0x00, 0xE7, 0x2E, 0x56, 0x71,
0x06, 0x10, 0x33, 0xFB, 0xE3, 0xCF, 0x55, 0x9A, 0x49, 0xA9, 0x0C, 0x3F, 0x5A, 0xDC, 0xE9, 0x6B, 0xC7, 0x88, 0xAC, 0x58, 0x16, 0x45, 0xED, 0x12, 0x1B, 0xCE, 0x32, 0x9F, 0xFB, 0x1F, 0x31, 0x7C,
0x22, 0x50, 0x7D, 0x59, 0xA2, 0xFF, 0xD1, 0xA4, 0x55, 0x51, 0x74, 0x70, 0x86, 0x8E, 0xC3, 0xEA, 0xEE, 0x6F, 0xCA, 0x63, 0xA3, 0x06, 0xF2, 0x1B, 0x18, 0x51, 0xCA, 0xEC, 0xB2, 0x20, 0x5B, 0x2B,
0xC2, 0x3A, 0xD4, 0xE5, 0x5E, 0x6D, 0x21, 0xE4, 0x40, 0xE2, 0x68, 0x29, 0xDC, 0xEA, 0x60, 0xB2, 0x9B, 0xF3, 0x63, 0xF7, 0x8F, 0xC7, 0x27, 0x97, 0xBC, 0x7A, 0x97, 0x78, 0x6A, 0x2F, 0x9C, 0x9D,
0x9C, 0xDC, 0xCE, 0x2B, 0x70, 0x5B, 0xEE, 0x13, 0x30, 0xD5, 0x5D, 0x38, 0xB6, 0x49, 0x55, 0x17, 0xA5, 0x1F, 0xD7, 0x4E, 0x24, 0x94, 0xAB, 0xBC, 0x6A, 0x47, 0x07, 0xED, 0x5A, 0x24, 0x76, 0x8C,
0x87, 0x4F, 0xB9, 0x13, 0xE1, 0xF2, 0x9B, 0xB3, 0x55, 0x84, 0x1A, 0x52, 0x7D, 0x83, 0x18, 0xEF, 0xFD, 0x38, 0xA1, 0xE1, 0x72, 0x74, 0x2C, 0x4A, 0xD9, 0x1F, 0x09, 0xF3, 0x5B, 0xC8, 0x00, 0xB9,
0xD4, 0x1D, 0x8F, 0x4B, 0xEE, 0x13, 0xB3, 0xC8, 0xFD, 0xF3, 0x9E, 0xCA, 0x79, 0x2B, 0xCF, 0x0B, 0xF7, 0xEF, 0x88, 0xD4, 0x8E, 0x88, 0x78, 0xA9, 0xB0, 0xFA, 0x34, 0xAC, 0xA8, 0x75, 0x60, 0xC8,
0x6A, 0xE9, 0x87, 0xE2, 0xA0, 0x5A, 0x4F, 0xE7, 0x58, 0xC7, 0x76, 0xFA, 0x8A, 0x49, 0x52, 0xFE, 0x64, 0xD8, 0x87, 0x04, 0xFF, 0x48, 0x82, 0xBB, 0x30, 0xF0, 0xC7, 0xBF, 0x44, 0x72, 0x22, 0xCD,
0x5F, 0xEE, 0x04, 0xF1, 0xB4, 0x92, 0xEF, 0x35, 0xC8, 0xF4, 0x30, 0xD2, 0x44, 0xE7, 0x37, 0xD4, 0x02, 0x98, 0x7A, 0xD1, 0x9B, 0x19, 0x0D, 0xF2, 0xFA, 0x18, 0x28, 0x91, 0x6E, 0x31, 0xC9, 0x2C,
0x9B, 0x8F, 0x52, 0xA5, 0xA4, 0xF2, 0xD2, 0x09, 0xB0, 0x23, 0x75, 0x62, 0x98, 0x03, 0x97, 0x75, 0x27, 0x45, 0xCB, 0x68, 0xD0, 0x6C, 0x58, 0xC4, 0xB9, 0x31, 0xBD, 0x42, 0xD5, 0x4C, 0x76, 0x8C,
0x18, 0x63, 0x64, 0x48, 0x71, 0xDC, 0xCF, 0xD6, 0xE4, 0x93, 0xFF, 0xAC, 0xCC, 0xB5, 0x7A, 0xDB, 0xB0, 0x3A, 0x97, 0x9E, 0xD9, 0xFC, 0xD6, 0x32, 0xBA, 0x27, 0x45, 0x5F, 0xB8, 0xC5, 0x78, 0xA2,
0x1E, 0x56, 0xEB, 0x7E, 0x0B, 0x9D, 0x1C, 0x90, 0x1C, 0xD2, 0x83, 0x81, 0x83, 0x9F, 0x62, 0x05, 0x13, 0x25, 0x45, 0x52, 0xDE, 0x0F, 0x2C, 0x2D, 0x38, 0x82, 0x34, 0xD4, 0x93, 0xA1, 0xC0, 0x7E,
0xA7, 0xAF, 0xC4, 0xEA, 0x15, 0xCD, 0x4C, 0x02, 0xAF, 0x73, 0xEF, 0xFD, 0x47, 0xF2, 0xA4, 0x90, 0xE3, 0x10, 0x11, 0x2C, 0xDD, 0xC5, 0xFF, 0xB5, 0x34, 0xCB, 0x02, 0x5A, 0xAD, 0xDA, 0xB9, 0x2C,
0xB5, 0x4E, 0x46, 0xF8, 0xA2, 0x84, 0xA2, 0xB1, 0x10, 0x87, 0xBA, 0x9A, 0xA3, 0xC7, 0x31, 0x51, 0x9F, 0xE9, 0xB2, 0x5B, 0x9C, 0x46, 0xFB, 0x53, 0x66, 0xA0, 0xAA, 0x54, 0x4E, 0x8B, 0x9A, 0xF3,
0xCF, 0xFC, 0x5E, 0xC4, 0x43, 0xD5, 0xD3, 0xFB, 0x4E, 0xB6, 0xCD, 0x03, 0x7B, 0xC7, 0xAA, 0xEB, 0x3E, 0x44, 0xF5, 0x8E, 0x6E, 0x10, 0x64, 0x9D, 0xE6, 0xC1, 0xA1, 0xCB, 0x3B, 0x10, 0x3B, 0x28,
0x78, 0x9F, 0x06, 0xAC, 0x82, 0xDB, 0x08, 0x36, 0x04, 0x70, 0x56, 0x66, 0x00, 0x7D, 0x3A, 0xAC, 0x3B, 0x24, 0x1E, 0x04, 0xAC, 0xCF, 0x7A, 0x2F, 0xCE, 0x71, 0xB1, 0x8F, 0x6B, 0xB0, 0x34, 0x3A,
0xF8, 0x6A, 0x42, 0x2E, 0x9B, 0xF9, 0xC8, 0xE0, 0x61, 0x57, 0x61, 0xC8, 0xE8, 0x8D, 0xDF, 0xE5, 0x9F, 0x67, 0x58, 0x15, 0xBB, 0x6C, 0x06, 0x38, 0x39, 0x9C, 0xB6, 0x2A, 0x08, 0x25, 0xAF, 0x3B,
0x1F, 0xED, 0xA2, 0xAE, 0xDD, 0xC2, 0x38, 0xA2, 0xC0, 0xD0, 0xDF, 0x2D, 0xCA, 0xDC, 0xCD, 0xE9, 0xF6, 0x09, 0x5D, 0xC0, 0x2D, 0x9B, 0xB5, 0x5E, 0xA1, 0xDD, 0x90, 0x1E, 0xEA, 0xC7, 0xA4, 0x72,
0x2E, 0x80, 0xA6, 0x72, 0x47, 0x18, 0x82, 0x64, 0x1B, 0x17, 0x10, 0xD5, 0x5A, 0x9E, 0x44, 0xE0, 0x53, 0x49, 0x61, 0xAB, 0x72, 0xF3, 0x28, 0x5E, 0xC3, 0x6A, 0x0E, 0xEC, 0x83, 0x98, 0x52, 0x6E,
0x0A, 0x02, 0xF1, 0x12, 0x85, 0xFF, 0x60, 0x50, 0x8E, 0x64, 0xE0, 0x74, 0x4F, 0xB4, 0x1A, 0xFB, 0x44, 0x30, 0x8E, 0x48, 0x49, 0xF3, 0x9F, 0xEF, 0x4F, 0x58, 0xB9, 0xE4, 0xAE, 0x46, 0x68, 0x8E,
0xBD, 0x61, 0x9F, 0xA5, 0x88, 0xC9, 0x76, 0xDA, 0xA9, 0x37, 0x8D, 0x48, 0x84, 0xD8, 0xC3, 0x52, 0x6B, 0x6D, 0xF2, 0x1A, 0xFC, 0xF2, 0x7E, 0x90, 0x48, 0xED, 0x2A, 0x88, 0x9B, 0x9E, 0x8A, 0xE9,
0x2B, 0x49, 0x04, 0x85, 0xAE, 0x52, 0x4E, 0xD7, 0x51, 0xED, 0x4C, 0x87, 0xDE, 0x2D, 0x49, 0xF3, 0x6A, 0xBF, 0x52, 0xF4, 0xF1, 0xD3, 0xC7, 0x99, 0xF8, 0x1D, 0x22, 0x9D, 0xD7, 0x21, 0xCE, 0x1D,
0x34, 0x1F, 0xA5, 0x8F, 0xA5, 0xD7, 0x1B, 0x7B, 0x03, 0x40, 0xFE, 0x5F, 0x78, 0x69, 0xC4, 0xCA, 0xAB, 0xCE, 0x7C, 0x58, 0xC3, 0x0C, 0xAA, 0x45, 0x9C, 0x96, 0xCD, 0x4A, 0xBA, 0xF9, 0x39, 0x04,
0xDD, 0x39, 0x2B, 0x7A, 0xBA, 0xBB, 0xDE, 0x25, 0xEF, 0x14, 0xA4, 0x4E, 0x39, 0x9D, 0x7C, 0x79, 0x85, 0x0B, 0xBF, 0x28, 0x0A, 0x9E, 0x15, 0x85, 0xFB, 0x19, 0x75, 0x36, 0x64, 0x86, 0x4F, 0x76,
0xAD, 0x2E, 0xA6, 0xAF, 0x8F, 0xD4, 0xDA, 0x22, 0xC0, 0x5E, 0x6E, 0xD0, 0x98, 0xBF, 0x60, 0x43, 0x9B, 0xF9, 0xCA, 0x7A, 0x60, 0xD2, 0x8A, 0xD8, 0xDC, 0x3C, 0x82, 0x26, 0x20, 0x65, 0x60, 0x5C,
0x03, 0x62, 0x75, 0x88, 0x60, 0x05, 0x7C, 0x3B, 0x88, 0x85, 0xF9, 0x6C, 0xDF, 0xE3, 0xAD, 0xCA, 0x40, 0x5F, 0xCD, 0x68, 0x3C, 0xC9, 0x9E, 0xA4, 0x73, 0x77, 0xCB, 0x62, 0xA2, 0xB1, 0x72, 0x9D,
0x52, 0xF0, 0x01, 0x5D, 0xF3, 0x28, 0x33, 0xBA, 0xC0, 0x08, 0xA1, 0xB0, 0xB0, 0x81, 0xCC, 0x7C, 0xC5, 0x09, 0x38, 0xA0, 0xB1, 0x08, 0x3C, 0x3C, 0x84, 0x79, 0xB6, 0x40, 0x57, 0x79, 0xAE, 0x7C,
0x54, 0xA3, 0x12, 0xFF, 0x8E, 0xF3, 0x4D, 0xDD, 0x05, 0xE1, 0x26, 0x0D, 0x30, 0xEB, 0xC5, 0x96, 0x2A, 0x9B, 0xAA, 0xAA, 0x05, 0x58, 0x12, 0x1D, 0x9F, 0x7C, 0x03, 0x82, 0xF5, 0xA3, 0xF2, 0x63,
0x7E, 0x5A, 0x7E, 0x6D, 0x5B, 0xAA, 0xF9, 0x84, 0x9F, 0xB1, 0x0A, 0xA1, 0x3F, 0xCD, 0x0C, 0xCA, 0x4A, 0xBF, 0x93, 0xE3, 0xBC, 0x1F, 0xB4, 0xC9, 0x53, 0xA7, 0x29, 0x53, 0x5B, 0x8E, 0x2E, 0x3D,
0x2C, 0x90, 0x2B, 0x77, 0x8A, 0xC5, 0x73, 0xC4, 0x18, 0x85, 0xA2, 0xC1, 0x9C, 0xAC, 0x58, 0xF7, 0x70, 0x92, 0x64, 0x4E, 0xA9, 0x2F, 0x82, 0xA2, 0xA7, 0xAE, 0x7D, 0x4E, 0x04, 0x6E, 0x2C, 0x20,
0xF1, 0x89, 0x9D, 0xDB, 0x67, 0x79, 0xA9, 0x35, 0x15, 0x24, 0x94, 0xF6, 0x28, 0xBC, 0x2F, 0x09, 0x0E, 0xDF, 0x12, 0x64, 0x94, 0x25, 0xB1, 0x1E, 0x8F, 0x56, 0x9A, 0x34, 0x6A, 0xC8, 0x4C, 0xDC,
0x86, 0xD3, 0x87, 0xC7, 0x1D, 0x86, 0xE4, 0xD7, 0x85, 0xD8, 0x3A, 0x30, 0xF9, 0xA4, 0xE0, 0x6C, 0x57, 0xC4, 0x30, 0x15, 0xB3, 0x40, 0x44, 0xF4, 0xAB, 0x7A, 0xA7, 0x79, 0xD3, 0xBA, 0x6A, 0x0A,
0x65, 0xB8, 0x06, 0x16, 0xF8, 0x8C, 0x17, 0x46, 0x57, 0xC2, 0x14, 0x33, 0xD6, 0xDB, 0xC5, 0x4B, 0xBF, 0x3A, 0x9C, 0x47, 0xD8, 0xDC, 0xA2, 0x30, 0x53, 0xC1, 0xED, 0xD4, 0xA4, 0x6D, 0x55, 0x46,
0x7E, 0x18, 0x11, 0xCB, 0x6C, 0x0E, 0x29, 0x03, 0xF6, 0x50, 0x1B, 0x39, 0x10, 0x03, 0xE0, 0x82, 0x85, 0x5B, 0x88, 0x85, 0x9E, 0x4D, 0x88, 0xBB, 0x64, 0xB5, 0xEE, 0xE5, 0x9E, 0x7D, 0x53, 0xFB,
0xA3, 0x24, 0xA9, 0xCD, 0x67, 0x70, 0xA2, 0xEE, 0xEF, 0xFF, 0xCF, 0x75, 0x68, 0xEC, 0x38, 0x49, 0x01, 0x1F, 0x05, 0x01, 0x2E, 0x8B, 0xA8, 0xD3, 0x37, 0xAF, 0xAC, 0xC6, 0x30, 0x96, 0x35, 0x9A,
0x34, 0x5C, 0x1F, 0xAA, 0x93, 0x9C, 0xB6, 0x3D, 0x8E, 0x4B, 0xE6, 0xDF, 0xC4, 0x53, 0x72, 0x90, 0xFC, 0x63, 0x31, 0xD8, 0x4E, 0xE0, 0x85, 0x14, 0xD1, 0xD6, 0x38, 0xB9, 0xB3, 0xAF, 0x7E, 0x08,
0x8B, 0xC8, 0x4B, 0x47, 0xC9, 0x2D, 0x46, 0x51, 0xB4, 0x1F, 0x79, 0x42, 0xBB, 0xD6, 0xC1, 0x06, 0xDB, 0x8E, 0x86, 0xBE, 0xA4, 0x59, 0xFD, 0x72, 0x26, 0x6F, 0x9D, 0xC5, 0x18, 0x05, 0xD8, 0x0F,
0x09, 0x02, 0xB6, 0x5F, 0xF6, 0xEA, 0x22, 0xD8, 0x66, 0x1A, 0xC5, 0xAE, 0x7A, 0xD5, 0xB1, 0x24, 0x6F, 0x76, 0x81, 0x23, 0x03, 0xFB, 0x5B, 0x9E, 0x72, 0x0D, 0x74, 0xE0, 0x9C, 0x79, 0x5B, 0xE4,
0x58, 0x5A, 0x3B, 0x3E, 0x12, 0xBA, 0xEF, 0x13, 0x8F, 0xA9, 0x0F, 0x56, 0x89, 0xFF, 0x65, 0x8E, 0x6E, 0x62, 0x3C, 0x48, 0xD1, 0x79, 0x10, 0x4A, 0xF1, 0x0F, 0x40, 0xC2, 0x8A, 0x53, 0x19, 0xED,
0x2B, 0x21, 0xEA, 0x9F, 0xF4, 0xFF, 0xE9, 0x44, 0x96, 0xE9, 0xA7, 0x54, 0x13, 0xF1, 0xF5, 0x7E, 0x50, 0xAD, 0x90, 0x6A, 0xC9, 0x05, 0x42, 0x97, 0x11, 0x2D, 0x68, 0x69, 0xB1, 0x03, 0x82, 0xE7,
0xCE, 0xC0, 0x7D, 0xDE, 0x23, 0x8D, 0xD0, 0xD5, 0x71, 0xAE, 0xFE, 0xD4, 0x0B, 0x08, 0xE8, 0x8D, 0xAB, 0x76, 0x65, 0x58, 0xE7, 0xFE, 0x23, 0x08, 0x6A, 0xCE, 0xFB, 0x58, 0x40, 0x4A, 0xF0, 0xD9,
0x92, 0xC4, 0x53, 0xE7, 0x3C, 0x1E, 0x40, 0xC7, 0x51, 0x98, 0xF8, 0xA5, 0xED, 0x3A, 0x83, 0xB4, 0xA7, 0xE0, 0xB8, 0x02, 0x8A, 0x43, 0x50, 0x9A, 0x5F, 0xE2, 0xF7, 0x83, 0x3A, 0x47, 0xCD, 0x21,
0xCB, 0xBE, 0xAC, 0xDB, 0x61, 0x9E, 0xE4, 0xAF, 0xF2, 0xD9, 0xC2, 0x84, 0xDD, 0x1C, 0xCF, 0x1B, 0x03, 0x42, 0xC3, 0xDC, 0x9C, 0x0D, 0x3D, 0xD1, 0x3A, 0xCB, 0x8F, 0xC0, 0x82, 0x3C, 0xEA, 0xB1,
0xF1, 0x46, 0x76, 0x4A, 0x63, 0xF3, 0x4E, 0xA5, 0x37, 0x17, 0x61, 0xCB, 0xF1, 0x75, 0xBB, 0xBD, 0xED, 0x76, 0x05, 0x6E, 0xB8, 0xF6, 0x2F, 0x84, 0xC8, 0xA6, 0x9A, 0x2B, 0xCA, 0x0C, 0x50, 0x69,
0xA3, 0x8E, 0x70, 0x7E, 0x2B, 0x24, 0xD0, 0xEE, 0x35, 0x4D, 0xB8, 0xF6, 0x67, 0xBD, 0xC4, 0x4B, 0x94, 0x47, 0x77, 0xCC, 0x86, 0xAF, 0xEC, 0xD3, 0x38, 0x7D, 0x2C, 0x67, 0xBE, 0x10, 0x3D, 0xB4,
0x37, 0x41, 0x18, 0x28, 0x47, 0xB2, 0xA7, 0x7D, 0x83, 0x34, 0x07, 0x8C, 0x74, 0x9C, 0xF1, 0x0F, 0x56, 0xBB, 0xAB, 0xAC, 0x64, 0x5D, 0x28, 0x6B, 0x1B, 0x36, 0xBE, 0xF9, 0x19, 0xA5, 0x3D, 0x97,
0x84, 0xE7, 0xE3, 0xD9, 0x03, 0xA8, 0x75, 0xA5, 0xFE, 0x42, 0x64, 0xD8, 0x48, 0x9C, 0x0B, 0x4B, 0x83, 0xC9, 0xF6, 0xA8, 0x46, 0x16, 0x87, 0x90, 0x91, 0xC8, 0x90, 0xEB, 0x93, 0x2B, 0x45, 0x8F,
0xB5, 0x37, 0x89, 0xE3, 0x42, 0x4B, 0x73, 0xF1, 0x98, 0x5B, 0xA5, 0x96, 0x09, 0xB0, 0xF7, 0xDC, 0xE1, 0xC1, 0x4A, 0x6F, 0x04, 0x1D, 0xB0, 0x76, 0x18, 0x50, 0x64, 0x27, 0x9C, 0x31, 0xEF, 0xA1,
0x62, 0x43, 0x2A, 0x3B, 0xC4, 0xDD, 0x7C, 0x46, 0x34, 0xCE, 0xFD, 0xA0, 0x21, 0xC2, 0x6C, 0x96, 0x9A, 0xA5, 0x56, 0x90, 0x83, 0xE4, 0x73, 0xCF, 0x2B, 0x2D, 0x5F, 0x8E, 0x09, 0x77, 0x73, 0xC7,
0x8C, 0x7F, 0x85, 0x8E, 0xDE, 0x8C, 0x05, 0x1F, 0x95, 0xC7, 0x29, 0x30, 0xF0, 0x9A, 0x1C, 0x21, 0xBC, 0x2D, 0x1B, 0x4C, 0xE6, 0xF3, 0x06, 0x63, 0xC5, 0x10, 0x7F, 0xFE, 0xD2, 0x80, 0x2C, 0xC4,
0xF4, 0x7C, 0xFC, 0xD5, 0x74, 0x74, 0x97, 0x7A, 0x83, 0x7B, 0x89, 0xF9, 0x6D, 0xD5, 0xCA, 0xB6, 0x25, 0xEC, 0xA1, 0x09, 0x8D, 0x34, 0xBD, 0xD0, 0x14, 0xE3, 0x84, 0x99, 0x2A, 0x25, 0x8C, 0x04,
0x17, 0xED, 0xB7, 0xD2, 0xB9, 0xD1, 0xB6, 0x0A, 0xBB, 0x5C, 0x3D, 0x27, 0x82, 0xFD, 0xC9, 0x55, 0x74, 0x5B, 0xB2, 0x82, 0xB7, 0x2E, 0x22, 0xFA, 0x2D, 0x45, 0xF7, 0xF1, 0xA9, 0x49, 0x75, 0xE2,
0xE7, 0xC6, 0x2C, 0x8F, 0x1E, 0x6C, 0x32, 0x75, 0x59, 0x0E, 0x0E, 0xCA, 0xB7, 0x77, 0x49, 0xF2, 0x64, 0xC0, 0xD5, 0xD4, 0x63, 0x28, 0xA9, 0x92, 0x5B, 0x49, 0x6D, 0xF7, 0xEB, 0xCC, 0x6D, 0x4B,
0xA7, 0x4E, 0xBB, 0xF1, 0x61, 0xAE, 0x69, 0x15, 0xA5, 0x6D, 0x69, 0x56, 0x05, 0x90, 0x22, 0x9A, 0x3E, 0x82, 0x1E, 0x28, 0x10, 0x04, 0x9A, 0xF0, 0xDD, 0xB9, 0x49, 0x18, 0x16, 0x82, 0x48, 0x37,
0xF4, 0x38, 0x90, 0x75, 0xD3, 0x34, 0x11, 0x09, 0xC6, 0xB3, 0x37, 0x15, 0x87, 0x48, 0x02, 0x10, 0x69, 0x6B, 0xEC, 0x54, 0xB4, 0x42, 0xD3, 0xDE, 0x10, 0x22, 0x01, 0xA8, 0xF9, 0x92, 0x70, 0x2F,
0x1D, 0xAE, 0xD5, 0x43, 0xB9, 0xB5, 0xB3, 0xD4, 0x42, 0xBA, 0xAA, 0x2F, 0x13, 0x41, 0x19, 0x1B, 0x9F, 0x7D, 0xF4, 0x10, 0x38, 0xEB, 0xC7, 0x7C, 0x45, 0xA6, 0x28, 0xD9, 0xC9, 0xEB, 0xCF, 0x02,
0x9E, 0x06, 0xC9, 0x68, 0x97, 0x56, 0xB3, 0x0D, 0xD8, 0x7F, 0xDD, 0x73, 0x45, 0x3D, 0xEA, 0x33, 0x25, 0x70, 0xB3, 0x75, 0x1F, 0xBE, 0xB3, 0x35, 0x31, 0x92, 0x55, 0x8B, 0xCC, 0x2C, 0x29, 0xA1,
0xF6, 0x73, 0x34, 0xF2, 0x89, 0x42, 0x05, 0xB9, 0x5E, 0x03, 0xAC, 0xD0, 0xA6, 0x12, 0x92, 0x11, 0x56, 0xFF, 0xF6, 0x09, 0xB7, 0x02, 0xBC, 0xF5, 0xA0, 0x2D, 0xF0, 0x84, 0xAC, 0xD3, 0x91, 0x11,
0x93, 0xD8, 0xDE, 0x53, 0x25, 0x91, 0xB2, 0x43, 0x4E, 0x8D, 0x5F, 0x5A, 0x2F, 0x15, 0x15, 0x61, 0x70, 0x7A, 0x8E, 0x0A, 0x13, 0xE0, 0xE4, 0x6D, 0x56, 0xBC, 0xBD, 0xFC, 0xA3, 0x98, 0xE0, 0xBB,
0x6A, 0x1B, 0x70, 0xEB, 0x14, 0x81, 0x55, 0x51, 0xD2, 0x49, 0xEB, 0x10, 0xB3, 0xCE, 0x77, 0x05, 0xA3, 0xE9, 0xF2, 0x4A, 0x19, 0x77, 0x1A, 0xE4, 0x59, 0xCF, 0x64, 0xCE, 0xBB, 0xE4, 0x67, 0xA4,
0x72, 0xB0, 0x5D, 0x78, 0x21, 0xA6, 0x09, 0x09, 0x25, 0xDA, 0xCA, 0x4B, 0xA1, 0x20, 0x44, 0xA3, 0x64, 0xC7, 0x2F, 0x04, 0xB3, 0xF9, 0x6C, 0xA9, 0x9E, 0x03, 0xEB, 0xA3, 0xCE, 0xCF, 0x72, 0xC8,
0xE5, 0xBC, 0xD0, 0x1E, 0xB3, 0x98, 0xB1, 0x65, 0x19, 0x4A, 0x17, 0xE5, 0x01, 0xE9, 0x81, 0x23, 0x83, 0xF1, 0x37, 0x8A, 0x0F, 0xD1, 0xC2, 0xFD, 0x28, 0xB3, 0xDF, 0x0A, 0x1E, 0xC3, 0x27, 0x4D,
0xE2, 0x03, 0x67, 0x77, 0xD2, 0x64, 0x26, 0x5C, 0xAA, 0x3E, 0x70, 0xC3, 0xB3, 0x79, 0xA0, 0x1D, 0xEF, 0xCA, 0x31, 0x16, 0x59, 0x92, 0xC0, 0xFF, 0x77, 0x30, 0x11, 0xB2, 0xFB, 0x48, 0xDD, 0x70,
0x74, 0x06, 0x03, 0x1B, 0xFB, 0x6B, 0xD0, 0x6B, 0x7C, 0x92, 0x71, 0x38, 0xF0, 0xC6, 0x89, 0x4E, 0x58, 0x64, 0x3B, 0xF0, 0x97, 0x46, 0xD5, 0x4C, 0xB6, 0x9A, 0x8A, 0x0F, 0xEF, 0x3A, 0x47, 0x35,
0x2E, 0xE8, 0xBC, 0xFF, 0x12, 0xA8, 0xC9, 0x22, 0x2C, 0xAC, 0x1D, 0x53, 0xFB, 0x74, 0x3F, 0xC9, 0x46, 0x47, 0x59, 0xC2, 0x39, 0xA7, 0xB6, 0x62, 0xD6, 0x29, 0x0D, 0x71, 0x26, 0xFE, 0x08, 0x24,
0xAD, 0xDA, 0xD2, 0x6A, 0x2E, 0xD8, 0xC4, 0x5E, 0xD9, 0x1B, 0x4B, 0xAC, 0x9A, 0xD2, 0xE3, 0x4D, 0x5A, 0xC1, 0xF1, 0x42, 0xE2, 0xDC, 0x8D, 0x33, 0x8C, 0x64, 0xDE, 0x86, 0xC5, 0x21, 0xC8, 0x5A,
0xF8, 0x03, 0xD5, 0xF5, 0x15, 0x41, 0x49, 0x96, 0xA3, 0xC4, 0x02, 0x4F, 0x14, 0xF8, 0xF9, 0x19, 0x5F, 0xC6, 0xA4, 0x86, 0x21, 0x4F, 0xD4, 0x9C, 0xC4, 0x71, 0x63, 0xE5, 0xFC, 0x78, 0x38, 0xDB,
0xE6, 0x24, 0x24, 0x22, 0x92, 0x7C, 0xA6, 0x1A, 0x9F, 0xE4, 0xF7, 0x8A, 0x81, 0xB9, 0xD2, 0x64, 0x83, 0xBF, 0xF2, 0xB3, 0x74, 0xCC, 0xE0, 0x55, 0x77, 0xBD, 0x1B, 0x1A, 0x84, 0x82, 0x6C, 0x6D,
0x6A, 0x00, 0x4D, 0x80, 0x5F, 0x23, 0x36, 0x24, 0xB9, 0x15, 0xB6, 0x7E, 0x93, 0x71, 0xB3, 0xE3, 0x96, 0x57, 0xD8, 0xED, 0x9A, 0x02, 0x70, 0x2D, 0xED, 0x1C, 0xC3, 0x76, 0x2D, 0x48, 0xDB, 0xA5,
0x8B, 0x23, 0x44, 0x17, 0x7D, 0x75, 0x32, 0x3A, 0xA5, 0x6C, 0xA3, 0x01, 0x4F, 0xD3, 0xCE, 0x15, 0x28, 0x1C, 0xE2, 0x47, 0x9E, 0x56, 0xC6, 0x0F, 0xDD, 0xCA, 0x66, 0x52, 0x91, 0x9F, 0x4E, 0xA4,
0x12, 0x30, 0x0D, 0x33, 0xC2, 0xC9, 0xFA, 0xD9, 0x2D, 0xEC, 0x6E, 0x91, 0x23, 0xD3, 0xC6, 0x55, 0x3B, 0xA9, 0xC1, 0x99, 0x77, 0xD2, 0x9F, 0x59, 0x6D, 0x04, 0x21, 0x64, 0x6F, 0xDF, 0x2B, 0x6E,
0x17, 0x00, 0xF4, 0x09, 0xB4, 0x2A, 0xFC, 0xA2, 0xA4, 0x39, 0xE0, 0x77, 0x2F, 0xB9, 0x33, 0x2B, 0x76, 0xFB, 0x5F, 0xAA, 0x73, 0xBE, 0x10, 0xEA, 0x57, 0xC0, 0xAD, 0x40, 0x24, 0x19, 0x83, 0xD7,
0x9D, 0x93, 0xC6, 0x07, 0x05, 0xF4, 0xBD, 0xC6, 0xA7, 0x8F, 0xE9, 0xC6, 0x24, 0x9C, 0x10, 0x5E, 0x81, 0x6A, 0x87, 0x94, 0xAF, 0x0C, 0xA0, 0x61, 0x68, 0xBA, 0x63, 0x69, 0xFA, 0x04, 0x31, 0x3A,
0x45, 0xCE, 0xC4, 0x90, 0x3B, 0xFA, 0x72, 0x18, 0x8F, 0xDA, 0x0C, 0xBA, 0xAB, 0x40, 0xB1, 0xEF, 0x61, 0xC0, 0x04, 0x2A, 0x95, 0x79, 0xF7, 0xB8, 0x2B, 0xBB, 0x19, 0xD4, 0x5E, 0xA9, 0x2D, 0x22,
0xF1, 0x4E, 0xAA, 0xCA, 0xE8, 0x95, 0x3A, 0xF4, 0x8B, 0xC6, 0x88, 0xEA, 0x98, 0x22, 0xF1, 0x43, 0x0B, 0x46, 0xC1, 0xAB, 0x0A, 0x5D, 0xB6, 0x3B, 0x99, 0x78, 0x59, 0x1F, 0x15, 0xB8, 0x5D, 0xC0,
0xFC, 0x86, 0xD2, 0x3F, 0x94, 0xC0, 0x8E, 0x13, 0xEF, 0xF8, 0x2E, 0x69, 0xED, 0xD0, 0x31, 0x8E, 0xFD, 0x9D, 0xE1, 0x6A, 0x58, 0x08, 0x58, 0x7E, 0xC5, 0x64, 0xB7, 0x43, 0x81, 0xF5, 0xBE, 0xBF,
0x77, 0xB4, 0xC3, 0x6C, 0xAC, 0xC7, 0x67, 0x88, 0xC6, 0x5A, 0xCA, 0xFA, 0xAC, 0xC6, 0x36, 0xBA, 0x5E, 0x43, 0x1F, 0xB5, 0x87, 0x38, 0x6F, 0x9D, 0x71, 0xA2, 0x57, 0xF0, 0xCD, 0x17, 0xA4, 0xA4,
0x81, 0xDD, 0x17, 0x5D, 0xCA, 0xAF, 0xF4, 0xFF, 0x48, 0xBA, 0x4B, 0x12, 0xBD, 0x6E, 0xAE, 0xD0, 0x76, 0x35, 0x94, 0x79, 0x7E, 0x97, 0xCB, 0x43, 0xA0, 0xCE, 0xFF, 0x95, 0x12, 0x88, 0x3D, 0xC3,
0x43, 0xDF, 0x0B, 0x2D, 0xF1, 0x2E, 0x02, 0x64, 0x23, 0xC4, 0xAA, 0x6A, 0x9A, 0x3F, 0xD7, 0x8D, 0xAA, 0x66, 0x86, 0xBC, 0xC8, 0x9A, 0xBC, 0xE8, 0xD7, 0x89, 0x21, 0xC6, 0x55, 0xFF, 0x8F, 0x4C,
0x47, 0x68, 0x20, 0x21, 0xAA, 0x1E, 0x0F, 0x96, 0xD6, 0x7D, 0x75, 0xC3, 0xEA, 0xED, 0x2B, 0xA4, 0x59, 0xF3, 0xC8, 0x89, 0x9D, 0xA6, 0xD4, 0x8A, 0x64, 0x91, 0x93, 0x19, 0x40, 0x9E, 0xC8, 0x14,
0x0D, 0x75, 0x78, 0x66, 0x7B, 0x5E, 0x18, 0x1A, 0x29, 0x03, 0xCC, 0xF7, 0x88, 0x12, 0x38, 0x3A, 0x07, 0x70, 0xEB, 0xB2, 0xA2, 0xE5, 0x08, 0x62, 0x85, 0x00, 0x44, 0xBF, 0x89, 0x2C, 0x79, 0x11,
0x8F, 0xD2, 0x85, 0xE6, 0xB7, 0x88, 0xF0, 0xA1, 0x08, 0x07, 0x70, 0xFD, 0xC3, 0xB2, 0x31, 0x54, 0xA2, 0x84, 0xE7, 0x5D, 0x90, 0x79, 0x26, 0xEB, 0xD4, 0xC5, 0xA5, 0xC5, 0x40, 0x23, 0xA3, 0xE7,
0x13, 0x01, 0x9E, 0xA3, 0xEE, 0x9B, 0xB8, 0xF6, 0xDE, 0x3E, 0x5B, 0x7D, 0x92, 0xA5, 0xDD, 0x2A, 0x3D, 0x0B, 0x31, 0xAB, 0x19, 0x65, 0xD2, 0xD1, 0x52, 0xED, 0xD3, 0x0B, 0x20, 0xF6, 0xC9, 0x25,
0x55, 0xB6, 0xFC, 0x02, 0x6E, 0xC4, 0x7C, 0xB5, 0x66, 0xB3, 0xF1, 0xE8, 0x27, 0x4A, 0xD1, 0x69, 0xB4, 0x61, 0x5D, 0x0F, 0x1E, 0x4A, 0xEE, 0xC9, 0xBC, 0x46, 0xF6, 0x1B, 0xA9, 0xC9, 0x41, 0x82,
0xF4, 0x89, 0x2D, 0xB0, 0x12, 0xAC, 0x53, 0xF5, 0x7A, 0xA1, 0x0F, 0x45, 0x3A, 0x49, 0x74, 0xA2, 0xB1, 0x0F, 0xFE, 0xC1, 0xAE, 0xDD, 0xCC, 0x96, 0x06, 0xDE, 0x8E, 0x8E, 0x8E, 0x4C, 0xE4, 0xD6,
0xF2, 0x4F, 0x96, 0x32, 0x6F, 0xC4, 0x44, 0xCC, 0xC0, 0x69, 0x58, 0xDE, 0x9D, 0x2F, 0x2E, 0xC4, 0x86, 0x36, 0xC3, 0xE4, 0xE7, 0xE8, 0x34, 0xB7, 0x8C, 0xDF, 0xC9, 0x5F, 0x98, 0x94, 0x9B, 0x93,
0x4F, 0xFB, 0xF4, 0xD6, 0x57, 0xFB, 0x05, 0xA3, 0x73, 0x78, 0xF8, 0xD6, 0xD0, 0x6F, 0x3E, 0x1A, 0x7F, 0x0F, 0x59, 0x89, 0xF0, 0xCD, 0x57, 0xA9, 0xE0, 0xB5, 0x68, 0x4A, 0x3B, 0xEE, 0x46, 0x49,
0x00, 0xD4, 0x4D, 0x0C, 0xA8, 0xE3, 0xFE, 0xCC, 0x4A, 0x94, 0x34, 0x90, 0xAE, 0x99, 0x71, 0x7F, 0xA6, 0x19, 0x72, 0x03, 0xE6, 0x96, 0x61, 0x50, 0x23, 0x18, 0xC6, 0x61, 0x1D, 0x26, 0x46, 0x1D,
0x27, 0x53, 0x67, 0xED, 0x5F, 0x66, 0xDB, 0xA5, 0x18, 0xE4, 0xDE, 0xC9, 0x5F, 0xC0, 0xED, 0xF9, 0xAF, 0x9B, 0xE0, 0x02, 0x73, 0x50, 0x0D, 0xFA, 0x1C, 0xC3, 0xE8, 0xE5, 0x94, 0x4C, 0x55, 0xFE,
0x11, 0xA5, 0x12, 0xBB, 0xC0, 0x47, 0x5C, 0xCB, 0x86, 0xE4, 0x2F, 0x37, 0x43, 0x18, 0x3D, 0xB6, 0x54, 0x85, 0xAD, 0x9C, 0x76, 0xD5, 0x16, 0x8F, 0x9B, 0xC8, 0x8A, 0xB9, 0xB6, 0xF8, 0x13, 0x2B,
0xD2, 0x25, 0xDB, 0xD6, 0xDF, 0x9D, 0xF2, 0x6A, 0xD7, 0xA5, 0xF2, 0x66, 0x2D, 0x75, 0x58, 0xC9, 0x9D, 0x8F, 0x8F, 0xD9, 0x12, 0x04, 0xA9, 0x78, 0xBB, 0x48, 0x22, 0xE4, 0xC5, 0xB0, 0x9F, 0xD6,
0xC4, 0x3C, 0x63, 0xD0, 0xF5, 0xDC, 0x37, 0x7C, 0xA2, 0xAA, 0x40, 0x61, 0x59, 0x2E, 0x63, 0x49, 0x3E, 0x3C, 0xDE, 0x00, 0x44, 0x99, 0xFC, 0x13, 0x65, 0x0A, 0x3A, 0xA0, 0x2F, 0x35, 0xBE, 0x27,
0x98, 0x14, 0x1C, 0x4E, 0x20, 0x96, 0x43, 0x21, 0xE2, 0xC7, 0x11, 0x41, 0x9E, 0x22, 0xF0, 0xCC, 0x41, 0x85, 0xC3, 0x47, 0x85, 0x0F, 0x5E, 0x86, 0x5A, 0xE5, 0x0F, 0xB2, 0xEC, 0x05, 0x40, 0x16,
0xDE, 0xC5, 0x59, 0x6A, 0xAA, 0x4A, 0x09, 0xB1, 0xA5, 0x06, 0x30, 0x51, 0xD2, 0x87, 0x21, 0xD9, 0x95, 0x32, 0x55, 0x62, 0x68, 0x4C, 0xD0, 0x00, 0x36, 0x04, 0x7F, 0x59, 0xAA, 0x86, 0xAC, 0x74,
0x0B, 0xE3, 0x0C, 0x83, 0x14, 0xF8, 0xDB, 0x05, 0x6C, 0x75, 0x07, 0x92, 0x43, 0x15, 0x93, 0xEE, 0x51, 0x6C, 0x10, 0x55, 0x14, 0xEA, 0xB6, 0x37, 0x73, 0x27, 0x5B, 0x02, 0x8A, 0x51, 0xB6, 0x08,
0xA7, 0x42, 0x03, 0x0B, 0x53, 0xC7, 0x71, 0xCB, 0xDE, 0xFC, 0x80, 0x86, 0xBE, 0xB9, 0x49, 0x1B, 0x3F, 0x33, 0x4E, 0x0B, 0xD8, 0xFB, 0xBF, 0xAD, 0xFA, 0x0C, 0x3A, 0xC8, 0x8C, 0x0D, 0xB6, 0x7D,
0xB4, 0xDD, 0xCA, 0x69, 0x51, 0xF3, 0x4E, 0xE2, 0x81, 0x6B, 0x8D, 0x13, 0x9F, 0x45, 0x69, 0x53, 0xED, 0xBC, 0x74, 0x86, 0xD7, 0xB8, 0x9C, 0x35, 0x73, 0x5F, 0x76, 0x17, 0x07, 0x67, 0x37, 0x4C,
0x86, 0xAA, 0xC4, 0x24, 0x79, 0x9D, 0x10, 0x98, 0xC6, 0xCE, 0x56, 0x7C, 0x09, 0xE5, 0x0E, 0x98, 0x36, 0x37, 0x84, 0xA1, 0xB7, 0x4E, 0xDF, 0xC5, 0x51, 0x26, 0xD7, 0x61, 0x98, 0xE1, 0xE3, 0x9A,
0xB0, 0xF2, 0xFD, 0xEB, 0x32, 0xC1, 0x6F, 0x4F, 0xB6, 0xDF, 0x5C, 0xA1, 0x47, 0xC9, 0xBF, 0x23, 0x0D, 0x37, 0x1D, 0x39, 0x28, 0xE5, 0xC6, 0x9C, 0x9A, 0xFE, 0x7F, 0xC0, 0xF5, 0xDE, 0x1A, 0x6A,
0x08, 0xD8, 0x22, 0x9E, 0x0C, 0x03, 0xE5, 0xED, 0x6D, 0x49, 0x24, 0x05, 0x80, 0x13, 0x54, 0xD7, 0xE7, 0x40, 0xF5, 0x5D, 0x0D, 0xA6, 0x16, 0x85, 0xD6, 0x85, 0x7C, 0xD7, 0x05, 0xE7, 0xA0, 0x62,
0x45, 0xAE, 0xDA, 0x3E, 0x68, 0x87, 0x7A, 0xF6, 0x48, 0x5E, 0xE0, 0x14, 0x54, 0x93, 0x98, 0x83, 0x64, 0x7E, 0x84, 0xEB, 0x3F, 0xCD, 0x7F, 0x26, 0x75, 0x86, 0x98, 0xA7, 0xF5, 0x5A, 0x7F, 0x94,
0x47, 0xF5, 0x02, 0xF0, 0xA5, 0x7D, 0xDD, 0xF6, 0xCE, 0x16, 0x6B, 0x36, 0xBF, 0xC6, 0xD8, 0x15, 0x93, 0xC2, 0x3A, 0x93, 0x82, 0x9F, 0xAF, 0x72, 0x12, 0xA2, 0xF8, 0x5D, 0xCC, 0x5E, 0x4D, 0xFB,
0x12, 0x66, 0x2E, 0x9E, 0x3C, 0x7A, 0x04, 0xEC, 0xE2, 0x32, 0xFC, 0x2F, 0xAF, 0xF9, 0x2E, 0x96, 0x63, 0x96, 0xEF, 0xE6, 0x7F, 0x57, 0x19, 0x54, 0x0C, 0x8B, 0x31, 0x63, 0x97, 0xB1, 0x6A, 0x84,
0xEC, 0x3A, 0xA2, 0x7A, 0xC0, 0x78, 0x4F, 0x2A, 0x78, 0x94, 0xDB, 0x76, 0x7D, 0xBE, 0xE6, 0xBF, 0xB9, 0x0E, 0xFC, 0x38, 0x1C, 0x5F, 0x90, 0x71, 0xC8, 0xC4, 0x77, 0xE9, 0x12, 0x8E, 0x29, 0xAC,
0x6F, 0x78, 0xEA, 0x43, 0xF6, 0xC4, 0x98, 0xBB, 0x79, 0xEE, 0x90, 0xD7, 0x80, 0x6A, 0x80, 0x0A, 0x7D, 0xC9, 0xF6, 0xA6, 0x99, 0xD8, 0xB5, 0xEA, 0x5C, 0x24, 0x05, 0xF2, 0x36, 0xCF, 0x59, 0xC9,
0x3E, 0xC6, 0x1F, 0x53, 0x38, 0x3E, 0x46, 0x13, 0x5F, 0x78, 0x5C, 0xC1, 0x92, 0x47, 0xFD, 0xE9, 0x95, 0x90, 0xCC, 0xD6, 0xB0, 0xB9, 0x9B, 0x3E, 0xEE, 0xCE, 0xE3, 0x70, 0x28, 0x55, 0x57, 0xE3,
0x25, 0xA3, 0x06, 0x81, 0x98, 0xAC, 0x16, 0x33, 0xE7, 0x69, 0x2F, 0x2A, 0xD1, 0xB9, 0x1D, 0x15, 0xA8, 0x5E, 0xD2, 0xB2, 0x17, 0xA6, 0xFC, 0xEB, 0x7F, 0xA9, 0x28, 0xC1, 0x6D, 0x47, 0x7F, 0x1F,
0x71, 0x8E, 0x4E, 0xD6, 0x08, 0xA2, 0x22, 0x58, 0x97, 0xB9, 0xD0, 0x12, 0xFA, 0xF6, 0x42, 0x21, 0x75, 0xA1, 0x63, 0xF3, 0x6B, 0x6B, 0x84, 0x7F, 0xAE, 0xA6, 0x50, 0xEC, 0x5B, 0x9E, 0x88, 0xB2,
0x58, 0x3E, 0x0D, 0x2C, 0x10, 0xBD, 0x53, 0xB0, 0xF2, 0x0E, 0x1D, 0xA0, 0x31, 0x66, 0x39, 0x90, 0x0A, 0x9D, 0x27, 0xB1, 0xFC, 0x4F, 0xA6, 0xB6, 0x17, 0x75, 0x9B, 0xDD, 0x18, 0xBC, 0x4A, 0x08,
0xF0, 0x84, 0xCE, 0x06, 0x6F, 0x9C, 0xFC, 0x16, 0xE1, 0xD0, 0xC9, 0x55, 0xB8, 0xF5, 0xA5, 0x9F, 0xB5, 0x2F, 0x76, 0xBF, 0xA6, 0x9A, 0x49, 0x51, 0x55, 0x9D, 0x91, 0x2A, 0x9C, 0x61, 0x93, 0x7A,
0xEF, 0x8D, 0x4C, 0x28, 0xF9, 0xCE, 0x9D, 0xD9, 0x49, 0x55, 0x88, 0x56, 0x43, 0x4D, 0xC4, 0x85, 0x6C, 0x2F, 0x16, 0xA1, 0xB4, 0xDC, 0x7E, 0xF2, 0xF5, 0x76, 0x60, 0xED, 0xD5, 0x24, 0x69, 0xFD,
0xE1, 0x4A, 0x81, 0x5F, 0x3C, 0x18, 0x03, 0xE7, 0x2E, 0x2C, 0x6F, 0x89, 0xB7, 0x41, 0x2B, 0x46, 0xEE, 0xEF, 0xE6, 0x2B, 0xFD, 0x1A, 0x9D, 0x37, 0xB9, 0x9D, 0x9E, 0x20, 0xFD, 0x31, 0x5C, 0xA2,
0x9F, 0x63, 0x69, 0xA9, 0xCA, 0x58, 0x97, 0xF3, 0x43, 0x29, 0x88, 0x4C, 0x18, 0xE0, 0xDF, 0x76, 0x40, 0x91, 0x6F, 0x10, 0x42, 0x29, 0xE7, 0xA5, 0xF1, 0xDE, 0x14, 0x5C, 0x80, 0x25, 0x2C, 0x65,
0x62, 0xCB, 0x80, 0x92, 0x2F, 0x5C, 0x7F, 0xF7, 0xEF, 0x79, 0xBF, 0x31, 0xD9, 0x8B, 0x79, 0x13, 0x43, 0x54, 0xCF, 0x2B, 0x12, 0x32, 0x99, 0xF8, 0x88, 0x8F, 0xCC, 0xA6, 0x12, 0xFA, 0xB2, 0xF7,
0x50, 0xB3, 0x86, 0x1A, 0x1E, 0x1F, 0x76, 0x89, 0x31, 0x3C, 0xED, 0xD1, 0x3E, 0xC5, 0xCA, 0x5A, 0xA0, 0x5B, 0x91, 0x58, 0x49, 0xD4, 0x46, 0x2F, 0xFF, 0x60, 0xA8, 0x62, 0xF9, 0xCF, 0x5E, 0x46,
0x24, 0x86, 0x03, 0x72, 0x9A, 0xD8, 0x72, 0x6F, 0x8B, 0x04, 0x6D, 0xC4, 0xCC, 0x24, 0x9A, 0x3E, 0x6F, 0x8E, 0x10, 0xB0, 0xC3, 0x13, 0xC0, 0xFA, 0xD4, 0x07, 0x07, 0xBF, 0xBD, 0xD1, 0x87, 0xFA,
0x6B, 0xD3, 0x27, 0xB5, 0xBE, 0xAB, 0xC4, 0xCA, 0x83, 0x4C, 0x93, 0x11, 0x1D, 0xEB, 0x2E, 0x0C, 0xB1, 0x27, 0xE9, 0x24, 0x5B, 0x48, 0x92, 0x83, 0xD6, 0x7C, 0x7F, 0x33, 0x44, 0xAC, 0x14, 0x0C,
0x8B, 0x82, 0xF4, 0xF7, 0x3B, 0xA8, 0x31, 0xE8, 0x72, 0x6B, 0x89, 0x7B, 0x36, 0xE5, 0xB2, 0x4B, 0x46, 0xAF, 0x8B, 0x6B, 0x7F, 0xE0, 0x13, 0x96, 0x7D, 0xED, 0x7F, 0x71, 0x67, 0xAD, 0x52, 0x2C,
0x6B, 0xD4, 0x8B, 0x2C, 0xD6, 0xA2, 0x51, 0x6E, 0x4C, 0x34, 0x68, 0x73, 0x0D, 0x0E, 0xE1, 0xB9, 0x71, 0x96, 0xA5, 0x63, 0x45, 0x9B, 0x82, 0x0D, 0xC5, 0xE1, 0x7E, 0x84, 0x25, 0xC2, 0x22, 0x94,
0xED, 0x4E, 0x94, 0x97, 0x4F, 0xFB, 0x40, 0x0D, 0x48, 0x4F, 0x42, 0xF3, 0x11, 0xF6, 0x1B, 0x38, 0x1E, 0x9D, 0x8D, 0xA8, 0xDD, 0xA7, 0x1F, 0x65, 0xCD, 0xC1, 0x11, 0x84, 0x4E, 0x4F, 0x0A, 0x45,
0x53, 0x73, 0xBB, 0x96, 0x21, 0x17, 0x56, 0xC4, 0x6C, 0x37, 0xF2, 0x30, 0x56, 0x36, 0x45, 0x9E, 0x2C, 0xCB, 0xF7, 0x54, 0xA4, 0x53, 0x9F, 0xBF, 0x9D, 0x9B, 0xE9, 0x55, 0xB4, 0x1A, 0xA4, 0xC8,
0x0D, 0x84, 0xD6, 0x48, 0x25, 0xB7, 0x3E, 0xD4, 0xD3, 0x60, 0x80, 0x51, 0xDA, 0xBA, 0x12, 0xAE, 0x7B, 0x01, 0x78, 0x4E, 0x9C, 0xFD, 0xDC, 0xED, 0x24, 0x22, 0xDC, 0xD0, 0x9B, 0x9B, 0x12, 0x62,
0xA5, 0x4A, 0xB3, 0xAD, 0x74, 0xEA, 0x6D, 0xF6, 0x2D, 0x45, 0xAE, 0x10, 0xCA, 0x32, 0x81, 0x7F, 0x1F, 0xE4, 0xC1, 0x31, 0xC3, 0x2E, 0x4C, 0xD6, 0x14, 0x16, 0x67, 0x68, 0x6A, 0x92, 0xC8, 0xFC,
0x02, 0x53, 0xB7, 0x9E, 0xB0, 0xF6, 0xB0, 0x55, 0x08, 0xEC, 0xCC, 0xE1, 0x51, 0x72, 0x7E, 0xAD, 0x9A, 0x7D, 0xB7, 0xA9, 0x37, 0xAE, 0x5C, 0x22, 0xEF, 0xB2, 0xA8, 0x49, 0xFC, 0xE7, 0x48, 0x24,
0x77, 0xA2, 0xA8, 0xC9, 0xF2, 0x02, 0x06, 0x10, 0x3B, 0xA8, 0xEA, 0xE5, 0x32, 0x43, 0xE0, 0x1F, 0x84, 0x42, 0xEC, 0x84, 0x7A, 0x10, 0x76, 0xEB, 0x53, 0xA8, 0x05, 0x91, 0x88, 0x40, 0x20, 0xBF,
0x64, 0xBE, 0x02, 0xFD, 0xF1, 0x58, 0xDA, 0x8A, 0x97, 0x0E, 0x7F, 0xF7, 0xA0, 0xF0, 0x69, 0x51, 0x15, 0x56, 0xE7, 0x30, 0x5C, 0xD9, 0x4E, 0x04, 0x15, 0xF8, 0x5D, 0x27, 0xD8, 0x3A, 0x3F, 0x34,
0x8F, 0x29, 0xF3, 0x61, 0x38, 0x54, 0xF6, 0xEF, 0xC0, 0x68, 0x27, 0xDF, 0x22, 0x90, 0xBF, 0x49, 0x57, 0x2F, 0x8B, 0x1C, 0xEC, 0x74, 0xCF, 0x06, 0x30, 0x92, 0x68, 0xF2, 0x7F, 0x87, 0xE9, 0xC9,
0x75, 0x62, 0xA9, 0x69, 0x31, 0xC7, 0xA7, 0x83, 0x6B, 0x63, 0xB4, 0x24, 0xBB, 0xF8, 0x02, 0x67, 0x53, 0x1F, 0x4F, 0xDE, 0xD5, 0x3B, 0xE8, 0x45, 0x44, 0x85, 0x45, 0xE3, 0x5C, 0x58, 0x04, 0x62,
0x1E, 0xC9, 0x57, 0x76, 0xF4, 0x67, 0x51, 0x7E, 0x6A, 0x72, 0x88, 0x29, 0x3A, 0xB4, 0xF0, 0xEB, 0xE8, 0xFE, 0x76, 0xD4, 0x19, 0x7B, 0x7B, 0x57, 0xCC, 0xE4, 0x33, 0x78, 0x75, 0xF7, 0xAF, 0x76,
0x6B, 0xF8, 0x55, 0xE6, 0x28, 0xCD, 0x4A, 0x40, 0xBC, 0x25, 0xF6, 0x57, 0x18, 0x3D, 0xBE, 0xD0, 0x6F, 0xD5, 0x61, 0x11, 0xB5, 0x26, 0x90, 0x16, 0x8D, 0x42, 0x61, 0x1B, 0x83, 0x8F, 0x54, 0x40,
0xC9, 0xF5, 0x88, 0x7A, 0x55, 0xE6, 0xFF, 0x45, 0xFE, 0xFD, 0x48, 0x4B, 0x8E, 0xAC, 0x8E, 0x97, 0xA7, 0x33, 0x0C, 0x05, 0xF6, 0x54, 0x3C, 0xC4, 0x9F, 0x2D, 0x5D, 0xF9, 0x93, 0x3B, 0x9B, 0xBA,
0x69, 0xA3, 0x67, 0x6D, 0x72, 0x3D, 0xB9, 0xFC, 0x70, 0xC4, 0x1D, 0x8B, 0x6D, 0x08, 0x36, 0xF7, 0x18, 0x41, 0xAB, 0x9C, 0xEE, 0x58, 0xDA, 0xA6, 0xDC, 0x2C, 0x02, 0x50, 0xAF, 0xBC, 0x85, 0xD5,
0x3C, 0xF0, 0x49, 0x7E, 0x31, 0xEF, 0xF5, 0xE2, 0xE7, 0xB9, 0xC6, 0xB0, 0x7A, 0x07, 0x33, 0x64, 0x3E, 0x1A, 0x07, 0x9D, 0xF0, 0x64, 0xD8, 0x03, 0x3C, 0x7C, 0xB7, 0x7C, 0x2E, 0x67, 0x0F, 0x38,
0x47, 0x9A, 0x35, 0xBA, 0x0D, 0xDB, 0xBE, 0x74, 0x75, 0x25, 0x8A, 0xDA, 0x2B, 0x3F, 0x79, 0xED, 0xAD, 0x65, 0x33, 0x6D, 0x57, 0xC3, 0xB0, 0xAC, 0x11, 0x3A, 0x6D, 0x7B, 0x7C, 0x2D, 0xDF, 0xCC,
0x2F, 0x4B, 0x35, 0xD9, 0xD6, 0xEC, 0xFC, 0x98, 0xA9, 0x32, 0x05, 0xC8, 0x5F, 0xF4, 0xA8, 0xD7, 0x20, 0xF9, 0x87, 0x11, 0xD5, 0x05, 0xA8, 0x8C, 0x71, 0x14, 0x51, 0x2F, 0x3F, 0xEB, 0x8B, 0x60,
0xCE, 0x26, 0xD3, 0x38, 0x05, 0x0D, 0x1E, 0xF1, 0xC5, 0x7C, 0x99, 0x0F, 0x08, 0x19, 0x8A, 0xF1, 0x4B, 0xF2, 0xCC, 0x28, 0xF3, 0x54, 0xEB, 0xA7, 0xE7, 0x50, 0x4A, 0x65, 0xC3, 0x1E, 0x95, 0xC1,
0xA6, 0x4C, 0xEC, 0x3C, 0xD0, 0xCE, 0x6C, 0xA6, 0xC3, 0x58, 0xA0, 0xEC, 0x45, 0xA1, 0x34, 0x9A, 0xFD, 0x56, 0x49, 0x5B, 0x4D, 0xED, 0xAD, 0x91, 0xA7, 0xB0, 0xB6, 0x9A, 0xAC, 0xFF, 0xC5, 0xED,
0x77, 0xBA, 0x9A, 0xC5, 0xBF, 0xDB, 0xA3, 0x5F, 0xE5, 0x21, 0x08, 0x76, 0xC5, 0xF9, 0x90, 0x4C, 0x3E, 0x27, 0x0B, 0x16, 0xCF, 0x1E, 0x04, 0xDB, 0x08, 0xAC, 0x2A, 0x56, 0x31, 0x34, 0xE5, 0x49,
0x30, 0x58, 0xAA, 0xDC, 0x71, 0x9F, 0x98, 0xFA, 0x00, 0xD0, 0x27, 0xCC, 0xDC, 0xB0, 0x80, 0x63, 0xC7, 0xF0, 0x85, 0xB8, 0xA6, 0xDE, 0xBC, 0x71, 0x1D, 0x8F, 0x14, 0xBB, 0x4B, 0x95, 0x53, 0x24,
0x71, 0xDB, 0x60, 0xD9, 0xD3, 0x3C, 0xE6, 0x8F, 0xBF, 0xA4, 0xB0, 0xD7, 0x88, 0x50, 0xEA, 0x63, 0x9E, 0x15, 0xCE, 0x2A, 0x8A, 0x94, 0x5E, 0xDD, 0xE8, 0x5D, 0xC1, 0x3A, 0x3B, 0xDC, 0x10, 0x85,
0xBA, 0x6A, 0xDC, 0x48, 0xC5, 0xC1, 0x0C, 0x29, 0xBB, 0xC6, 0x03, 0xD6, 0x0A, 0xDA, 0xC8, 0x71, 0xAD, 0x0C, 0x50, 0xC0, 0xED, 0x93, 0x08, 0x58, 0x17, 0xA8, 0x0E, 0xDC, 0x25, 0x5C, 0xD9, 0x97,
0x41, 0x17, 0x6E, 0x2C, 0xA9, 0x87, 0xD5, 0x47, 0x72, 0xB3, 0xA1, 0xB2, 0x06, 0xB1, 0x52, 0xB9, 0xC7, 0xA9, 0xDB, 0x37, 0x5E, 0x43, 0x30, 0xB0, 0x96, 0x0C, 0xAB, 0x87, 0xC4, 0x60, 0xEF, 0x5C,
0x6C, 0x05, 0xCF, 0x82, 0x0B, 0xAA, 0x9B, 0x9B, 0x65, 0xBB, 0x0E, 0x8B, 0x2F, 0x00, 0x58, 0x94, 0xD2, 0x43, 0x24, 0xF3, 0x7E, 0x52, 0xE5, 0x61, 0xA2, 0x1C, 0xB8, 0x9D, 0x23, 0x61, 0x48, 0xEF,
0xD0, 0xEC, 0xC1, 0x45, 0x62, 0x3E, 0x51, 0x0A, 0x85, 0x43, 0x95, 0xDD, 0x31, 0x56, 0x96, 0xA4, 0x78, 0xB4, 0x86, 0xE6, 0x98, 0x26, 0x5E, 0x9E, 0xBF, 0xB1, 0xD4, 0x30, 0xDC, 0x19, 0x1D, 0xE5,
0x00, 0x3E, 0xDB, 0x9D, 0xCC, 0xE2, 0x7B, 0x29, 0x15, 0xBB, 0xC2, 0xFF, 0x81, 0x68, 0xEC, 0xCC, 0x00, 0x44, 0x55, 0x3B, 0x57, 0x33, 0xAE, 0x2E, 0xA9, 0xF4, 0x50, 0x31, 0x76, 0x63, 0x5A, 0x21,
0xFE, 0xDC, 0x35, 0xCB, 0x8B, 0xB8, 0x9C, 0xBE, 0x1E, 0xBC, 0x3D, 0x4E, 0x28, 0xA8, 0x84, 0x8E, 0x1F, 0x14, 0x29, 0x01, 0xDB, 0xA7, 0x06, 0x8F, 0xB9, 0xE6, 0x37, 0x2C, 0x98, 0xE4, 0xF9, 0x7D,
0xC1, 0x43, 0x2F, 0xF5, 0x07, 0x43, 0xFC, 0x5E, 0xD3, 0xDB, 0x2C, 0xBD, 0xF3, 0x9A, 0xC8, 0x54, 0xA6, 0x6D, 0x89, 0x19, 0x3E, 0xC2, 0x6D, 0xB9, 0x6E, 0xF5, 0x35, 0xC4, 0xF3, 0x2A, 0x81, 0xAD,
0xEA, 0x8D, 0x9D, 0xED, 0x76, 0xC8, 0x02, 0x0C, 0x90, 0xDC, 0x80, 0xFB, 0xF5, 0xEC, 0x24, 0x02, 0x67, 0x2B, 0xCF, 0x69, 0x90, 0x60, 0xA1, 0xE3, 0xD1, 0x89, 0x0C, 0x99, 0x31, 0xCD, 0x52, 0xAD,
0x04, 0xD4, 0xE4, 0x88, 0xB4, 0x4B, 0x01, 0xE2, 0x51, 0x39, 0xCB, 0xE6, 0xA0, 0x06, 0xBA, 0x65, 0xAF, 0xC9, 0x93, 0xD5, 0xC3, 0xC3, 0xEF, 0x95, 0xD5, 0x0A, 0x17, 0x0F, 0x45, 0x4A, 0xBE, 0x59,
0x3D, 0x8A, 0x45, 0x11, 0xAB, 0xDC, 0x18, 0xBB, 0xF8, 0x3F, 0x8F, 0x5C, 0x8A, 0x93, 0x3D, 0xAE, 0xAF, 0x43, 0x84, 0x9F, 0xD1, 0x17, 0xC3, 0xE1, 0xBE, 0x4F, 0x9A, 0x69, 0x5F, 0x60, 0x15, 0xC3,
0x34, 0x87, 0x6D, 0x5E, 0xF2, 0xAC, 0xDA, 0x6B, 0x45, 0x6E, 0x8B, 0x21, 0xCF, 0x70, 0x91, 0x7A, 0x32, 0xA8, 0xD9, 0x8C, 0xFC, 0xE1, 0xF7, 0x7A, 0xBE, 0x91, 0xC5, 0xEF, 0x0E, 0x9F, 0x9E, 0x02,
0x51, 0xA4, 0xF8, 0xF2, 0x2A, 0xAB, 0x0C, 0x08, 0x18, 0x8E, 0xC3, 0x34, 0xA0, 0x78, 0x62, 0x4C, 0xE3, 0x62, 0xF3, 0xA8, 0xF3, 0x1B, 0x4F, 0xD7, 0x5C, 0x5E, 0x8E, 0x5F, 0x52, 0xD5, 0x75, 0x30,
0x17, 0x85, 0xBD, 0x79, 0xD1, 0x19, 0x23, 0xFB, 0x2D, 0xBE, 0x77, 0x68, 0x1E, 0x41, 0xB1, 0x6A, 0x84, 0xBD, 0x00, 0x1E, 0xF5, 0xD6, 0x0C, 0xD8, 0x08, 0xBA, 0x21, 0x37, 0x24, 0x43, 0x2F, 0xCA,
0x6F, 0x3E, 0x6C, 0xEC, 0x3F, 0x19, 0x1B, 0x94, 0xFF, 0x81, 0x65, 0x36, 0xC5, 0x6B, 0xD8, 0xD7, 0xAB, 0x5B, 0x7D, 0xC6, 0x60, 0x58, 0x2B, 0xF1, 0x6A, 0x97, 0x22, 0x6E, 0xE5, 0x09, 0x1E, 0x66,
0x63, 0x7F, 0x1E, 0x59, 0x70, 0xAF, 0xD8, 0x8E, 0x5D, 0x39, 0x2F, 0xB8, 0x01, 0xEA, 0x65, 0x2D, 0xD9, 0x21, 0x9F, 0x5F, 0xD7, 0x01, 0x76, 0x8D, 0x55, 0x52, 0x93, 0x90, 0x90, 0xFE, 0xC7, 0xB5,
0x87, 0x76, 0xC9, 0xB7, 0x10, 0xCE, 0x9E, 0xDA, 0x63, 0x32, 0x4B, 0xD9, 0xD0, 0xC3, 0xCB, 0x42, 0xAC, 0xD0, 0x06, 0x7F, 0x11, 0x1F, 0xD4, 0xCE, 0xB2, 0x5A, 0xA5, 0x4C, 0xE0, 0xF6, 0x73, 0x3C,
0xC7, 0x48, 0xF2, 0xCF, 0x45, 0x85, 0x41, 0xC3, 0xF0, 0xAC, 0xAB, 0x50, 0x36, 0x02, 0x59, 0x7D, 0x98, 0x23, 0x85, 0xFF, 0x67, 0x84, 0xA7, 0x4D, 0xB3, 0xCE, 0xC4, 0xEA, 0xA4, 0x11, 0x17, 0x47,
0x06, 0x76, 0x00, 0x54, 0x76, 0xC2, 0xD8, 0x11, 0x23, 0xF2, 0x75, 0x28, 0xA0, 0xCF, 0x9F, 0x8E, 0x33, 0xAD, 0xD5, 0xFE, 0x02, 0x76, 0x48, 0x6A, 0x58, 0x1C, 0xDC, 0xE9, 0x8B, 0xD7, 0x9A, 0x60,
0x5D, 0x46, 0xCE, 0x6A, 0x8D, 0x90, 0x7E, 0xB6, 0x48, 0xAD, 0x1D, 0x82, 0x88, 0xEB, 0x1D, 0x12, 0xBE, 0x66, 0x1F, 0xDB, 0x1C, 0x46, 0x25, 0xE2, 0x29, 0xC5, 0x11, 0xED, 0x71, 0x86, 0x04, 0x2D,
0xC3, 0xB8, 0xB4, 0x22, 0xBD, 0xD4, 0x50, 0xD3, 0x92, 0x73, 0xB9, 0x46, 0x93, 0xA4, 0x18, 0x9F, 0x39, 0xB7, 0x48, 0x72, 0x67, 0xC3, 0xC0, 0x8D, 0x70, 0xFC, 0xF8, 0x0E, 0xFF, 0xFC, 0x1A, 0x91,
0x08, 0x0A, 0xD6, 0x21, 0x67, 0xD2, 0xB1, 0xC0, 0xE1, 0x3D, 0x58, 0x74, 0x00, 0x41, 0x83, 0x6F, 0xA4, 0xB3, 0xCA, 0x4F, 0x87, 0x76, 0xB2, 0x6C, 0x4E, 0x7B, 0xA8, 0x30, 0x4B, 0xCE, 0x76, 0xBD,
0xD4, 0x63, 0xD1, 0xB0, 0x05, 0x0E, 0x52, 0x30, 0x26, 0x25, 0x7E, 0x23, 0xCA, 0xF9, 0x3E, 0x9D, 0xDC, 0x70, 0xC8, 0xDA, 0xEE, 0x60, 0x19, 0x06, 0x71, 0x20, 0x8D, 0x43, 0x54, 0xF4, 0x49, 0x50,
0x6F, 0x4C, 0x83, 0x0E, 0x13, 0xEE, 0x8C, 0x43, 0x46, 0x0C, 0x35, 0xDE, 0x98, 0xC9, 0x65, 0x3D, 0x4F, 0x63, 0x70, 0xD3, 0x8C, 0x54, 0xA7, 0xCB, 0xDC, 0x9A, 0xBC, 0x9E, 0xEA, 0xB0, 0xDD, 0xFF,
0xC3, 0x61, 0xD7, 0x99, 0x3C, 0xFC, 0xEA, 0x6E, 0x98, 0xC8, 0xEF, 0x4D, 0x29, 0x9B, 0x12, 0x84, 0xCC, 0x86, 0xAB, 0x3F, 0x2E, 0x2D, 0x13, 0x6B, 0x46, 0xB8, 0xF2, 0x12, 0xDF, 0xE6, 0x50, 0x7F,
0x64, 0x1C, 0xA9, 0x57, 0xB7, 0x69, 0x9B, 0x74, 0x8A, 0x52, 0xF7, 0x2E, 0x09, 0x09, 0xF7, 0x3D, 0xE1, 0x66, 0x8A, 0x01, 0xB9, 0xBD, 0xD9, 0xD2, 0xD2, 0x86, 0xF4, 0x9D, 0xA8, 0x22, 0x2F, 0x65,
0xA5, 0x9C, 0x99, 0x3E, 0x1F, 0xB0, 0xE4, 0x44, 0xCB, 0xAA, 0x38, 0xE9, 0x45, 0xFF, 0x50, 0x82, 0x71, 0xC4, 0x63, 0x85, 0xD9, 0x4F, 0xB5, 0x64, 0xF5, 0xAA, 0x84, 0x27, 0x9E, 0x25, 0x86, 0x99,
0x35, 0x92, 0x14, 0x7E, 0xF5, 0xAF, 0xA6, 0x45, 0x8B, 0x8B, 0x31, 0x85, 0xFB, 0xE4, 0x89, 0xFD, 0x70, 0xA2, 0xE8, 0xF9, 0xAD, 0x9F, 0x79, 0xFC, 0x27, 0xEE, 0xBC, 0xDA, 0x32, 0xC5, 0x76, 0x78,
0x16, 0xAC, 0xFF, 0xA0, 0xD2, 0x98, 0xBE, 0x91, 0x7C, 0x8C, 0x42, 0xBA, 0xD8, 0x12, 0xE2, 0x28, 0x84, 0x3F, 0xF3, 0xF8, 0x64, 0xED, 0x3D, 0x79, 0x79, 0xD3, 0xBF, 0x4E, 0x51, 0x95, 0x88, 0xC3,
0x8D, 0xFD, 0xC6, 0xC5, 0x6E, 0x4C, 0xAE, 0x1B, 0x87, 0x51, 0x0D, 0xB7, 0x4F, 0xC0, 0x29, 0x13, 0x07, 0x74, 0xEE, 0xD7, 0x2A, 0x03, 0xB1, 0xDB, 0x6F, 0x2C, 0xEC, 0x34, 0x37, 0xD6, 0x4A, 0x1B,
0xA4, 0xDE, 0x09, 0x73, 0x1F, 0x6D, 0x7D, 0xE8, 0x5E, 0x8D, 0xF9, 0x34, 0xD3, 0xE2, 0xA0, 0xF9, 0x14, 0xB6, 0xFC, 0x8A, 0x56, 0x7F, 0xFE, 0xF0, 0xFA, 0x5D, 0x1B, 0xC7, 0x71, 0x32, 0x27, 0x56,
0x8C, 0xD3, 0x61, 0xA9, 0x69, 0x3A, 0x70, 0xA7, 0xF6, 0xA8, 0x7D, 0xAF, 0x83, 0x29, 0x20, 0x9A, 0xB2, 0x88, 0x37, 0x46, 0x01, 0x4D, 0x25, 0x52, 0x39, 0xD1, 0xF0, 0xCA, 0xB8, 0xDE, 0x8B, 0x7C,
0x29, 0x78, 0xE5, 0x2A, 0xA3, 0x4E, 0x44, 0x1B, 0xDB, 0x7F, 0x3B, 0xB8, 0xF1, 0x4B, 0x6E, 0x51, 0x5A, 0xA2, 0xFF, 0x2A, 0x48, 0xF2, 0xA2, 0xF7, 0x26, 0xF9, 0x43, 0x4A, 0x41, 0x0C, 0x09, 0xBC,
0xF4, 0x7F, 0x97, 0x75, 0xA0, 0x18, 0x5D, 0xA9, 0x04, 0x40, 0xD5, 0x0B, 0xB7, 0x11, 0xF8, 0x60, 0xD9, 0x7C, 0x90, 0x04, 0x2E, 0x16, 0x15, 0x0D, 0xD9, 0xEE, 0x49, 0xAF, 0xC2, 0x3A, 0x3B, 0x02,
0xBC, 0xDA, 0xEA, 0x78, 0xDC, 0x25, 0x9F, 0xC5, 0x98, 0x64, 0x7C, 0xC5, 0xDC, 0x11, 0x73, 0x91, 0x5D, 0xE9, 0xA9, 0x60, 0x04, 0x93, 0x5F, 0x09, 0xD9, 0x96, 0x0E, 0x56, 0x95, 0x63, 0x34, 0xB5,
0xCC, 0xB2, 0x5A, 0xAA, 0xC1, 0xA0, 0xE7, 0x70, 0x93, 0xB1, 0xA7, 0xCD, 0x4D, 0x46, 0x3E, 0xEE, 0x85, 0xCE, 0x77, 0xE6, 0x7A, 0x3B, 0x1D, 0xF3, 0x11, 0x17, 0x82, 0x94, 0x6C, 0x8E, 0x63, 0x7E,
};
PROGMEM is a C macro which allows you to store constant data in the 32K code space of the 328P. Any large const array should be stored this way. This includes sound waves, wavetables, pitch to frequency lookup tables, you name it.
Mozzi instead uses a macro called CONSTTABLE_STORAGE. This allows Mozzi to switch to the proper const storage mechanism depending on the platform. For the 328P it just gets expanded to PROGMEM.
PROGMEM access is slightly slower than accessing RAM, but it's not bad at all. You should use it liberally.
To get the PROGMEM facility, you can do
#include <avr/pgmspace.h>
If you're doing Mozzi, it already includes this file, so you don't need to.
You create a PROGMEM table of uint8_t like this:
const PROGMEM uint8_t myTable[5] = { 1, 2, 3, 4, 5 };
You can make tables of any numerical type (uint16_t, int8_t, int32_t, float, whatever).
To access an element, you can't access it directly -- it's in a completely different memory space. You have to use a special function, such as pgm_read_byte_near(...). This function takes a pointer to an element in the table (like where you'd expect the data), and looks it up in code space. To do all this, I would make a little macro.
#define getMyTable(index) ((uint8_t) pgm_read_byte_near(&myTable[index]))
Notice I'm casting the byte into the signed/unsigned type I want (uint8_t in this case). Now you can access elements in your table like this:
uint8_t element2 = getMyTable(2); // should return a 3
To get a 16-bit integer you need to use pgm_read_word_near(...), and then cast into the signed/unsigned form you want (here, int16_t).
#define getMySecondTable(index) ((int16_t) pgm_read_word_near(&mySecondTable[index]))
To get a 32-bit integer you need to use pgm_read_dword_near(...), and then cast into the signed/unsigned form you want (here, int32_t).
#define getMyThirdTable(index) ((int32_t) pgm_read_dword_near(&myThirdTable[index]))
To get a float you need to use pgm_read_float_near(...)
#define getMyFourthTable(index) pgm_read_float_near(&myFourthTable[index])
Notice the term "near". There are also "far" versions of these functions. They are for much larger arrays, in 32-bit addressed spaces. You don't have that much memory on the GRAINS, it's only 32K, which fits into 16-bit addressing. So don't worry about them unless GRAINS is upgraded to a bigger chip.
It is possible to do other stuff, like tables of const stucts, or tables of const pointers, but it gets a little more complex. Notably you can hack things up to do multdimensional tables. I've done that occasionally.
GRAINS has seven inputs and outputs. They're commonly defined as follows:
#define CV_POT_IN1 A2
#define CV_POT_IN2 A1
#define CV_POT3 A0
#define CV_IN3 A3
#define CV_AUDIO_IN A4
#define CV_AUDIO_OUT 9 // On Mozzi. On Ginkosynthese GRAINS, it's 11
#define CV_GATE_OUT 8
To this collection I typically add the following, which I use to seed random number generators (see the math section earlier).
#define RANDOM_PIN A5
The GRAINS is essentially an Arduino Nano, so it has eight analog pins A0...A7. The pins A5, A6, and A7 are not connected, so any of them can be used to collect random number seed entropy.
There is a bug in all of the analog inputs: they seem to have a reference voltage of about 4V. This means that everything is scaled so that 4V or above (roughly) will be read as 1023 -- it's not volt per octave. For IN1 and IN2, you can scale this back down such that only 5V will read as 1023, by setting their potentiometers to about the 2 o'clock or maybe 3 o'clock position. Nothing can be done for IN3 and AUDIO IN. If set to MAN, the maximum potentiometer position is exactly 1023. I consider all this a significant bug but I don't know what is causing it: AREF is properly being pinned to ground with a capacitor, so it should be 5V internally.
-
IN 1. This is attenuated by POT1 or alternatively replaced by POT1. Note that when attenuated, if you set POT1 to about the 2 o'clock position, IN1 will be maximal. Higher than that and you're just multiplying IN1 by larger values, but they're clipped at 1023 in the Arduino. I consider this a bug.
-
IN 2. This is just like IN1 (with its own POT2), and with the same bug.
-
IN 3. This is a pure CV input. It's filtered a bit. It maxes out (1023) at about 4V.
-
Pot 3. This is the input from potentiometer 3. Pot 3 and IN 3 have nothing to do with each other.
-
Audio In. This input can be used for CV input, and when using a library such as Mozzi, you can modify the library to allow this to be used for audio input (badly). It maxes out (1023) at about 4V. The problem with Audio In is that its impedance is very different from the other inputs, and so it takes longer for the analog pin to read voltage. It takes so long in fact that analogRead(...) often won't work right. If you do an analogRead(...) on IN3 and then do an analogRead(...) on AudioIn, often AudioIn will be just set to what IN3 was set to! You have to throw that away and do a second analogRead(...) on AudioIn to get what you need. Note that you don't have this option in Mozzi. Mozzi does all the analog reading before you even get to their special analog read functions, which just report what it read. So you'll have to hope for the best there.
-
Audio Out. This is a digital output which goes through a low-pass filter. This means it's slow if you use it as a digital out. I have also found that you must explicitly set it to 0 first (perhaps in setup) if you intend to write output with digitalWrite(). It's slow because of the filter. It's set up like this so that libraries like Mozzi can use it to do filtered PWM. If you're using Mozzi (etc.), you'd not output on Audio Out, you let Mozzi handle it. If you're writing your own code, you can use Audio Out as a slow digital out.
-
Gate ("Digital") Out. This is the one digital pin that has nothing special messing with it. It's fast. I use it as MIDI In for my MIDI-based oscillators (it's the only one that works right).
Though these pins are by default meant for certain input and output functions, they in fact can be changed to be used for different purposes:
-
IN 1. Can be used for analog or digital input, keeping in mind that POT2 is attenuating the voltage.
-
IN 2. Can be used for analog or digital input, keeping in mind that POT2 is attenuating the voltage.
-
IN 3. Can be used for analog or digital input, or for digital output (but a bit slow due to the filter).
-
POT 3. Can be used for analog input only.
-
Audio In. Can be used for analog or digital input, or for digital output (but a bit slow due to the filter).
-
Audio Out. Can be used for analog (via filtered PWM) or digital output (via filtered PWM). Can also be used as digital output via digitalWrite(). Digital output will be slow due to the filter and PWM. If you use analogWrite(), the PWM is slow and bounces around; I would not do that.
-
Gate ("Digital") Out. Can be used for digital input or output.
This will be strange to users, seeing OUTPUTS on the left side and INPUTS on the right, but it is often necessary.
You can a pin to be output or input with pinMode(...). Do this in setup(...).
You can use digitalRead(...) on analog pins to read them as if they were digital pins. This just does an analogRead(...) and tests to see if it's over 512. This isn't very good because there's noise in analogRead(...), so if you're near 512, it may drop down again for a bit, then rise again, resulting in multiple on/off readings. You don't want that.
Instead you might consider doing something like this to avoid noise. The code pattern below, which I use a lot, triggers actions based on whether we're going high or low (not being high or low):
#define HIGH 612
#define LOW 412
uint8_t state = 0;
/// This part is inside a function
uint16_t val = analogRead(pin);
if (state == 0 && val >= 612)
{
// I just went high
// do stuff here in response
state = 1;
}
else if (state == 1 && val < 412)
{
// I just went low
// do stuff here in response
state = 0;
}
But you could then tack on the following code to check if you are currently high or low (I don't do that so often):
if (state == 0)
{
// I think I am low
// do stuff here if you need to
}
else if (state == 1)
{
// I think I am high
// do stuff here if you need to
}
Audio Out is a digital pin which the Mozzi and Ginkosynthese GRAINS libraries set to have its PWM turned on. The result is then pushed through a filter to approximate a DAC.
Notionally, filtered PWM has an amplitude range of -244 ... +243, corresponding to voltages from 0 to 5V. Because this is between 8 and 9 bits, Mozzi calls this "8.5 Bit". Ideally you'd like to scale your audio from (typically) -128 ... +127 to -244 ... +243 in order to make GRAINS as loud as possible to reduce noise. However I have found that the upper portion of this range is significantly distorted above +175. So realistically you can only do -244 ... +175 for CV. Since you want to keep your audio properly centered at 2.5V, you can only do -175 ... +175. You need to do this as fast as possible. I wrote a few functions you can use in Mozzi's updateAudio(...) function to scale very rapidly to between -168 and +167, which is pretty close:
/** Maps -128 ... +127 to -168 ... +167 */
inline int16_t scaleAudioSmall(int16_t val)
{
return (val * 21) >> 4;
}
/** Maps -32768 ... +32767 to -168 ... +167 */
inline int16_t scaleAudio(int16_t val)
{
return ((val >> 5) * 21) >> 7;
}
This might still be too slow for Mozzi if you're doing lots of other stuff to generate the audio. You have two other options:
-
Just output in the range -128 ... +127. This is quieter though.
-
Provide a gain knob. Let's say that POT 3 was your gain knob, and you read it earlier in updateControl(...) and scaled it down to 0...15. Let's assume you want 0 to be 0.0 gain, 8 to be the 1.0 gain, and 15 to be just under 2.0 gain. You might do:
// Scales -128...+127 to whatever, given pot3 gain. // pot3 variable goes 0...15 inline int16_t scaleWithPot(int16_t val) { return (val * pot3) >> 3; }
Obviously if the musician turns the knob up too much, this will produce values outside the -244 ... +243 range and clip. But that's to be expected.
Filtered PWM on GRAINS is designed for audio rates, not CV, but you can get away with it. First off, note that CV is similarly distorted above about +175 just like audio as discussed above. To maximize the CV range, your best option is to scale your CV to between -244 and +175. Here are two functions which will map into that range and are pretty fast.
/** Maps -128 ... +127 to -244 ... +170 */
inline int16_t scaleAudioSmallBiased(int16_t val)
{
return ((val * 13) >> 3) - 36;
}
/** Maps -32768 ... +32767 to -244 ... +171 */
inline int16_t scaleAudioBiased(int16_t val)
{
return (((val >> 4) * 13) >> 7) - 36;
}
GRAINS's Audio Out is strongly affected by the impedance of the item its connected to. This particularly causes problems for CV when the CV output is meant to be volt per octave for pitches. For example, let's say that you are using Mozzi to output CV values from 0...5V corresponding to notes. Depending on the oscillator you attach this CV to, the oscillator may pull significant amperage from Audio Out, resulting in it scaling down its voltage. Instead of outputting 3.2 volts you might instead output 3.1 volts. This would be fine (you could write a table to adjust for it) except that many oscillators are different. For example, the 555 oscillator has a built-in op-amp and doesn't cause this much. But the VCO module has significant issues. Several of my GRAINS modules require tables depending on the particular device the output goes into. If you run the output through a buffered mult, you won't have many problems.
Below are some tables you can use to provide accurate Pitch CV depending on the oscillator you're plugged into.
// VALUES FOR 555
uint16_t positions[48] =
{
// C C# D D# E F F# G G# A A# B
0, 13, 22, 30, 38, 47, 55, 64, 72, 81, 89, 98, // Octave 1
107, 116, 124, 133, 141, 150, 159, 167, 176, 184, 193, 202, // Octave 2
210, 219, 227, 236, 244, 253, 262, 270, 279, 287, 296, 304, // Octave 3
313, 321, 330, 338, 346, 355, 363, 372, 380, 388, 399, 399 // Octave 4
// 555 has 47 notes
};
// VALUES FOR VCO
uint16_t positions[48] =
{
// C C# D D# E F F# G G# A A# B
0, 14, 24, 33, 42, 51, 60, 69, 78, 88, 97, 106, // Octave 1
115, 124, 134, 143, 152, 161, 171, 180, 189, 198, 208, 217, // Octave 2
226, 235, 244, 254, 263, 272, 281, 290, 299, 308, 318, 327, // Octave 3
350, 359, 368, 377, 385, 394, 394, 394, 394, 394, 394, 394 // Octave 4
// VCO has only 42 notes
};
// VALUES FOR uBUFFER
uint16_t positions[48] =
{
// C C# D D# E F F# G G# A A# B
0, 13, 21, 29, 38, 46, 55, 63, 72, 80, 90, 97, // Octave 1
106, 114, 123, 141, 139, 148, 156, 165, 173, 182, 190, 199, // Octave 2
208, 216, 225, 233, 242, 250, 259, 267, 276, 284, 293, 301, // Octave 3
309, 318, 326, 335, 343, 351, 359, 368, 376, 384, 392, 392 // Octave 4
// uBuffer has 47 notes
};
// VALUES FOR 4BUFFER
uint16_t positions[48] =
{
// C C# D D# E F F# G G# A A# B
0, 13, 21, 29, 38, 46, 55, 63, 72, 80, 89, 98, // Octave 1
107, 115, 124, 142, 140, 149, 157, 166, 174, 183, 191, 200, // Octave 2
209, 217, 226, 234, 243, 251, 260, 268, 277, 285, 294, 302, // Octave 3
311, 320, 328, 337, 345, 353, 361, 370, 378, 386, 394, 394 // Octave 4
// 4Buffer has 47 notes
};
// VALUES FOR 2OSCD
uint16_t positions[48] =
{
// C C# D D# E F F# G G# A A# B
0, 13, 22, 30, 39, 47, 56, 64, 73, 82, 90, 99, // Octave 1
107, 116, 125, 133, 142, 151, 159, 168, 176, 185, 194, 202, // Octave 2
211, 220, 228, 237, 245, 254, 262, 271, 280, 288, 297, 306, // Octave 3
314, 323, 331, 340, 348, 356, 365, 373, 382, 390, 403, 403 // Octave 4
// 2OSCD has 47 notes
};
To output a trigger, you need to raise a digital out, but then quickly lower it. To do this, you raise the digital out, then schedule it to be lowered. I do that like this:
#define MAX_COUNTDOWN 16 // or whatever is the right interval length
uint8_t triggerCountdown = 0;
/// *** The following code should appear at the very
/// top of your loop() or updateAudio() or updateControl()
if (triggerCountdown >= 1)
{
if (triggerCountdown == 1)
{
digitalWrite(myPin, 0);
}
triggerCountdown--;
}
/// The following code, located elsewhere, starts the trigger
digitalWrite(myPin, 1);
triggerCountdown = MAX_COUNTDOWN;
Note the code marked ***. This is put in some main looped function. But some looped functions are called more often than others. loop() will call super fast so maybe you'll need a bigger countdown than just a uint8_t. updateAudio() is called 16K times a second. updateControl() is called CONTROL_RATE times a second (these are Mozzi functions, see more about them below). I often do it in updateAudio(), or sometimes updateControl() with a very small MAX_COUNTDOWN.
This trick can be used for other delayed effects too. For example, if I'm using Audio Out's PWM as a digital output, it's pretty slow to respond. If I'm also using Gate Out (Digital Out) to output, it's really fast. If I need them to line up, I need Digital Out to wait a bit. I might set Audio Out's digital output, then set a very short countdown, and when it's done I set Digital Out's output.
The big challenge in using Mozzi lies in its updateControl(...) method. This method is called every once in a while so you can read in analog values etc. from the pots or incoming CV. In contrast, updateAudio(...) is called constantly.
You specify how often updateControl(...) is called using the CONTROL_RATE #define, which must be set before you #include Mozzi. For example:
#define CONTROL_RATE 128
This says that updateControl(...) will be called 128 times a second. Note that updateAudio(...) is being called 16384 times a second (GRAINS's sampling rate on Mozzi), so this means updateControl(...) is being called every 128 updateAudio(...) calls.
Mozzi suggests that CONTROL_RATE should be a power of two, though I have found non-powers-of-two to work okay.
If CONTROL_RATE is too slow, then your program will be too slow to respond well to incoming note and CV changes. If you're doing notes for pads, you might be able to get away with 64. If you don't need the knobs or CV inputs to respond in real-time at all, you could do even slower. But if you're doing triggers for drum notes, you want something fast, ideally even 256 if you can get away with it.
However, updateControl(...) takes time away from updateAudio(...), and this is reflected in a soft but infuriating whine you'll hear in the output. The pitch of the whine depends on the setting of CONTROL_RATE and on how computationally expensive updateControl(...) is, that is, how much time you spend in it. You want to make updateControl(...) short if possible, but computing pitch to frequency conversion, etc., is expensive.
And if the CONTROL_RATE is too high, you'll start getting audible clicks in your sound due to updateAudio(...) sitting and waiting for updateControl(...) to finish.
The Filtered PWM is also not very good for soft sounds. If you've got a large amplitude sound wave, it's great. If it dwindles to a very soft wave, you'll hear weird whiny and noisy distortion.
MIDI applications have a big advantage over non-MIDI applications here, because you don't have to poll for changes in pitch in every call to updateControl(...), so you don't have to do mozziAnalogRead(...) and do frequency conversion etc. Instead, you just check for incoming MIDI messages, and if there are none, you're done. You only change pitch when a MIDI message comes in. This makes MIDI both simpler and faster, which is valuable here (and pitch is stable, so your frequency table can be very small, just one frequency for each semitone).
updateAudio(...) must be completed very quickly. If it's done too slowly, it can't keep up with the sampling rate and you'll get distortion, whines, clicks, etc. It's the most time-sensitive function by far.
Mozzi uses the Oscil, MetaOscil, and Sample classes to define oscillators which play sounds. These classes have weaknesses. For one, thanks to Mozzi's use of C++ templating, you will find it difficult or impossible to put these classes into arrays. Second, the classes chew up a lot of memory, seemingly unecessarily. So beyond the tables you have to load for waves, you have to consider the memory cost of each Oscil or each MetaOscil. You will find that you can at most drive about 6 MetaOscil or 9 Sample instances at most, and fewer instances will sound better and cause less whining in updateAudio(...).
MIDI is achieved by setting up a serial port at 32150 BPS and reading from it. I have a package called "MIDI" in my collection which is designed to make it easy to parse MIDI and respond to messages. It's set up so that you can turn off everything you don't want, which automatically makes the code in the library smaller and faster.
MIDI has a big advantage over Gate/CV in GRAINS because you only update pitch and volume information etc. when MIDI messages arrive, as opposed to constantly polling gate/CV information in every call to updateControl(...). As a result, many of my MIDI apps run at a CONTROL_RATE of 256, which is pretty good.
The Arduino can do serial in two ways. First, it has a single UART (hardware to handle Serial). These are pins 0 (Receive) and 1 (Transmit). A UART is the very best option -- it's fast and has a buffer and doesn't hold up anything while it's doing its work. It's perfect. Unfortunately, these pins are not exposed as sockets. They do connect to the USB serial connection, so you can use the UART to read MIDI sent to it over serial on USB. I have a program called Dave.java in my DAVE package in my collection which can help transferring MIDI over serial from your DAW etc.
The other option is software serial. There are several software serial packages available for the Arduino, and they are all bad. Notably writing MIDI is very bad because it holds up everything while it's writing -- including incoming MIDI data to the software serial, which will then get dropped on the floor before we can read it.
The fastest software serial option that works for GRAINS is NeoSWSerial. You can find it in any of my MIDI firmware packages, such as PARA. If you're making a MIDI-based oscillator, you'd read on DIGITAL OUT (GATE OUT), which is by far your best pin option. It's all set up with my MIDI parser like this:
#include "NeoSWSerial.h"
#include "parsemidi.c"
#define MIDI_RATE 31250
#define BLANK_SERIAL 5 // I will get rid of this, I modified NeoSWSerial to do something...
#define PIN_UNUSED 255
NeoSWSerial softSerial(CV_GATE_OUT, BLANK_SERIAL, PIN_UNUSED);
midiParser parse;
Next you follow the instructions in parsemidi.c and parsemidi.h to set up MIDI how you'd like. Then in setup() you do:
initializeParser(&parse, OMNI, 0, 0); // or pick a channel
softSerial.begin(MIDI_RATE);
Then you define some MIDI functions according to what you turned on in parsemidi.c/h, for example
void noteOn(midiParser* parser, unsigned char note, unsigned char velocity)
{
// update pitches here...
}
If and when we get an upgraded GRAINS which exposes the hardware UART transmit and receive ports, then we'll be able to do highly reliable MIDI over serial. But right now all we have is software serial.
The GRAINS has 1K of EEPROM. This allows you to store data that survives power cycling and then reload it. I use it to store sequencer note data for example. It's particularly useful to store preferences, or perhaps stored patch data (such as CCs) sent over MIDI.
You should read up about how to use the EEPROM in the Arduino documentation. It's important that you never use EEPROM.write(). Instead, always use EEPROM.update(), which will help keep the EEPROM from burning out prematurely.
Never call EEPROM.update() in a loop or call it every time you have updateControl() called etc. It should be called very sparingly, such as ONCE when a user needs to save something. Remember that the EEPROM has roughly 100,000 write cycles.