simongehrig/McLighting
1
0
Fork 0
Code Issues 3 Pull Requests Projects Releases Wiki Activity

Version Bump to 3.1.0.BETA2

Browse Source 
Version Bump to 3.1.0.BETA2
bugfixes
implemented https://github.com/FabLab-Luenen/McLighting/commit/589806d0fda737011426754a6d84c88535ded688
This commit is contained in:
bpohvoodoo
2019-10-09 17:21:24 +02:00
parent 0188c8e273
commit 2e40c5934d
16 changed files with 829 additions and 746 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Arduino/McLighting/McLighting.ino
+49 -27
View File
@@ -327,6 +327,10 @@ void setup() {
} }
#endif #endif
#if defined(POWER_SUPPLY)
pinMode(POWER_SUPPLY, OUTPUT); // output to control external power supply
#endif
// start ticker with 0.5 because we start in AP mode and try to connect // start ticker with 0.5 because we start in AP mode and try to connect
ticker.attach(0.5, tick); ticker.attach(0.5, tick);
@@ -561,7 +565,7 @@ void setup() {
#if defined(ENABLE_REMOTE) #if defined(ENABLE_REMOTE)
irrecv.enableIRIn(); // Start the receiver irrecv.enableIRIn(); // Start the receiver
#endif #endif
fx_speed_actual = segState.speed[State.segment]; fx_speed = segState.speed[State.segment];
brightness_trans = State.brightness; brightness_trans = State.brightness;
initStrip(); initStrip();
strip->setBrightness(0); strip->setBrightness(0);
@@ -652,11 +656,19 @@ void loop() {
#if defined(ENABLE_MQTT) #if defined(ENABLE_MQTT)
snprintf(mqtt_buf, sizeof(mqtt_buf), "OK =off", ""); snprintf(mqtt_buf, sizeof(mqtt_buf), "OK =off", "");
#endif #endif
#if defined(POWER_SUPPLY)
digitalWrite(POWER_SUPPLY, LOW); // power off -> external power supply
#endif
if (Config.transEffect) { if (Config.transEffect) {
brightness_trans = 0; brightness_trans = 0;
} }
} }
} }
#if defined(POWER_SUPPLY)
if (State.mode != OFF) {
if (prevmode != State.mode) {digitalWrite(POWER_SUPPLY, HIGH); } // power on -> external power supply
}
#endif
if (State.mode == SET) { if (State.mode == SET) {
State.mode = HOLD; State.mode = HOLD;
@@ -665,7 +677,7 @@ void loop() {
#if defined(ENABLE_MQTT) #if defined(ENABLE_MQTT)
snprintf(mqtt_buf, sizeof(mqtt_buf), "OK Ss%i", State.segment); snprintf(mqtt_buf, sizeof(mqtt_buf), "OK Ss%i", State.segment);
#endif #endif
prevsegment = State.segment; //prevsegment = State.segment;
} }
// Mode // Mode
if (segState.mode[State.segment] != fx_mode) { if (segState.mode[State.segment] != fx_mode) {
@@ -679,9 +691,10 @@ void loop() {
//strip->setSpeed(State.segment, segState.speed[State.segment]); //strip->setSpeed(State.segment, segState.speed[State.segment]);
//strip->setColors(State.segment, segState.colors[State.segment]); //strip->setColors(State.segment, segState.colors[State.segment]);
strip->setMode(State.segment, segState.mode[State.segment]); strip->setMode(State.segment, segState.mode[State.segment]);
//strip->trigger;
} }
//Color //Color
/*if (memcmp(segmentState.colors[State.segment)], strip->getColors(State.segment), sizeof(segmentState.colors[State.segment)])) != 0) { /*if (memcmp(segmentState.colors[prevsegment)], strip->getColors(prevsegment), sizeof(segmentState.colors[prevsegment)])) != 0) {
convertColors(); convertColors();
}*/ }*/
// Brightness // Brightness
@@ -692,13 +705,12 @@ void loop() {
brightness_trans = State.brightness; brightness_trans = State.brightness;
} }
// Speed // Speed
if (fx_speed_actual != segState.speed[State.segment]) { if (fx_speed != segState.speed[State.segment]) {
#if defined(ENABLE_MQTT) #if defined(ENABLE_MQTT)
snprintf(mqtt_buf, sizeof(mqtt_buf), "OK ?%i", segState.speed[State.segment]); snprintf(mqtt_buf, sizeof(mqtt_buf), "OK ?%i", segState.speed[prevsegment]);
#endif #endif
} }
prevmode = SET; prevmode = SET;
//strip->trigger();
} }
if ((State.mode == HOLD) || ((State.mode == OFF) && (strip->getBrightness() > 0) && Config.transEffect)) { if ((State.mode == HOLD) || ((State.mode == OFF) && (strip->getBrightness() > 0) && Config.transEffect)) {
@@ -710,6 +722,7 @@ void loop() {
} }
if (prevmode != State.mode) { if (prevmode != State.mode) {
if (segState.mode[prevsegment] != FX_MODE_CUSTOM_0) {
convertColors(); convertColors();
if (memcmp(hexcolors_trans, strip->getColors(prevsegment), sizeof(hexcolors_trans)) != 0) { if (memcmp(hexcolors_trans, strip->getColors(prevsegment), sizeof(hexcolors_trans)) != 0) {
DBG_OUTPUT_PORT.println("Color changed!"); DBG_OUTPUT_PORT.println("Color changed!");
@@ -717,7 +730,8 @@ void loop() {
trans_cnt = 1; trans_cnt = 1;
memcpy(segState.colors[prevsegment], hexcolors_trans, sizeof(hexcolors_trans)); memcpy(segState.colors[prevsegment], hexcolors_trans, sizeof(hexcolors_trans));
} }
strip->setSpeed(State.segment, convertSpeed(fx_speed_actual)); strip->setSpeed(prevsegment, convertSpeed(fx_speed));
}
//strip->setBrightness(brightness_actual); //strip->setBrightness(brightness_actual);
#if defined(ENABLE_MQTT) #if defined(ENABLE_MQTT)
#if ENABLE_MQTT == 0 #if ENABLE_MQTT == 0
@@ -739,7 +753,7 @@ void loop() {
(writeStateFS(updateState)) ? DBG_OUTPUT_PORT.println("State FS Save Success!") : DBG_OUTPUT_PORT.println("State FS Save failure!"); (writeStateFS(updateState)) ? DBG_OUTPUT_PORT.println("State FS Save Success!") : DBG_OUTPUT_PORT.println("State FS Save failure!");
} }
if (updateSegState) { if (updateSegState) {
(writeSegmentStateFS(updateSegState, State.segment)) ? DBG_OUTPUT_PORT.println("Segment State FS Save Success!") : DBG_OUTPUT_PORT.println("Segment State FS Save failure!"); (writeSegmentStateFS(updateSegState, prevsegment)) ? DBG_OUTPUT_PORT.println("Segment State FS Save Success!") : DBG_OUTPUT_PORT.println("Segment State FS Save failure!");
} }
if (updateConfig) { if (updateConfig) {
(writeConfigFS(updateConfig)) ? DBG_OUTPUT_PORT.println("Config FS Save success!"): DBG_OUTPUT_PORT.println("Config FS Save failure!"); (writeConfigFS(updateConfig)) ? DBG_OUTPUT_PORT.println("Config FS Save success!"): DBG_OUTPUT_PORT.println("Config FS Save failure!");
@@ -772,25 +786,27 @@ void loop() {
} }
} }
// Async speed transition // Async speed transition
if ((segState.mode[prevsegment] != FX_MODE_CUSTOM_0) && (fx_speed_actual != segState.speed[prevsegment])) { if ((segState.mode[prevsegment] != FX_MODE_CUSTOM_0) && (fx_speed != segState.speed[prevsegment])) {
//if (Config.transEffect) { if (Config.transEffect) {
if (true == false) { // disabled for the moment //if (true == false) { // disabled for the moment
if (speedFadeDelay <= millis()) { if (speedFadeDelay <= millis()) {
DBG_OUTPUT_PORT.println("Speed actual: "); //DBG_OUTPUT_PORT.print("Speed trans actual: ");
DBG_OUTPUT_PORT.println(fx_speed_actual); if (fx_speed < segState.speed[prevsegment]) {
if (fx_speed_actual < segState.speed[prevsegment]) { fx_speed++;
fx_speed_actual++;
} }
if (fx_speed_actual > segState.speed[prevsegment]) { if (fx_speed > segState.speed[prevsegment]) {
fx_speed_actual--; fx_speed--;
} }
//DBG_OUTPUT_PORT.println(fx_speed);
speedFadeDelay = millis() + TRANS_DELAY; speedFadeDelay = millis() + TRANS_DELAY;
strip->setSpeed(prevsegment, convertSpeed(fx_speed_actual)); strip->setSpeed(prevsegment, convertSpeed(fx_speed));
if (State.mode == HOLD) strip->trigger(); if (State.mode == HOLD) strip->trigger();
} }
} else { } else {
fx_speed_actual = segState.speed[State.segment]; fx_speed = segState.speed[prevsegment];
strip->setSpeed(prevsegment, convertSpeed(fx_speed_actual)); //DBG_OUTPUT_PORT.print("Speed actual: ");
strip->setSpeed(prevsegment, convertSpeed(fx_speed));
//DBG_OUTPUT_PORT.println(fx_speed);
if (State.mode == HOLD) strip->trigger(); if (State.mode == HOLD) strip->trigger();
} }
} }
@@ -806,23 +822,29 @@ void loop() {
strip->decreaseBrightness(1); strip->decreaseBrightness(1);
} }
brightnessFadeDelay = millis() + TRANS_DELAY; brightnessFadeDelay = millis() + TRANS_DELAY;
//if (State.mode == HOLD) strip->trigger(); if (State.mode == HOLD) strip->trigger();
strip->trigger();
} }
} else { } else {
brightness_trans = State.brightness; brightness_trans = State.brightness;
strip->setBrightness(brightness_trans); strip->setBrightness(brightness_trans);
if (State.mode == HOLD) strip->trigger();
} }
} }
/* // Segment change only if color and speed transitions are finished, because they are segment specific // Segment change only if color and speed transitions are finished, because they are segment specific
if (prevsegment != State.segment) { if (prevsegment != State.segment) {
if ((memcmp(hexcolors_trans, strip->getColors(State.segment), sizeof(hexcolors_trans)) == 0) && (fx_speed_actual == segState.speed[State.segment])) { DBG_OUTPUT_PORT.println("Segment not equal");
State.segment = prevsegment; if ((segState.mode[State.segment] == FX_MODE_CUSTOM_0) || (segState.mode[State.segment] == FX_MODE_CUSTOM_2) || (segState.mode[prevsegment] == FX_MODE_CUSTOM_0)) {
fx_speed = segState.speed[State.segment];
DBG_OUTPUT_PORT.printf("Switched segment from: %i to %i", prevsegment, State.segment);
prevsegment = State.segment;
} else if ((memcmp(hexcolors_trans, strip->getColors(prevsegment), sizeof(hexcolors_trans)) == 0) && (fx_speed == segState.speed[prevsegment])) {
memcpy(hexcolors_trans, segState.colors[State.segment], sizeof(hexcolors_trans));
fx_speed = segState.speed[State.segment];
DBG_OUTPUT_PORT.printf("Switched segment from: %i to %i\r\n", prevsegment, State.segment);
prevsegment = State.segment;
} }
} }
*/
#if defined(ENABLE_REMOTE) #if defined(ENABLE_REMOTE)
handleRemote(); handleRemote();
Arduino/McLighting/WS2812FX.cpp
+4
View File
@@ -340,6 +340,10 @@ uint32_t* WS2812FX::getColors(uint8_t seg) {
return _segments[seg].colors; return _segments[seg].colors;
} }
uint8_t WS2812FX::getSegmentIndex(void) {
return _segment_index;
}
WS2812FX::Segment* WS2812FX::getSegment(void) { WS2812FX::Segment* WS2812FX::getSegment(void) {
return &_segments[_segment_index]; return &_segments[_segment_index];
} }
Arduino/McLighting/WS2812FX.h
+2 -1
View File
@@ -500,7 +500,8 @@ class WS2812FX : public Adafruit_NeoPixel {
getNumSegments(void), getNumSegments(void),
get_random_wheel_index(uint8_t), get_random_wheel_index(uint8_t),
getOptions(uint8_t), getOptions(uint8_t),
getNumBytesPerPixel(void); getNumBytesPerPixel(void),
getSegmentIndex(void);
uint16_t uint16_t
random16(void), random16(void),
Arduino/McLighting/data/index.htm
+2 -2
View File
@@ -1929,9 +1929,9 @@ function initSettings() {
redrawColorPicker(); redrawColorPicker();
}); });
var settransitionEffects = document.getElementById("set-transitionEffects"); var settransitionEffects = document.getElementById("set-transitionEffects");
settransitionEffects.checked = config.transitionEffects; settransitionEffects.checked = config.ws_trans;
settransitionEffects.addEventListener('change', ()=>{ settransitionEffects.addEventListener('change', ()=>{
config.transitionEffects = settransitionEffects.checked; config.ws_trans = settransitionEffects.checked;
if (settransitionEffects.checked) { if (settransitionEffects.checked) {
document.getElementById("settransitionEffectsbgcolor").style.backgroundColor = settings.theme_btn; document.getElementById("settransitionEffectsbgcolor").style.backgroundColor = settings.theme_btn;
ws_send("Ce1"); ws_send("Ce1");
Arduino/McLighting/data/index.htm.gz
BIN
View File
Binary file not shown.
Arduino/McLighting/definitions.h
+2 -2
View File
@@ -12,7 +12,7 @@
#define FX_OPTIONS 48 // ws2812fx Options 48 = SIZE_SMALL + FADE_MEDIUM is configurable just for the start; for WS2812FX setSegment OPTIONS, see: https://github.com/kitesurfer1404/WS2812FX/blob/master/extras/WS2812FX%20Users%20Guide.md #define FX_OPTIONS 48 // ws2812fx Options 48 = SIZE_SMALL + FADE_MEDIUM is configurable just for the start; for WS2812FX setSegment OPTIONS, see: https://github.com/kitesurfer1404/WS2812FX/blob/master/extras/WS2812FX%20Users%20Guide.md
//#define LED_TYPE_WS2811 // Uncomment, if LED type uses 400 KHz (classic 'v1' (not v2) FLORA pixels, WS2811 drivers) //#define LED_TYPE_WS2811 // Uncomment, if LED type uses 400 KHz (classic 'v1' (not v2) FLORA pixels, WS2811 drivers)
#define LED_BUILTIN 2 // ESP-12F has the built in LED on GPIO2, see https://github.com/esp8266/Arduino/issues/2192 #define LED_BUILTIN 2 // ESP-12F has the built in LED on GPIO2, see https://github.com/esp8266/Arduino/issues/2192
//#define POWER_SUPPLY 12 // PIN (12 / D6) If defined, enable output to control external power supply
char HOSTNAME[65] = "McLightingRGBW"; // Friedly hostname is configurable just for the start. Hostname should not contain spaces as this can break Home Assistant discovery if used. char HOSTNAME[65] = "McLightingRGBW"; // Friedly hostname is configurable just for the start. Hostname should not contain spaces as this can break Home Assistant discovery if used.
#define ENABLE_OTA 1 // If defined, enable Arduino OTA code. If set to 0 enable Arduino OTA code, if set to 1 enable ESP8266HTTPUpdateServer OTA code. #define ENABLE_OTA 1 // If defined, enable Arduino OTA code. If set to 0 enable Arduino OTA code, if set to 1 enable ESP8266HTTPUpdateServer OTA code.
@@ -183,7 +183,7 @@ struct {
bool transEffect = false; bool transEffect = false;
} Config; } Config;
uint8_t fx_speed_actual = 196; // Global variable for storing the speed for effects while fading --> smaller == slower uint8_t fx_speed = 196; // Global variable for storing the speed for effects while fading --> smaller == slower
uint8_t fx_mode = 0; uint8_t fx_mode = 0;
uint8_t brightness_trans = 0; // Global variable for storing the brightness before change uint8_t brightness_trans = 0; // Global variable for storing the brightness before change
uint32_t hexcolors_trans[3] = {}; // Color array of colors of WS2812FX before fading uint32_t hexcolors_trans[3] = {}; // Color array of colors of WS2812FX before fading
Arduino/McLighting/helper_functions.h
+4 -2
View File
@@ -208,8 +208,9 @@ void initStrip(uint16_t _stripSize = Config.stripSize, uint8_t _num_segments = C
(readSegmentStateFS(State.segment)) ? DBG_OUTPUT_PORT.println("Segment state config FS read Success!") : DBG_OUTPUT_PORT.println("Segment state config FS read failure!"); (readSegmentStateFS(State.segment)) ? DBG_OUTPUT_PORT.println("Segment state config FS read Success!") : DBG_OUTPUT_PORT.println("Segment state config FS read failure!");
memcpy(segState.colors[State.segment], hexcolors_trans, sizeof(hexcolors_trans)); memcpy(segState.colors[State.segment], hexcolors_trans, sizeof(hexcolors_trans));
strip->setSegment(State.segment, segState.start, segState.stop , segState.mode[State.segment], hexcolors_trans, convertSpeed(segState.speed[State.segment]), segState.options); strip->setSegment(State.segment, segState.start, segState.stop , segState.mode[State.segment], hexcolors_trans, convertSpeed(segState.speed[State.segment]), segState.options);
fx_speed_actual = segState.speed[State.segment]; fx_speed = segState.speed[State.segment];
fx_mode = segState.mode[State.segment]; fx_mode = segState.mode[State.segment];
brightness_trans = State.brightness;
prevsegment = State.segment; prevsegment = State.segment;
strip->setCustomMode(0, F("Autoplay"), handleAuto); strip->setCustomMode(0, F("Autoplay"), handleAuto);
strip->setCustomMode(1, F("Custom WS"), handleCustomWS); strip->setCustomMode(1, F("Custom WS"), handleCustomWS);
@@ -248,7 +249,8 @@ void getSegmentParams(uint8_t _seg) {
segState.stop = strip->getSegment(_seg)->stop;; segState.stop = strip->getSegment(_seg)->stop;;
//segState.mode[_seg] = strip->getMode(_seg); //segState.mode[_seg] = strip->getMode(_seg);
//segState.speed[_seg] = unconvertSpeed(strip->getSpeed(_seg)); //segState.speed[_seg] = unconvertSpeed(strip->getSpeed(_seg));
fx_speed_actual = segState.speed[_seg]; //fx_mode = segState.mode[_seg];
//fx_speed = segState.speed[_seg];
main_color.white = ((segState.colors[_seg][0] >> 24) & 0xFF); main_color.white = ((segState.colors[_seg][0] >> 24) & 0xFF);
main_color.red = ((segState.colors[_seg][0] >> 16) & 0xFF); main_color.red = ((segState.colors[_seg][0] >> 16) & 0xFF);
main_color.green = ((segState.colors[_seg][0] >> 8) & 0xFF); main_color.green = ((segState.colors[_seg][0] >> 8) & 0xFF);
Arduino/McLighting/htm_index_gz.h
+453 -454
View File
@@ -1,8 +1,7 @@
#include <pgmspace.h> #include <pgmspace.h>
#define index_htm_gz_len 20708
#define index_htm_gz_len 20709
static const char index_htm_gz[] PROGMEM ={ static const char index_htm_gz[] PROGMEM ={
0x1f, 0x8b, 0x08, 0x08, 0x1e, 0x16, 0x9a, 0x5d, 0x04, 0x00, 0x69, 0x6e, 0x1f, 0x8b, 0x08, 0x08, 0x48, 0xb8, 0x9c, 0x5d, 0x04, 0x00, 0x69, 0x6e,
0x64, 0x65, 0x78, 0x2e, 0x68, 0x74, 0x6d, 0x00, 0xe4, 0x5d, 0x5b, 0x77, 0x64, 0x65, 0x78, 0x2e, 0x68, 0x74, 0x6d, 0x00, 0xe4, 0x5d, 0x5b, 0x77,
0x1b, 0x49, 0x11, 0x7e, 0xe7, 0x1c, 0xfe, 0xc3, 0x44, 0x81, 0x44, 0x62, 0x1b, 0x49, 0x11, 0x7e, 0xe7, 0x1c, 0xfe, 0xc3, 0x44, 0x81, 0x44, 0x62,
0x25, 0x59, 0x17, 0xdb, 0x38, 0x72, 0xe4, 0xc5, 0xc9, 0x3a, 0xd9, 0x40, 0x25, 0x59, 0x17, 0xdb, 0x38, 0x72, 0xe4, 0xc5, 0xc9, 0x3a, 0xd9, 0x40,
@@ -1277,455 +1276,455 @@ static const char index_htm_gz[] PROGMEM ={
0x15, 0xde, 0x68, 0xe9, 0xd5, 0xcb, 0x1b, 0xf0, 0x6c, 0xd6, 0x02, 0x4e, 0x15, 0xde, 0x68, 0xe9, 0xd5, 0xcb, 0x1b, 0xf0, 0x6c, 0xd6, 0x02, 0x4e,
0x2d, 0x14, 0xcc, 0xb2, 0xe2, 0xfd, 0x03, 0xc1, 0xb5, 0x9f, 0xf3, 0x92, 0x2d, 0x14, 0xcc, 0xb2, 0xe2, 0xfd, 0x03, 0xc1, 0xb5, 0x9f, 0xf3, 0x92,
0x05, 0xc9, 0x9c, 0xce, 0x6e, 0xd1, 0x31, 0x92, 0x0f, 0xce, 0xcf, 0xe3, 0x05, 0xc9, 0x9c, 0xce, 0x6e, 0xd1, 0x31, 0x92, 0x0f, 0xce, 0xcf, 0xe3,
0x59, 0xdd, 0x4a, 0x56, 0xde, 0x77, 0x10, 0xa4, 0xb8, 0xbc, 0xd4, 0x24, 0x59, 0xdd, 0x4a, 0x56, 0xde, 0x77, 0x10, 0xa4, 0xb8, 0xbc, 0xd4, 0x94,
0xc7, 0xca, 0x6f, 0x77, 0x40, 0x4a, 0xb1, 0xdb, 0xac, 0x77, 0x79, 0xaa, 0xdc, 0xed, 0x5b, 0x2a, 0xa5, 0x48, 0x2d, 0x97, 0xb9, 0xc4, 0xd5, 0x97,
0x53, 0xc9, 0x97, 0x75, 0x5a, 0xac, 0x0a, 0x34, 0xfc, 0x22, 0x89, 0x8f, 0x4a, 0x2e, 0xac, 0xb3, 0x61, 0x55, 0xa0, 0xe1, 0xd7, 0x46, 0x7c, 0x54,
0xca, 0xf4, 0x82, 0xd4, 0xa5, 0xd3, 0x6d, 0x7e, 0x0c, 0xdd, 0x9d, 0x8e, 0xa6, 0x17, 0xa4, 0x1c, 0x9d, 0x6e, 0xf3, 0x43, 0xe7, 0xee, 0xe4, 0x23,
0xc4, 0x43, 0x10, 0x3a, 0xdb, 0xd6, 0x9f, 0x7d, 0x40, 0x68, 0xcb, 0xf5, 0x1e, 0x82, 0x88, 0xd9, 0xb6, 0xfe, 0xec, 0xe3, 0x40, 0x5b, 0xae, 0x77,
0xee, 0x74, 0xca, 0xeb, 0xb9, 0xfb, 0x90, 0xf5, 0xd4, 0xea, 0xe5, 0x9d, 0xa7, 0x53, 0x5e, 0xcf, 0xdd, 0x87, 0xac, 0xa7, 0x56, 0x2f, 0xef, 0x3c,
0x99, 0x2e, 0xae, 0x26, 0xc9, 0xb2, 0xf6, 0x64, 0x45, 0x1f, 0xa1, 0xa4, 0x74, 0x71, 0x35, 0x49, 0x96, 0xb5, 0xe7, 0x28, 0xfa, 0x08, 0x25, 0x35,
0xce, 0x4b, 0x2c, 0xd7, 0x6e, 0x6a, 0xef, 0xa4, 0xe8, 0xa0, 0x8d, 0xd6, 0x5c, 0x62, 0xb9, 0x56, 0x52, 0x7b, 0x15, 0x45, 0x07, 0x6d, 0xb4, 0x82,
0xd4, 0x7c, 0xc4, 0xa0, 0x0c, 0xad, 0x4c, 0x67, 0xaf, 0xfc, 0x32, 0xbe, 0xe6, 0x23, 0x06, 0x65, 0x68, 0x65, 0x3a, 0x3b, 0xe3, 0x97, 0xf1, 0x0d,
0x21, 0xb0, 0x2a, 0x56, 0x14, 0xf4, 0x6d, 0xf2, 0x13, 0x1a, 0x97, 0x88, 0x81, 0x55, 0xb1, 0xa2, 0xa0, 0x6f, 0x93, 0x9f, 0xd0, 0x94, 0x44, 0x74,
0xce, 0x58, 0x3f, 0x81, 0x01, 0x59, 0xa2, 0x8b, 0xa3, 0x71, 0xd1, 0xb0, 0xa2, 0xfa, 0x09, 0x0c, 0xbf, 0x12, 0x5d, 0x1c, 0x84, 0x8b, 0x86, 0xbd,
0x37, 0xea, 0xf6, 0x86, 0x07, 0xdd, 0x57, 0x47, 0x6f, 0xbe, 0xd9, 0x7d, 0x51, 0xb7, 0x37, 0x3c, 0xe8, 0xbe, 0x3a, 0x7a, 0xf3, 0xcd, 0xee, 0x6b,
0xad, 0x1c, 0x6e, 0x4f, 0xc2, 0xed, 0xbf, 0xf1, 0x7a, 0x15, 0xdc, 0xbe, 0xe5, 0x70, 0x7b, 0x12, 0x6e, 0xff, 0x8d, 0xd7, 0xab, 0xe0, 0xf6, 0x25,
0x84, 0x1b, 0x0e, 0x1f, 0x77, 0xbb, 0x3b, 0x43, 0x38, 0xf9, 0x15, 0x12, 0xdc, 0x70, 0xf8, 0xb8, 0xdb, 0xdd, 0x19, 0xc2, 0x39, 0xaf, 0x90, 0x30,
0x18, 0x3b, 0x5f, 0xad, 0x16, 0xd3, 0x49, 0x83, 0xce, 0x43, 0x85, 0x86, 0xd8, 0xf9, 0x6a, 0xb5, 0x98, 0x4e, 0x1a, 0x74, 0x1e, 0x2a, 0x34, 0x84,
0x50, 0x3e, 0x5f, 0xad, 0xf2, 0x78, 0x1b, 0x84, 0x6d, 0x96, 0x65, 0xab, 0xf2, 0xf9, 0x6a, 0x95, 0xc7, 0xdb, 0x20, 0x6c, 0xb3, 0x2c, 0x5b, 0x25,
0x44, 0x20, 0x73, 0x8a, 0x3f, 0x3c, 0xda, 0x47, 0x2b, 0xfe, 0xe8, 0xc5, 0x02, 0x99, 0x53, 0xb4, 0xe1, 0xd1, 0x3e, 0xda, 0xec, 0x47, 0x2f, 0x0e,
0xe1, 0x70, 0xf8, 0x88, 0x1d, 0xc2, 0x97, 0x0f, 0x3e, 0xf8, 0xe0, 0x51, 0x87, 0xc3, 0x47, 0xec, 0x10, 0xbe, 0x7c, 0xf0, 0xc1, 0x07, 0x8f, 0x42,
0x08, 0x65, 0x62, 0x79, 0x7b, 0x84, 0xe9, 0x66, 0x4b, 0x3b, 0xea, 0x76, 0x28, 0x13, 0xcb, 0xdb, 0x23, 0x4c, 0xf7, 0x58, 0xda, 0x51, 0xb7, 0xfb,
0x7f, 0xc2, 0x17, 0x84, 0xea, 0xfb, 0x13, 0x42, 0xc9, 0xfe, 0x24, 0xb1, 0x13, 0xbe, 0x17, 0x54, 0xdf, 0x9f, 0x10, 0x4a, 0xf6, 0x27, 0x89, 0x55,
0xca, 0xfa, 0x13, 0xe6, 0xe9, 0x90, 0x8d, 0x16, 0x7d, 0x5c, 0x5a, 0xc0, 0xd6, 0x9f, 0x30, 0x4f, 0x87, 0x6c, 0xb4, 0xc4, 0xe3, 0xd2, 0x02, 0xee,
0x9d, 0x59, 0x62, 0x88, 0x98, 0xe8, 0x28, 0xae, 0x2d, 0x20, 0x1f, 0xf1, 0xcc, 0x12, 0x43, 0xc4, 0x44, 0x07, 0x6f, 0x6d, 0x01, 0xf9, 0x88, 0x97,
0x12, 0xa9, 0xa0, 0x8e, 0xd5, 0x4b, 0x05, 0xa1, 0xa4, 0x54, 0x24, 0x56, 0x48, 0x05, 0x75, 0xac, 0x5e, 0x2a, 0x08, 0x25, 0xa5, 0x22, 0xb1, 0xca,
0x99, 0x54, 0x30, 0xcf, 0x84, 0x6c, 0x2f, 0x15, 0xce, 0x9d, 0xa4, 0x13, 0xa4, 0x82, 0x79, 0x26, 0x64, 0x7b, 0xa9, 0x70, 0xee, 0x24, 0x9d, 0x70,
0x2e, 0x15, 0x71, 0xe4, 0xbe, 0x49, 0x5f, 0x42, 0x80, 0x10, 0xd2, 0xf2, 0xa9, 0x88, 0x03, 0xf6, 0x4d, 0xfa, 0x12, 0x02, 0x84, 0x90, 0x96, 0x27,
0x2c, 0xce, 0xc3, 0x53, 0x2e, 0x76, 0xe6, 0xb6, 0x45, 0x1a, 0x97, 0xc6, 0x6f, 0x1e, 0x9e, 0x72, 0xb1, 0x0f, 0xb7, 0x2d, 0xd2, 0xb8, 0x10, 0xbe,
0xb7, 0x45, 0x9b, 0x4f, 0x17, 0xb6, 0x48, 0x1d, 0x66, 0x1f, 0x5b, 0x93, 0x2d, 0xda, 0x7c, 0x72, 0xb0, 0x45, 0xea, 0x30, 0xd7, 0xd8, 0x9a, 0xcc,
0xb9, 0x9c, 0xcc, 0x6c, 0x91, 0x3e, 0xcc, 0x8d, 0xda, 0xb3, 0x2f, 0xce, 0xe5, 0xd4, 0x65, 0x8b, 0xf4, 0x61, 0x26, 0xd4, 0x9e, 0x7d, 0x71, 0x9a,
0x37, 0xe6, 0xf1, 0x4d, 0xbe, 0x43, 0xb7, 0xfe, 0x78, 0x3f, 0x9f, 0xc7, 0x31, 0x8f, 0x6f, 0xf2, 0x1d, 0xba, 0xe3, 0xc7, 0xfb, 0xf9, 0x3c, 0x5e,
0x6b, 0x7e, 0x3a, 0x9d, 0x41, 0x92, 0xa2, 0xc9, 0x30, 0x66, 0x3b, 0x86, 0xf3, 0xb3, 0xe8, 0x0c, 0x92, 0x14, 0x4d, 0x86, 0x11, 0xda, 0x31, 0x48,
0xed, 0x0c, 0x1d, 0x8c, 0x11, 0xf5, 0x9f, 0x3d, 0x16, 0xcb, 0xe0, 0xfa, 0x67, 0xe8, 0x60, 0x8c, 0xa8, 0xff, 0xec, 0xb1, 0x58, 0x86, 0xd2, 0xcf,
0x59, 0xc8, 0x81, 0x59, 0x75, 0x25, 0x52, 0x4d, 0xe5, 0xfd, 0x87, 0x65, 0x42, 0x8e, 0xc7, 0xaa, 0x0b, 0x90, 0x6a, 0xe2, 0xee, 0x3f, 0x1a, 0xcb,
0x39, 0x4d, 0xf7, 0xc0, 0xac, 0xfa, 0xe3, 0x10, 0x70, 0x4e, 0xb6, 0x6e, 0x69, 0xba, 0xc7, 0x63, 0xd5, 0x1f, 0x87, 0x80, 0x53, 0xb1, 0x75, 0x23,
0x04, 0x1a, 0x8d, 0x46, 0xde, 0xf1, 0xed, 0x3e, 0x58, 0x49, 0x4e, 0xe2, 0xd0, 0x68, 0x34, 0xf2, 0x8e, 0x6f, 0xf7, 0xc1, 0x4a, 0x72, 0x12, 0x5f,
0x0b, 0x78, 0x32, 0xa0, 0xdd, 0x58, 0x07, 0x7f, 0x01, 0x27, 0xeb, 0xb6, 0xc0, 0x03, 0x01, 0xed, 0xc6, 0x3a, 0xf8, 0x0b, 0x38, 0x47, 0xb7, 0x1d,
0x43, 0x9e, 0x07, 0x41, 0xdc, 0x02, 0x61, 0x3a, 0x5c, 0xbb, 0x1d, 0xd2, 0xf2, 0x3c, 0xe4, 0xe1, 0x16, 0x08, 0xd3, 0x51, 0xda, 0xed, 0x90, 0xc6,
0x78, 0xe4, 0x76, 0x3b, 0x94, 0xf1, 0x20, 0xee, 0x96, 0x48, 0xf3, 0x10, 0x03, 0xb6, 0xdb, 0xa1, 0x8c, 0xc7, 0x6e, 0xb7, 0x44, 0x9a, 0x07, 0x9c,
0x74, 0xdb, 0xa1, 0x9d, 0xad, 0xe3, 0x6d, 0x35, 0xa3, 0x34, 0x36, 0xed, 0xdb, 0x0e, 0xed, 0x6c, 0x1d, 0x6f, 0xab, 0x19, 0xa5, 0xb1, 0x69, 0x47,
0x48, 0x3b, 0xfe, 0x4a, 0x1e, 0x30, 0x29, 0x02, 0x20, 0xc3, 0x5b, 0xc9, 0xda, 0xf1, 0x57, 0xf2, 0x80, 0x49, 0x11, 0x00, 0x19, 0xde, 0x4a, 0x5e,
0x4b, 0xa7, 0x44, 0x90, 0xa5, 0xc3, 0x3d, 0xc7, 0x7c, 0x88, 0x18, 0x13, 0x3a, 0x25, 0x82, 0x2c, 0x1d, 0xee, 0x39, 0xe6, 0x43, 0xc4, 0x98, 0xa0,
0x54, 0xc2, 0x1d, 0x15, 0x49, 0xa4, 0x0f, 0xeb, 0x35, 0x4d, 0xc6, 0x87, 0x12, 0xee, 0xa8, 0x48, 0x22, 0x7d, 0x58, 0x9d, 0x69, 0x32, 0x3e, 0xe4,
0x7c, 0x19, 0x42, 0x9d, 0xaf, 0xd3, 0xd4, 0x4f, 0x7a, 0x5d, 0xea, 0x8d, 0xcb, 0x10, 0xea, 0x7c, 0x55, 0xa6, 0x7e, 0xd2, 0xeb, 0x52, 0x6f, 0xb4,
0x56, 0x22, 0x1e, 0x78, 0x0a, 0x5e, 0xc9, 0x0d, 0xb7, 0x95, 0xcf, 0x26, 0x12, 0xf1, 0xc0, 0x53, 0xf0, 0x4a, 0x6e, 0xb8, 0xad, 0x7c, 0x36, 0x99,
0xb3, 0x3c, 0x81, 0x95, 0x40, 0x7e, 0x97, 0x3f, 0xea, 0x96, 0x2b, 0x4b, 0xe5, 0x09, 0xac, 0xfb, 0xf1, 0x9b, 0xfb, 0x51, 0xb7, 0x5c, 0x59, 0xb2,
0x16, 0xa4, 0x2d, 0x40, 0xd5, 0x52, 0x98, 0xac, 0x42, 0x63, 0x00, 0xda, 0x20, 0x6d, 0x01, 0xaa, 0x96, 0xc2, 0x64, 0x15, 0x1a, 0x03, 0xd0, 0x06,
0x80, 0x6d, 0xb2, 0x32, 0xe4, 0xa5, 0x06, 0xa5, 0x18, 0xa5, 0x36, 0xae, 0x6c, 0x93, 0x05, 0x21, 0x2f, 0x35, 0x28, 0xc5, 0x28, 0xb5, 0x71, 0x7d,
0xaf, 0x70, 0x10, 0xe8, 0xf1, 0xc5, 0xf3, 0xc9, 0x2c, 0x16, 0x8f, 0xb0, 0x85, 0x83, 0x40, 0x4f, 0x2d, 0x9e, 0x4f, 0x66, 0xb1, 0x78, 0x72, 0xa5,
0x34, 0x89, 0xcc, 0x2b, 0xe6, 0xf1, 0xe5, 0x01, 0x21, 0xd5, 0x24, 0xa7, 0x49, 0x1c, 0x5e, 0x31, 0x8f, 0x2f, 0x0f, 0xff, 0xa8, 0x26, 0x39, 0xd5,
0x1a, 0x04, 0x1b, 0xb4, 0x0e, 0x24, 0x5f, 0xd6, 0x43, 0x64, 0x5e, 0x10, 0x20, 0xd8, 0xa0, 0x75, 0x20, 0xf9, 0xb2, 0x1e, 0x22, 0xf3, 0x82, 0xd0,
0xba, 0xa7, 0x17, 0xd6, 0xa5, 0xf8, 0x03, 0xd2, 0x9e, 0xb6, 0xa1, 0xa8, 0xad, 0xbc, 0xb0, 0x2e, 0xc5, 0x9f, 0x8b, 0xf6, 0xb4, 0x0d, 0xc5, 0x28,
0x05, 0xb2, 0x69, 0x1e, 0xd6, 0xc9, 0x90, 0xb7, 0xb9, 0xc7, 0xf5, 0xfc, 0x90, 0x4d, 0xf3, 0xb0, 0x4e, 0x86, 0xbc, 0xbb, 0x3d, 0xae, 0xe7, 0xcf,
0x39, 0x78, 0x93, 0x54, 0x68, 0xbf, 0xba, 0x0a, 0x43, 0xb7, 0xad, 0x60, 0xc1, 0x9b, 0xa4, 0x42, 0xfb, 0xd5, 0xc5, 0x17, 0xba, 0x5b, 0x05, 0xfb,
0x67, 0x82, 0x75, 0xec, 0x6b, 0xd5, 0x00, 0x5c, 0x5c, 0xef, 0x92, 0x41, 0x10, 0xac, 0x63, 0x5f, 0xa2, 0x06, 0xe0, 0xe2, 0x32, 0x97, 0x0c, 0x99,
0x14, 0xba, 0xee, 0x4d, 0x2b, 0xfa, 0x33, 0x69, 0xb2, 0xd7, 0xc6, 0x2a, 0xd0, 0x75, 0xef, 0x55, 0xd1, 0x9f, 0x49, 0x93, 0xbd, 0x36, 0x56, 0xc1,
0x9c, 0x81, 0x73, 0x89, 0x14, 0x33, 0x62, 0x1e, 0x40, 0x1b, 0xae, 0x99, 0x0b, 0x9c, 0x2b, 0xa3, 0x98, 0x11, 0xf3, 0x70, 0xd9, 0x70, 0xa9, 0x2c,
0xc5, 0x19, 0x5d, 0xa4, 0x91, 0x8f, 0x77, 0x32, 0xae, 0x7f, 0x99, 0x86, 0xce, 0xe8, 0xda, 0x8c, 0x7c, 0xaa, 0x93, 0x71, 0xfd, 0xcb, 0x34, 0x24,
0x64, 0x5e, 0x8e, 0xbd, 0x9a, 0xac, 0x9d, 0x8b, 0xb1, 0xea, 0xcf, 0xbe, 0xf3, 0x2a, 0xec, 0xd5, 0x64, 0xed, 0x5c, 0x83, 0x55, 0x7f, 0xf6, 0x6d,
0x1f, 0xe6, 0xf0, 0x59, 0x63, 0xd0, 0xe4, 0xe5, 0x30, 0x3d, 0x6a, 0x4d, 0x30, 0x87, 0xcf, 0x1a, 0x83, 0x26, 0xaf, 0x82, 0xe9, 0x31, 0x6a, 0xc2,
0x58, 0xbd, 0x2c, 0x4f, 0xcc, 0xe8, 0x3b, 0xcf, 0xe7, 0x1f, 0xea, 0x3e, 0xea, 0x65, 0x79, 0x62, 0x46, 0xdf, 0x79, 0x3e, 0xff, 0x50, 0xf7, 0x11,
0x62, 0x39, 0x5b, 0x82, 0xab, 0xa6, 0xc1, 0x8f, 0xcc, 0x76, 0x23, 0xdd, 0xcb, 0xd9, 0x12, 0x5c, 0x35, 0x0d, 0x75, 0x64, 0xb6, 0x1b, 0xe9, 0x86,
0xf0, 0x5f, 0x93, 0x12, 0xd5, 0x16, 0x57, 0xa4, 0x3a, 0x5d, 0xa7, 0x59, 0xff, 0x52, 0x94, 0xa8, 0xb6, 0xb8, 0x10, 0xd5, 0xe9, 0x3a, 0xcd, 0x4a,
0xe9, 0x42, 0xa4, 0xdd, 0xac, 0x93, 0xc5, 0xe2, 0xaf, 0x6a, 0x51, 0x94, 0xd7, 0x1f, 0xed, 0x66, 0x9d, 0x2c, 0x16, 0x7f, 0x55, 0x8b, 0xa2, 0x5c,
0x2b, 0x97, 0x0e, 0x1b, 0x37, 0x69, 0xde, 0x23, 0x3f, 0x39, 0x02, 0x30, 0xb9, 0x74, 0xd8, 0xb8, 0x49, 0xf3, 0x1e, 0xf9, 0xc9, 0x11, 0x80, 0x29,
0x65, 0x43, 0x49, 0xed, 0xc4, 0xf3, 0x77, 0x6a, 0xc7, 0xd8, 0x97, 0xef, 0x1b, 0x4a, 0x6a, 0x27, 0x9e, 0xbf, 0x53, 0x3b, 0xc6, 0xbe, 0x7c, 0x7f,
0xaf, 0x45, 0x75, 0x25, 0xee, 0xdd, 0x05, 0xe5, 0xda, 0xb0, 0x1d, 0x86, 0x2d, 0xaa, 0x2b, 0x71, 0xef, 0x2e, 0x28, 0xd7, 0x06, 0xe9, 0x30, 0xbc,
0xf7, 0xd1, 0xc4, 0x54, 0xfa, 0x36, 0xe4, 0xaa, 0x6c, 0x9e, 0xda, 0xd3, 0x8f, 0x26, 0xa6, 0xd2, 0xb7, 0xfd, 0x56, 0x65, 0xf3, 0xd4, 0x0e, 0x1e,
0x83, 0x52, 0xac, 0x21, 0xce, 0xba, 0xcd, 0xfb, 0xc0, 0xb3, 0xbe, 0x30, 0x94, 0x62, 0x0d, 0x71, 0xd6, 0xdd, 0xdd, 0x07, 0x9e, 0xf5, 0x85, 0xa9,
0x55, 0x0e, 0x51, 0xe3, 0x06, 0x5a, 0x1b, 0x66, 0x94, 0xf4, 0x16, 0x7b, 0x72, 0x88, 0x1a, 0x37, 0xd0, 0xda, 0x30, 0xa3, 0xa4, 0xb7, 0xd8, 0x03,
0xc0, 0x89, 0x6a, 0x13, 0x36, 0x34, 0x16, 0xd4, 0xb7, 0x00, 0xc7, 0x52, 0x4e, 0x54, 0x9b, 0xb0, 0xa1, 0xb1, 0xa0, 0xbe, 0x05, 0x38, 0x96, 0x6a,
0x8d, 0x61, 0xd5, 0x65, 0xdc, 0x3b, 0x97, 0x70, 0xcd, 0x9b, 0xd9, 0x57, 0x0c, 0xab, 0x2e, 0xe3, 0xde, 0xb9, 0x72, 0x6b, 0xde, 0xc3, 0xbe, 0xca,
0x19, 0xe8, 0xf2, 0xf5, 0xe5, 0x6d, 0x8f, 0xe1, 0x23, 0xf6, 0x50, 0xa7, 0x40, 0x97, 0xaf, 0x2f, 0x6f, 0x7b, 0x0c, 0x9f, 0xac, 0x87, 0x3a, 0xd5,
0xda, 0xbb, 0xb1, 0xa2, 0x7c, 0x41, 0xa0, 0x68, 0xea, 0x1b, 0x63, 0xd7, 0xde, 0x84, 0x15, 0xe5, 0x0b, 0x02, 0x45, 0x53, 0xdf, 0x18, 0x7b, 0xec,
0x1d, 0xc8, 0xca, 0xf4, 0x52, 0x2f, 0x33, 0x82, 0x62, 0x71, 0xbc, 0x94, 0x40, 0x56, 0xa6, 0x97, 0x7a, 0x99, 0x11, 0x14, 0x8b, 0xe3, 0xa5, 0xbc,
0x37, 0xbf, 0x69, 0x17, 0xf3, 0xc5, 0xc9, 0x7c, 0xf4, 0xfa, 0xe8, 0x75, 0xe7, 0x4d, 0x7b, 0x96, 0x2f, 0x4e, 0xe6, 0xa3, 0xd7, 0x47, 0xaf, 0xd3,
0xda, 0xc6, 0x7c, 0xf1, 0xf1, 0x6c, 0x72, 0xbe, 0xbf, 0xdb, 0x51, 0x2e, 0xa6, 0xe5, 0x8b, 0x8f, 0x67, 0x93, 0xf3, 0xfd, 0xdd, 0x8e, 0x72, 0xb1,
0xd6, 0xbb, 0xcb, 0xe4, 0x6a, 0x42, 0x95, 0x48, 0x32, 0x62, 0x78, 0xce, 0xde, 0x5d, 0x26, 0x57, 0x13, 0xaa, 0x44, 0x92, 0x11, 0xc3, 0x73, 0x1e,
0x63, 0xbb, 0x90, 0x08, 0xe8, 0xe6, 0x55, 0x84, 0x17, 0xe4, 0xf9, 0x1d, 0xc9, 0x85, 0x44, 0x40, 0xf7, 0xac, 0x22, 0xbc, 0x0e, 0xcf, 0x6f, 0x8c,
0x72, 0x06, 0xa5, 0x0c, 0xf1, 0x4b, 0xd7, 0x77, 0xdd, 0xb5, 0x83, 0x62, 0x33, 0x28, 0x65, 0x88, 0x5f, 0xba, 0xbe, 0xcb, 0xad, 0x1d, 0x14, 0x03,
0x80, 0xfd, 0x70, 0x22, 0xc3, 0x4b, 0xf0, 0xbf, 0x1a, 0x72, 0x17, 0x70, 0xec, 0x7e, 0x13, 0x19, 0x5e, 0x82, 0xff, 0x8d, 0x90, 0xbb, 0x80, 0x5b,
0x4f, 0xd6, 0x20, 0xc6, 0x6d, 0x03, 0xbb, 0x17, 0x22, 0x55, 0x21, 0xbc, 0xb1, 0x06, 0x31, 0x6e, 0x1b, 0xd8, 0xbd, 0x10, 0xa9, 0x0a, 0xd8, 0xcd,
0xd9, 0xb7, 0xf1, 0xf4, 0x64, 0x05, 0x1e, 0x7b, 0x4e, 0x07, 0x17, 0x28, 0xbe, 0x8d, 0xa7, 0x27, 0x2b, 0xf0, 0xd8, 0x73, 0x3a, 0xa6, 0x40, 0x41,
0x6c, 0xf7, 0x22, 0xa6, 0xa7, 0xfa, 0xc5, 0x06, 0x38, 0x90, 0xbf, 0xb3, 0xba, 0x17, 0x31, 0x3d, 0xcc, 0x2f, 0xb6, 0xbb, 0x81, 0xfc, 0x9d, 0xfd,
0xdf, 0x10, 0x17, 0x1c, 0x1d, 0xb2, 0x21, 0xd6, 0x8c, 0xe7, 0xc2, 0xc9, 0x62, 0xb8, 0xe0, 0xe8, 0x90, 0x0d, 0xb1, 0x66, 0x3c, 0x17, 0xce, 0x01,
0xc0, 0xaf, 0xe2, 0x3c, 0x4d, 0xf0, 0xd9, 0xf1, 0x91, 0x48, 0x4b, 0x63, 0x7e, 0x15, 0xe7, 0x69, 0x82, 0x8f, 0x8c, 0x8f, 0x44, 0x5a, 0x1a, 0x2b,
0x85, 0xf3, 0x7e, 0xbc, 0x98, 0xdc, 0x7e, 0x94, 0xae, 0xae, 0x3f, 0x9c, 0x9c, 0xf7, 0xe3, 0xc5, 0xe4, 0xf6, 0xa3, 0x74, 0x75, 0xfd, 0xe1, 0x04,
0xe0, 0x33, 0xd9, 0x0a, 0x68, 0x1e, 0x4f, 0x37, 0x17, 0xfc, 0x3d, 0x73, 0x1f, 0xc5, 0x56, 0x40, 0xf3, 0x78, 0xba, 0xb9, 0xe0, 0xaf, 0x97, 0x03,
0x60, 0xeb, 0xc8, 0x7c, 0xa9, 0x58, 0xe0, 0xbf, 0xbb, 0x58, 0x98, 0xa1, 0x5b, 0x47, 0xe6, 0xbb, 0xc4, 0x02, 0xff, 0xdd, 0xc5, 0xc2, 0x0c, 0x1c,
0x04, 0xcc, 0xab, 0xa3, 0xc7, 0x8b, 0x15, 0x8c, 0x93, 0xeb, 0x55, 0x0e, 0x60, 0x5e, 0x14, 0x3d, 0x5e, 0xac, 0x60, 0x9c, 0x5c, 0xaf, 0x72, 0xd0,
0xba, 0x90, 0xc0, 0x00, 0x76, 0xcb, 0xd0, 0xcd, 0xd3, 0x18, 0xce, 0xb4, 0x85, 0x04, 0x06, 0xb0, 0x5b, 0x86, 0x6e, 0x9e, 0xc6, 0x70, 0xa6, 0xdd,
0xdb, 0xdc, 0xde, 0xe7, 0xcc, 0x55, 0x08, 0x8f, 0x08, 0x13, 0x9d, 0x20, 0xdd, 0xf6, 0x3e, 0x5e, 0xae, 0x02, 0x76, 0x44, 0x98, 0xe8, 0x84, 0x5c,
0xec, 0x90, 0x06, 0x32, 0x86, 0x52, 0x22, 0xaa, 0x32, 0xeb, 0x7c, 0x36, 0x87, 0x34, 0x90, 0x31, 0x94, 0x12, 0x51, 0x95, 0x59, 0xe7, 0xb3, 0xc9,
0x59, 0x6e, 0xa8, 0x24, 0x4a, 0x9d, 0x1f, 0x1e, 0x56, 0x30, 0x4b, 0xd1, 0x72, 0x43, 0x25, 0x51, 0xea, 0xfc, 0xf0, 0xb0, 0x82, 0x59, 0x8a, 0x3d,
0x08, 0xee, 0x7e, 0x8c, 0xe3, 0xf5, 0x31, 0x01, 0xf3, 0xca, 0xde, 0x6b, 0x70, 0xf7, 0x63, 0x1c, 0xaf, 0x8f, 0x09, 0x98, 0x57, 0xf6, 0x5e, 0x73,
0x0e, 0x7b, 0x2d, 0x7b, 0xd0, 0x0a, 0xa7, 0x67, 0x3a, 0x58, 0xf9, 0xc3, 0xd8, 0x6b, 0xd9, 0x83, 0x56, 0x38, 0x3d, 0xd3, 0xc1, 0xca, 0x9f, 0x61,
0xec, 0x68, 0x1f, 0x8c, 0x19, 0x4f, 0xe5, 0xdc, 0x58, 0xd1, 0xe8, 0x03, 0x47, 0xfb, 0x60, 0xcc, 0x78, 0x2a, 0xe7, 0xc6, 0x8a, 0x46, 0x1f, 0x20,
0x24, 0x75, 0x1d, 0xd3, 0xf5, 0x84, 0xd4, 0x32, 0xd7, 0xb3, 0xb1, 0xdb, 0xa9, 0xeb, 0x98, 0xae, 0x27, 0xa4, 0x96, 0xb9, 0x9e, 0x8d, 0xdd, 0x4e,
0x09, 0xb4, 0x6a, 0x4c, 0x83, 0x79, 0x57, 0x58, 0xd4, 0xaa, 0xb4, 0xe9, 0xa0, 0x55, 0x63, 0x1a, 0xcc, 0x9b, 0xc1, 0xa2, 0x56, 0xa5, 0x4d, 0x5f,
0xab, 0x15, 0x04, 0x68, 0x2a, 0x0d, 0x21, 0x30, 0x0a, 0x7e, 0x0f, 0x73, 0xad, 0x20, 0x40, 0x53, 0x69, 0x08, 0x81, 0x51, 0xa8, 0x7b, 0x98, 0x63,
0x2c, 0xb1, 0x15, 0xbf, 0x49, 0xa1, 0xb3, 0xd2, 0x00, 0xc4, 0xe1, 0x40, 0x89, 0x1d, 0xf8, 0x4d, 0x0a, 0x9d, 0x95, 0x06, 0x20, 0x0e, 0x07, 0x8a,
0xf1, 0xf9, 0xcf, 0x92, 0xd3, 0x25, 0xb2, 0xf6, 0x47, 0xb2, 0xf6, 0x1c, 0xcf, 0x7f, 0x96, 0x9c, 0x25, 0x91, 0xb5, 0x3f, 0x92, 0xb5, 0xe7, 0xd0,
0x5a, 0xa9, 0x0e, 0x5e, 0x1c, 0xb4, 0x55, 0x07, 0xd3, 0xc4, 0xe5, 0xcb, 0x4a, 0x75, 0xf0, 0x9a, 0xa0, 0xad, 0x3a, 0x98, 0x26, 0xae, 0x5a, 0x0e,
0x01, 0x74, 0x8f, 0x2b, 0x27, 0x16, 0x92, 0x0a, 0x3c, 0xeb, 0x86, 0xf4, 0xa0, 0x7b, 0x5c, 0x39, 0x91, 0x8f, 0x54, 0x98, 0x59, 0x37, 0x80, 0x07,
0x00, 0x8e, 0x48, 0x08, 0x62, 0x92, 0xf6, 0x95, 0xec, 0x4f, 0xc0, 0x59, 0x70, 0x44, 0x42, 0x10, 0x93, 0xb4, 0xaf, 0x64, 0x7f, 0x02, 0xce, 0x8a,
0xd1, 0x71, 0x71, 0x2d, 0xcf, 0x8a, 0x34, 0x72, 0xf8, 0xc6, 0x10, 0x03, 0x8e, 0x8b, 0x6b, 0x79, 0x56, 0x5c, 0x91, 0xc3, 0x37, 0x86, 0x18, 0x96,
0x75, 0x4d, 0xd2, 0xf9, 0x26, 0x59, 0xae, 0xe0, 0xab, 0xea, 0xce, 0x50, 0x6b, 0x92, 0xce, 0x37, 0xc9, 0x72, 0x05, 0x5f, 0x55, 0x77, 0x86, 0xd2,
0x7a, 0x79, 0xd0, 0x90, 0xe3, 0x82, 0x3a, 0x0a, 0x4a, 0xa9, 0x06, 0xd5, 0xcb, 0x43, 0x84, 0x1c, 0x17, 0xd4, 0x51, 0x50, 0x4a, 0x35, 0xa8, 0x9e,
0x13, 0xc8, 0x20, 0x7d, 0x9d, 0x40, 0xb5, 0xd2, 0x8a, 0x30, 0xd8, 0x98, 0x40, 0x06, 0xe9, 0xeb, 0x04, 0xaa, 0x95, 0x56, 0x04, 0xbd, 0xc6, 0x04,
0xc0, 0x91, 0x9c, 0x92, 0x31, 0x9c, 0x1e, 0xf5, 0xd4, 0xb1, 0xfd, 0xee, 0x8e, 0xe4, 0x94, 0x8c, 0xc1, 0xf3, 0xa8, 0xa7, 0x8e, 0xed, 0x57, 0x0e,
0x41, 0x35, 0x83, 0xf1, 0x3c, 0x9c, 0xbf, 0x80, 0x1e, 0xf3, 0xda, 0x6b, 0xaa, 0x19, 0x8c, 0xe7, 0xe1, 0xfc, 0x05, 0xf4, 0x98, 0xd7, 0x5e, 0xb3,
0x16, 0xce, 0xf3, 0xf5, 0x1d, 0x8b, 0x7b, 0xdd, 0x52, 0x3b, 0xbf, 0x3b, 0x70, 0x9e, 0xaf, 0xef, 0x58, 0xdc, 0xeb, 0x96, 0xda, 0xf9, 0xdd, 0xe9,
0x1d, 0x3f, 0x92, 0x19, 0xc9, 0xed, 0x35, 0x68, 0xdc, 0xba, 0x4a, 0xd8, 0xf8, 0x91, 0xcc, 0xb8, 0x6d, 0xaf, 0x41, 0xe3, 0xd6, 0x55, 0xc2, 0xf6,
0x7e, 0xc4, 0x91, 0x57, 0xda, 0x64, 0xad, 0x82, 0xc5, 0xfd, 0x3e, 0xf4, 0x23, 0x8e, 0xbc, 0xd2, 0x26, 0x6b, 0x15, 0x2c, 0xee, 0xf7, 0xa1, 0x7f,
0xaf, 0xad, 0x48, 0xbc, 0xdf, 0xdf, 0xaa, 0xc4, 0x9f, 0x57, 0x78, 0xb2, 0x6d, 0x45, 0xe2, 0xfd, 0xfe, 0x56, 0x25, 0xfe, 0xbc, 0xc2, 0x93, 0x5d,
0x6b, 0xd6, 0x59, 0xda, 0xb7, 0xc6, 0x4c, 0x19, 0x38, 0x0f, 0x23, 0xa1, 0xb3, 0xce, 0xd2, 0xbe, 0x35, 0x66, 0xca, 0xc0, 0x79, 0x18, 0x09, 0x8d,
0xd1, 0x53, 0xef, 0x83, 0xda, 0x8e, 0x5c, 0x92, 0xe0, 0xb6, 0xfb, 0x80, 0x95, 0x7a, 0x1f, 0xd4, 0x76, 0xe4, 0x92, 0x04, 0xb7, 0xdd, 0x07, 0x04,
0xa0, 0x57, 0xcb, 0xc0, 0x46, 0xbb, 0x0f, 0x88, 0x6e, 0x03, 0x56, 0xa4, 0xbd, 0x5a, 0x06, 0x36, 0xda, 0x7d, 0x40, 0x2c, 0x1b, 0xb0, 0x22, 0xc5,
0x18, 0xd1, 0xf5, 0xf1, 0x97, 0xc4, 0xa4, 0xe4, 0x32, 0x50, 0x40, 0xb2, 0x88, 0xae, 0x8f, 0xbf, 0x24, 0x26, 0x25, 0x97, 0x81, 0x02, 0x92, 0xa5,
0x14, 0xc0, 0x2c, 0x92, 0xc2, 0xc7, 0x26, 0x45, 0xb2, 0x7f, 0x3e, 0x49, 0x00, 0x66, 0x91, 0x14, 0x3e, 0x36, 0x29, 0x92, 0xfd, 0xf3, 0x49, 0xb2,
0x16, 0xb1, 0x88, 0x71, 0x52, 0x2d, 0x5b, 0x60, 0xd8, 0x64, 0xd9, 0x61, 0x88, 0x45, 0x44, 0x93, 0x6a, 0xd9, 0x02, 0xc3, 0x26, 0xcb, 0x0e, 0xc3,
0xd8, 0x64, 0xb7, 0xda, 0xb6, 0x02, 0xfe, 0x26, 0x5d, 0x94, 0xd8, 0xd2, 0x26, 0xbb, 0xd5, 0xb6, 0x15, 0xf0, 0x37, 0xe9, 0xa2, 0xc4, 0x96, 0xd6,
0xda, 0xa9, 0xd4, 0xbf, 0x3b, 0x0a, 0xbd, 0x15, 0x19, 0x89, 0xe2, 0x34, 0x4e, 0xa5, 0xfe, 0xdd, 0x31, 0xe7, 0xad, 0x38, 0x48, 0x14, 0x95, 0x11,
0x82, 0x64, 0x32, 0x90, 0x8c, 0x3e, 0xb4, 0x7e, 0x7b, 0x19, 0x2f, 0xf9, 0x24, 0x93, 0x81, 0x64, 0xf4, 0xa1, 0xf5, 0xdb, 0xcb, 0x78, 0xc9, 0x07,
0xa0, 0xaa, 0x44, 0x9a, 0x64, 0xe4, 0x81, 0xf5, 0xe8, 0xa5, 0x19, 0x8a, 0x55, 0x25, 0xd2, 0x24, 0x23, 0x0f, 0xac, 0x47, 0xef, 0xca, 0x50, 0xe4,
0x05, 0x41, 0x52, 0x17, 0xc3, 0x2f, 0xa4, 0xa6, 0x3f, 0xc7, 0xa9, 0xaf, 0x07, 0x92, 0xba, 0x18, 0x7e, 0x21, 0x35, 0xfd, 0x39, 0x4e, 0x7d, 0xad,
0x35, 0xd4, 0x88, 0xe0, 0x3e, 0xe9, 0xe2, 0xea, 0x78, 0xd1, 0x4e, 0x54, 0xa1, 0x46, 0x04, 0xf7, 0x01, 0x17, 0x57, 0xc7, 0x8b, 0x76, 0xa2, 0xd2,
0x9a, 0x3b, 0xc5, 0x4b, 0x8a, 0xd6, 0x8f, 0xe7, 0x6e, 0x80, 0x34, 0x02, 0xdc, 0x29, 0x5e, 0x52, 0xb4, 0x7e, 0x3c, 0x77, 0xc3, 0xa1, 0x11, 0x48,
0x49, 0xe3, 0xf3, 0x34, 0xce, 0x2e, 0x9f, 0xd1, 0x2a, 0x29, 0x4c, 0x42, 0x1a, 0x9f, 0xa7, 0x71, 0x76, 0xf9, 0x8c, 0x56, 0x49, 0x61, 0x12, 0xca,
0xf9, 0xd0, 0xff, 0x44, 0xfc, 0x8a, 0xa8, 0xaf, 0xa9, 0xe3, 0x5e, 0x2f, 0x87, 0xfe, 0x27, 0xe2, 0x57, 0x44, 0x7d, 0x4d, 0x1d, 0xf7, 0x7a, 0xa9,
0x75, 0xba, 0x3d, 0x72, 0x7a, 0x77, 0xb1, 0xac, 0x06, 0x86, 0x4b, 0x79, 0xd3, 0xed, 0x91, 0xd3, 0xbb, 0x8b, 0x65, 0x35, 0x30, 0x5c, 0xca, 0x53,
0x2a, 0x42, 0x8b, 0x1b, 0x58, 0x89, 0xb0, 0x5e, 0x22, 0xe8, 0xb6, 0x1a, 0x11, 0x5a, 0xdc, 0xc0, 0x4a, 0x84, 0xf5, 0x12, 0x41, 0xb7, 0xd5, 0xc0,
0x78, 0x76, 0x76, 0xca, 0x1e, 0x27, 0x54, 0x35, 0x17, 0xf3, 0x87, 0x11, 0xb3, 0xb3, 0x53, 0xf6, 0x14, 0xa1, 0xaa, 0xb9, 0x98, 0x3f, 0x8c, 0xb0,
0xd6, 0xbd, 0x19, 0xea, 0xb1, 0x40, 0xdd, 0x6b, 0x8e, 0xfa, 0x9b, 0x40, 0xee, 0xcd, 0x50, 0x8f, 0x05, 0xea, 0x5e, 0x73, 0xd4, 0xdf, 0x04, 0xea,
0x7d, 0x8c, 0xa8, 0x41, 0x9b, 0x1b, 0xa5, 0x3d, 0x0e, 0x5a, 0xed, 0xe5, 0x63, 0x44, 0x0d, 0xda, 0xdc, 0x28, 0xed, 0x71, 0xd0, 0x6a, 0x2f, 0x77,
0x4e, 0x33, 0x12, 0xe1, 0xdd, 0x0e, 0x88, 0x53, 0xbf, 0x0b, 0xe2, 0xb1, 0x9a, 0x91, 0x08, 0xef, 0x76, 0x40, 0x9c, 0xfa, 0x5d, 0x10, 0x8f, 0x6d,
0x6d, 0xdf, 0xc3, 0xf8, 0xa5, 0xb7, 0xd2, 0x51, 0xde, 0x6a, 0x0f, 0x24, 0xfb, 0x1e, 0x46, 0x2b, 0xbd, 0x95, 0x8e, 0xf2, 0x56, 0x7b, 0x20, 0x79,
0x2f, 0xa1, 0x69, 0x17, 0xe4, 0x13, 0xa1, 0xda, 0x4e, 0x68, 0x47, 0x78, 0x09, 0x4d, 0xbb, 0x20, 0x9f, 0x08, 0xd5, 0x76, 0x42, 0x3b, 0x9e, 0x1b,
0xa3, 0xe7, 0x33, 0x8b, 0xfe, 0xe6, 0xed, 0x93, 0x5d, 0x5f, 0xa5, 0x3f, 0x3d, 0x96, 0x59, 0xf4, 0x37, 0x6f, 0x9f, 0xec, 0xfa, 0x2a, 0xfd, 0xe9,
0x5d, 0x5d, 0x30, 0x1a, 0x11, 0xb3, 0xb2, 0x5a, 0x50, 0xae, 0x5e, 0x0b, 0xea, 0x82, 0xd1, 0x88, 0x98, 0x95, 0xd5, 0x82, 0x72, 0xf5, 0x5a, 0x50,
0x4a, 0xf0, 0x56, 0x85, 0x72, 0xf4, 0xca, 0xc8, 0xc0, 0x6f, 0xf4, 0xd9, 0x82, 0xb7, 0x2a, 0x94, 0xa3, 0x57, 0x46, 0x86, 0x79, 0xa3, 0xcf, 0xa6,
0xb4, 0x4a, 0xe8, 0x3a, 0xb8, 0x63, 0x62, 0x9e, 0xde, 0x1e, 0xd3, 0xd5, 0x55, 0x42, 0xd7, 0xc1, 0x1d, 0x13, 0xf3, 0xf4, 0xf6, 0x98, 0x2e, 0x12,
0xc2, 0xb7, 0xc7, 0xda, 0x18, 0x32, 0x50, 0xf3, 0x66, 0xe2, 0xac, 0xa1, 0xbe, 0x3d, 0xd6, 0xc6, 0x90, 0x81, 0x9a, 0x37, 0x13, 0x67, 0x0d, 0x1d,
0x43, 0xe4, 0xda, 0x15, 0xf5, 0x57, 0xef, 0x6c, 0xb6, 0xb2, 0x2c, 0x41, 0x22, 0xd7, 0xae, 0xa8, 0xbf, 0x7a, 0x67, 0xb3, 0x95, 0x65, 0x09, 0xb2,
0xd6, 0x45, 0x5a, 0xb1, 0xc6, 0x15, 0xb2, 0xc6, 0xfc, 0x36, 0x65, 0x77, 0x2e, 0xd2, 0x8a, 0x35, 0xae, 0x90, 0x35, 0xe6, 0xb7, 0x29, 0xbb, 0xd3,
0xda, 0x84, 0xfd, 0x13, 0xe5, 0x92, 0xd7, 0x34, 0x64, 0xaf, 0xf9, 0x5b, 0x26, 0xc8, 0x9f, 0x28, 0x97, 0xbc, 0xa6, 0x21, 0x7b, 0xcd, 0xdf, 0x42,
0x08, 0xd2, 0x43, 0xf0, 0x47, 0x5a, 0xe4, 0xc0, 0xa1, 0x1b, 0x3a, 0xd0, 0x90, 0x1e, 0x82, 0x3f, 0xd2, 0xe2, 0x04, 0x0e, 0xdd, 0x40, 0x81, 0x7e,
0xaf, 0xcb, 0xe2, 0x38, 0x06, 0x0f, 0x01, 0x1b, 0xd0, 0x47, 0x8b, 0xe8, 0x5d, 0x16, 0xc7, 0x31, 0x78, 0xc0, 0xd7, 0x80, 0x3e, 0x5a, 0xc4, 0x4a,
0x49, 0x41, 0xb1, 0x8f, 0x95, 0x66, 0x23, 0x79, 0x41, 0x9a, 0xc7, 0x40, 0x0a, 0x8a, 0x74, 0xac, 0x34, 0x1b, 0xc9, 0x0b, 0xd2, 0x3c, 0xe2, 0xf1,
0x1e, 0x20, 0x6d, 0x9d, 0x43, 0x50, 0xd4, 0xb0, 0xd7, 0x5c, 0x0a, 0xcc, 0x00, 0x69, 0xeb, 0x1c, 0x82, 0xa2, 0x86, 0xbd, 0xdd, 0x52, 0x60, 0xee,
0x9d, 0x9d, 0xa0, 0x45, 0xd1, 0x47, 0x64, 0xf9, 0x1e, 0xc9, 0x4d, 0x5e, 0xec, 0x04, 0x2d, 0x8a, 0x3e, 0x22, 0xcb, 0xf7, 0x48, 0x6e, 0xf2, 0x8a,
0xf1, 0x8a, 0x21, 0x36, 0xd9, 0x12, 0x7a, 0xab, 0xbb, 0xed, 0x64, 0x56, 0x37, 0x0b, 0xb1, 0xc9, 0x96, 0xd0, 0x5b, 0xdd, 0x6d, 0x27, 0xb3, 0x0a,
0x01, 0xca, 0x07, 0x76, 0xe1, 0xdf, 0xe7, 0x78, 0x44, 0x46, 0x46, 0xd9, 0x50, 0x3e, 0xb0, 0x0b, 0xff, 0x3e, 0xc7, 0x93, 0x31, 0x32, 0xa6, 0x86,
0x70, 0x5f, 0xf1, 0x30, 0xa3, 0x17, 0x8c, 0x75, 0xe8, 0x23, 0x16, 0x74, 0xfb, 0x66, 0x87, 0x19, 0xab, 0x60, 0xac, 0x43, 0x1f, 0xb1, 0xa0, 0xd3,
0x3a, 0xcf, 0x1f, 0x06, 0x21, 0xe0, 0x35, 0x0e, 0x5c, 0x2b, 0x2e, 0xe7, 0x79, 0xfe, 0xa0, 0x07, 0x01, 0x6f, 0x6f, 0xe0, 0x5a, 0x71, 0x39, 0x47,
0x88, 0x72, 0xc7, 0x05, 0x60, 0x08, 0x41, 0xf5, 0x46, 0x73, 0xf0, 0x73, 0x94, 0x3b, 0x2e, 0x00, 0x43, 0x08, 0xaa, 0x17, 0x99, 0x83, 0x1f, 0x27,
0x25, 0xee, 0xeb, 0xd3, 0x16, 0x25, 0x4b, 0xe6, 0xaa, 0x91, 0x28, 0xa0, 0x71, 0xdf, 0x9a, 0xb6, 0x28, 0x59, 0x32, 0x57, 0x8d, 0x44, 0xe1, 0xdb,
0x1b, 0x3b, 0x56, 0xaf, 0xbf, 0x62, 0xd4, 0x37, 0x0f, 0xb0, 0xf5, 0x48, 0xd8, 0xb1, 0x7a, 0xeb, 0x15, 0x63, 0xbc, 0x79, 0x80, 0xad, 0x27, 0xb1,
0x76, 0x48, 0x01, 0x6e, 0x4d, 0x69, 0x4f, 0x5b, 0xb4, 0xe1, 0x09, 0x3d, 0x43, 0x0a, 0x70, 0x6b, 0x4a, 0x7b, 0xda, 0xa2, 0x0d, 0x4f, 0xe8, 0xa1,
0xdd, 0xc7, 0x2f, 0x36, 0x67, 0x14, 0x65, 0xac, 0x56, 0x30, 0x04, 0xeb, 0x3e, 0x7e, 0x8d, 0x39, 0xa3, 0x98, 0x62, 0xb5, 0x82, 0x21, 0x58, 0x47,
0xc8, 0x04, 0xe0, 0xee, 0xac, 0xdb, 0xf1, 0x63, 0x05, 0x7e, 0x14, 0x12, 0x26, 0x00, 0x77, 0x67, 0xdd, 0x85, 0x1f, 0x2b, 0xf0, 0xa3, 0x90, 0x48,
0x1b, 0xc0, 0x7f, 0xbf, 0x3f, 0xa8, 0xf5, 0xf1, 0x92, 0xb5, 0xcb, 0x92, 0x00, 0xfe, 0xdb, 0xfc, 0x41, 0xad, 0x8f, 0x57, 0xaa, 0x5d, 0x96, 0x6c,
0xcd, 0x13, 0xc0, 0x8c, 0x0b, 0xf0, 0xa3, 0x80, 0x1b, 0xfa, 0xfe, 0x7b, 0x9e, 0x00, 0x66, 0x5c, 0x80, 0x1f, 0x05, 0xdc, 0xc7, 0xf7, 0xdf, 0xaa,
0xf6, 0x21, 0x0c, 0x9d, 0xdf, 0x3c, 0x2b, 0xd3, 0x48, 0xa0, 0xe5, 0x28, 0x0f, 0x61, 0xe8, 0xfc, 0xe6, 0x59, 0x99, 0x46, 0x02, 0x2d, 0x47, 0x29,
0x25, 0x80, 0x87, 0xea, 0x25, 0x9d, 0x27, 0x0a, 0x56, 0x49, 0xe7, 0x59, 0x01, 0x3c, 0x54, 0x2f, 0xe9, 0x3c, 0x51, 0xb0, 0x4a, 0x3a, 0x8f, 0x70,
0x6e, 0x45, 0xa3, 0x46, 0x19, 0x2b, 0xf5, 0xd0, 0x7e, 0x2e, 0x5c, 0x51, 0x2b, 0x1a, 0x35, 0xca, 0x58, 0xa9, 0x87, 0xf6, 0xe3, 0xe0, 0x8a, 0x6a,
0x0d, 0xd3, 0x40, 0xab, 0x4e, 0x74, 0xa6, 0x22, 0xb8, 0x4e, 0xee, 0x23, 0x98, 0x06, 0x5a, 0x75, 0xa2, 0x33, 0x15, 0xc1, 0x75, 0x72, 0x9f, 0x3c,
0x28, 0x8a, 0x08, 0x3c, 0x71, 0x77, 0x14, 0x84, 0x95, 0x1a, 0x58, 0xc3, 0x51, 0x44, 0xe0, 0x41, 0xbb, 0xa3, 0x20, 0xac, 0xd4, 0xc0, 0x1a, 0x06,
0x40, 0xac, 0x0b, 0x03, 0x6b, 0x14, 0x88, 0x35, 0x35, 0xb0, 0xf6, 0x02, 0x62, 0x5d, 0x18, 0x58, 0xa3, 0x40, 0xac, 0xa9, 0x81, 0xb5, 0x17, 0x88,
0xb1, 0xe0, 0x1c, 0x27, 0x8f, 0xd1, 0xf1, 0x74, 0xf5, 0x71, 0x7c, 0x13, 0x05, 0xe7, 0x38, 0x79, 0x44, 0x8e, 0xa7, 0xab, 0x8f, 0xe3, 0x9b, 0xe8,
0x9d, 0xea, 0x75, 0xec, 0x19, 0xbc, 0xf7, 0x0c, 0x9e, 0x7a, 0x46, 0x59, 0x54, 0xaf, 0x63, 0xcf, 0xe0, 0xbd, 0x67, 0xf0, 0xd4, 0x33, 0xca, 0x3a,
0x67, 0xdd, 0xb0, 0xd2, 0xae, 0x47, 0x06, 0x93, 0x8f, 0x03, 0x99, 0x4c, 0xeb, 0x86, 0x95, 0x76, 0x3d, 0x32, 0x98, 0x7c, 0x1c, 0xc8, 0x64, 0x6a,
0x4d, 0xb4, 0xfd, 0x40, 0xb4, 0x0b, 0x13, 0xed, 0x20, 0x10, 0x6d, 0x6a, 0xa2, 0xed, 0x07, 0xa2, 0x5d, 0x98, 0x68, 0x07, 0x81, 0x68, 0x53, 0x13,
0xa2, 0xbd, 0x1e, 0x88, 0x06, 0x92, 0x1c, 0x95, 0x88, 0xf2, 0xb1, 0x21, 0xed, 0xf5, 0x40, 0x34, 0x90, 0xe4, 0xa8, 0x44, 0x94, 0x8f, 0x0d, 0x71,
0xae, 0x7d, 0xe3, 0xd7, 0x01, 0xfe, 0x52, 0x85, 0x85, 0x8b, 0x72, 0xcf, 0xed, 0x1b, 0xbf, 0x0e, 0xf0, 0x97, 0x2a, 0x2c, 0x5c, 0x94, 0x7b, 0x06,
0xe0, 0xf2, 0x8d, 0x40, 0x2e, 0x53, 0x13, 0xed, 0xcd, 0x40, 0xb4, 0x0b, 0x97, 0x6f, 0x04, 0x72, 0x99, 0x9a, 0x68, 0x6f, 0x06, 0xa2, 0x5d, 0x98,
0x13, 0x6d, 0x18, 0xda, 0x01, 0xa6, 0x16, 0x5e, 0x68, 0x17, 0x00, 0x61, 0x68, 0xc3, 0xd0, 0x0e, 0x30, 0xb5, 0xf0, 0x42, 0xbb, 0x00, 0x08, 0x73,
0xee, 0x95, 0x08, 0xf3, 0x0d, 0x43, 0x60, 0x6f, 0x9a, 0x5a, 0x6a, 0x29, 0xaf, 0x44, 0x98, 0x6f, 0x18, 0x02, 0x7b, 0xd3, 0xd4, 0x52, 0x4b, 0x69,
0xed, 0x10, 0xc4, 0xf9, 0x10, 0xc3, 0x21, 0x5a, 0x12, 0x3b, 0xbe, 0xf0, 0x87, 0x20, 0xce, 0x87, 0x18, 0x0e, 0xd1, 0x92, 0xd8, 0xd1, 0x84, 0xc7,
0xb8, 0x6a, 0x45, 0x91, 0x55, 0xc6, 0xa7, 0x1d, 0xa4, 0x25, 0x4c, 0xb1, 0x55, 0x2b, 0x8a, 0xac, 0x32, 0x1a, 0xed, 0x20, 0x2d, 0x61, 0x8a, 0x55,
0xea, 0x98, 0xb4, 0xd0, 0x0e, 0x65, 0x88, 0xd5, 0x71, 0x68, 0x07, 0xd3, 0x47, 0xa0, 0x85, 0x76, 0x28, 0x43, 0xac, 0x8e, 0x3a, 0x3b, 0x98, 0x96,
0x52, 0xbc, 0xea, 0xd8, 0xb3, 0x83, 0x6b, 0x81, 0x18, 0x60, 0x6e, 0x2b, 0xe2, 0x55, 0x47, 0x9a, 0x1d, 0x5c, 0x0b, 0xc4, 0x00, 0x73, 0x5b, 0x21,
0x04, 0x35, 0x6a, 0x2d, 0xa8, 0x51, 0x6b, 0x49, 0x8d, 0xda, 0x8a, 0x6a, 0xa8, 0x51, 0x6b, 0x41, 0x8d, 0x5a, 0x4b, 0x6a, 0xd4, 0x56, 0x54, 0xa3,
0xd4, 0x5a, 0x56, 0xa3, 0x46, 0xc2, 0x2a, 0x91, 0xd5, 0x5e, 0x6b, 0x59, 0xd6, 0xb2, 0x1a, 0x35, 0x12, 0x56, 0x89, 0xac, 0xf6, 0x5a, 0xcb, 0x6a,
0xed, 0xb5, 0x96, 0xd5, 0x5e, 0x5b, 0x59, 0xed, 0xb5, 0x96, 0xd5, 0x5e, 0xaf, 0xb5, 0xac, 0xf6, 0xda, 0xca, 0x6a, 0xaf, 0xb5, 0xac, 0xf6, 0xc2,
0xb8, 0xac, 0xfc, 0xce, 0x25, 0x7f, 0x71, 0xb3, 0x91, 0x53, 0x59, 0xf1, 0x65, 0xe5, 0x77, 0x2e, 0xf9, 0xfb, 0x9a, 0x8d, 0x9c, 0xca, 0x8a, 0x67,
0x30, 0xe5, 0x9d, 0x13, 0x85, 0xd5, 0x7e, 0x9b, 0x32, 0x24, 0x54, 0x6c, 0x28, 0xef, 0x9c, 0x98, 0xab, 0xf6, 0x4b, 0x94, 0x21, 0x81, 0x61, 0x4b,
0x49, 0x6c, 0xd8, 0x20, 0x97, 0xab, 0xe2, 0x69, 0xcb, 0xbb, 0xfa, 0xc7, 0x22, 0xc1, 0x06, 0xb9, 0x5c, 0x15, 0x0f, 0x59, 0xde, 0xd5, 0x3f, 0x65,
0x2d, 0x83, 0x42, 0xbb, 0x96, 0x85, 0x72, 0x0d, 0xf2, 0x7e, 0x65, 0xe4, 0x19, 0x14, 0xc8, 0xb5, 0x2c, 0x70, 0x6b, 0x90, 0xf7, 0x2b, 0xe3, 0x8c,
0xd1, 0x5a, 0xfe, 0x3c, 0xef, 0x63, 0xd6, 0xf2, 0x07, 0x30, 0x5e, 0xfe, 0xd6, 0xf2, 0xe7, 0x79, 0x0d, 0xb3, 0x96, 0x3f, 0x80, 0xf1, 0xf2, 0x47,
0x28, 0x2b, 0xcc, 0x3b, 0xaf, 0x78, 0x60, 0xf3, 0xae, 0xfe, 0x89, 0xcd, 0x59, 0x61, 0xde, 0x79, 0xc5, 0x73, 0x9a, 0x77, 0xf5, 0x0f, 0x6a, 0x06,
0xa0, 0x70, 0xa9, 0xa5, 0xe1, 0x51, 0x83, 0xf9, 0xf3, 0xbf, 0xd1, 0x79, 0x05, 0x47, 0x2d, 0x0d, 0x86, 0x1a, 0xcc, 0x9f, 0xff, 0x45, 0xce, 0xbb,
0x57, 0xff, 0x4a, 0x27, 0x0b, 0x09, 0x6c, 0x5a, 0x1a, 0xc8, 0x34, 0x84, 0xfa, 0x37, 0x39, 0x59, 0x48, 0x18, 0xd3, 0xd2, 0xb0, 0xa5, 0x21, 0xfc,
0xbf, 0x8a, 0x67, 0x3e, 0xef, 0x2a, 0x1e, 0xfa, 0x0c, 0x99, 0x72, 0xcf, 0x55, 0x3c, 0xea, 0x79, 0x57, 0xf1, 0xac, 0x67, 0xc8, 0x94, 0x7b, 0xb6,
0x96, 0x56, 0xe3, 0x2a, 0x5a, 0x81, 0x9c, 0x01, 0x85, 0x5a, 0xce, 0xcc, 0xb4, 0x1a, 0x57, 0xd1, 0x0a, 0xe4, 0x0c, 0x28, 0xd4, 0x72, 0x66, 0xbe,
0xb7, 0x42, 0x03, 0x16, 0x03, 0x66, 0xab, 0x4d, 0x09, 0x63, 0xb3, 0xb0, 0x0c, 0x1a, 0xb0, 0x18, 0x30, 0x5b, 0x6d, 0x4a, 0x18, 0x9b, 0x85, 0x2d,
0xe5, 0x80, 0xbf, 0xec, 0xad, 0xd1, 0xb0, 0x8b, 0x81, 0x56, 0x3d, 0xfe, 0x07, 0xfc, 0x65, 0x2f, 0x8b, 0x86, 0x5d, 0x0c, 0xb4, 0xea, 0xf1, 0x17,
0x82, 0xf7, 0x4b, 0x19, 0x0b, 0x7f, 0x29, 0x33, 0xac, 0x42, 0xd7, 0x0d, 0xbc, 0x56, 0xca, 0x58, 0xf8, 0xbb, 0x98, 0x61, 0x15, 0xba, 0x6e, 0xf0,
0x9e, 0xcd, 0xa4, 0x3f, 0xf3, 0x04, 0xee, 0x76, 0x0a, 0xd5, 0x96, 0x48, 0x48, 0x26, 0xfd, 0x99, 0x27, 0x70, 0xb7, 0x53, 0xa8, 0xb6, 0x44, 0x1a,
0xc3, 0x06, 0xbb, 0x5d, 0x09, 0x1a, 0xe0, 0xea, 0x5e, 0x37, 0x85, 0x1f, 0x36, 0xd8, 0xed, 0x4a, 0xd0, 0x00, 0x57, 0xf7, 0xba, 0x29, 0xfc, 0xa8,
0x35, 0x45, 0xd8, 0xab, 0x42, 0x00, 0x2d, 0x0f, 0x1a, 0x71, 0xc3, 0xdf, 0x29, 0xc2, 0x5e, 0x15, 0x02, 0x68, 0x79, 0xd0, 0x88, 0x1b, 0xfe, 0x0a,
0xa5, 0xbd, 0xab, 0x78, 0x99, 0xb6, 0xb6, 0x4f, 0x02, 0x8c, 0x57, 0x93, 0xed, 0x5d, 0xc5, 0x3b, 0xb4, 0xb5, 0x7d, 0x12, 0x60, 0xbc, 0x9a, 0x0c,
0x21, 0x3d, 0xb0, 0x47, 0x96, 0xbd, 0x6b, 0x7b, 0x57, 0xf7, 0xb2, 0x6d, 0xe9, 0x81, 0x3d, 0xb2, 0xec, 0x15, 0xdb, 0xbb, 0xba, 0x77, 0x6c, 0x1b,
0xe3, 0x48, 0x25, 0x2e, 0x9b, 0x44, 0x29, 0xd4, 0xda, 0x52, 0xf8, 0x9c, 0xc7, 0x25, 0x71, 0xd9, 0x24, 0x4a, 0xa1, 0xd6, 0x96, 0x82, 0xe5, 0x84,
0x70, 0xd3, 0xe1, 0x09, 0xf2, 0x63, 0x50, 0x3a, 0x6a, 0x76, 0x16, 0xdf, 0x9b, 0x0e, 0x4f, 0x48, 0x1f, 0x83, 0xd2, 0x51, 0xb3, 0xb3, 0xf8, 0xd6,
0xba, 0xf7, 0x1b, 0x1c, 0xe0, 0xae, 0x39, 0x7d, 0xbc, 0xf9, 0x5b, 0x5b, 0xbd, 0xdf, 0xe0, 0x70, 0x76, 0xcd, 0xe9, 0xe3, 0xcd, 0xdf, 0xda, 0x02,
0xc0, 0x70, 0xd4, 0xbe, 0x00, 0x71, 0xf7, 0x37, 0x30, 0xe4, 0x56, 0x73, 0x86, 0xa3, 0xf6, 0x05, 0x88, 0xbb, 0xbf, 0x81, 0x01, 0xb6, 0x9a, 0xd3,
0xfa, 0x70, 0xf7, 0xb7, 0xb6, 0x02, 0x07, 0xb0, 0xfb, 0x19, 0xd4, 0x8f, 0x87, 0xbb, 0xbf, 0xb5, 0x15, 0x38, 0x80, 0xdd, 0xcf, 0xa0, 0x7e, 0x84,
0xf0, 0x8d, 0x39, 0x30, 0x30, 0x8d, 0x56, 0x43, 0x61, 0x2d, 0x26, 0x58, 0x2f, 0xca, 0x81, 0x81, 0x69, 0xb4, 0x1a, 0x0a, 0x6b, 0x31, 0xc1, 0x6a,
0x4d, 0x00, 0x5e, 0x1d, 0x73, 0xc3, 0x17, 0x76, 0xec, 0x13, 0x28, 0x6e, 0x02, 0xf0, 0xea, 0x98, 0x1b, 0xbe, 0xa7, 0x63, 0x9f, 0x40, 0x71, 0x4b,
0x49, 0x04, 0x36, 0x00, 0x3f, 0x95, 0x5e, 0xb2, 0x2a, 0x7e, 0x88, 0xe3, 0x22, 0xb0, 0x01, 0xf8, 0xa9, 0xf4, 0x6e, 0x55, 0xf1, 0x43, 0x1c, 0x57,
0xca, 0xec, 0x6d, 0xb6, 0xeb, 0x2f, 0xcd, 0x7f, 0xe3, 0x80, 0x4e, 0x92, 0x66, 0x6f, 0xb3, 0x5d, 0x7f, 0x69, 0xfe, 0x1b, 0x07, 0x74, 0x92, 0xec,
0xdd, 0x31, 0x7a, 0x7e, 0xed, 0x50, 0x51, 0xeb, 0xb1, 0x64, 0xce, 0x7f, 0x8e, 0xd1, 0x63, 0x6b, 0x87, 0x8a, 0x5a, 0x8f, 0x25, 0x73, 0xfe, 0x93,
0x12, 0x9c, 0x3a, 0x4a, 0x19, 0x38, 0x09, 0xa0, 0xe4, 0x80, 0x93, 0xff, 0xe0, 0xd4, 0x51, 0xca, 0xc0, 0x49, 0x00, 0x25, 0x07, 0x9c, 0xfc, 0xb7,
0xf6, 0xd4, 0x9e, 0x79, 0x66, 0xf5, 0xee, 0xc3, 0x27, 0x2e, 0x80, 0xff, 0xa7, 0xf6, 0xcc, 0x33, 0xab, 0x77, 0x9f, 0x39, 0x71, 0x01, 0xfc, 0x4f,
0x31, 0x95, 0xb2, 0x92, 0xe8, 0x2e, 0x16, 0xfb, 0x8a, 0xfe, 0x05, 0x92, 0xa7, 0x94, 0x95, 0x44, 0x77, 0xb1, 0xd8, 0x57, 0xf4, 0x2f, 0x90, 0xb4,
0x16, 0x64, 0xf9, 0x13, 0x2c, 0x55, 0x9c, 0x67, 0xf4, 0x84, 0x49, 0xba, 0x20, 0xcb, 0x1f, 0x5c, 0xa9, 0xe2, 0x3c, 0xa3, 0x07, 0x4b, 0xd2, 0xd5,
0x5a, 0x64, 0xe5, 0x80, 0x72, 0x63, 0x86, 0x10, 0x5c, 0x38, 0x99, 0x2f, 0x22, 0x2b, 0x07, 0x94, 0x1b, 0x33, 0x84, 0xe0, 0xc2, 0xc9, 0x7c, 0x51,
0xaa, 0x40, 0xaf, 0xa1, 0x1e, 0xd5, 0x9c, 0x46, 0x32, 0x50, 0xd8, 0x39, 0x05, 0x7a, 0xfb, 0xf4, 0xa8, 0xe6, 0x34, 0x92, 0x81, 0xc2, 0xce, 0xa1,
0x14, 0x93, 0x5d, 0xc6, 0xf3, 0x17, 0x8c, 0xf1, 0x3f, 0xe8, 0x76, 0x5b, 0x98, 0xec, 0x32, 0x9e, 0xbf, 0x60, 0x8c, 0xff, 0x41, 0xb7, 0xdb, 0x4a,
0x69, 0x09, 0x3e, 0xac, 0x8a, 0x82, 0xa0, 0x81, 0x4b, 0x49, 0x91, 0xde, 0x4b, 0xf0, 0x61, 0x55, 0x14, 0x04, 0x0d, 0x5c, 0x4a, 0x8a, 0xf4, 0x0e,
0xa1, 0x24, 0x68, 0x83, 0xac, 0xf8, 0xe5, 0xdb, 0x77, 0x2a, 0x32, 0x99, 0x25, 0x41, 0x1b, 0x64, 0xc5, 0x2f, 0xdf, 0xbe, 0x53, 0x91, 0xc9, 0xe4,
0x7c, 0x17, 0xb6, 0xf6, 0x60, 0xd6, 0x13, 0x80, 0x4e, 0x26, 0x8b, 0xe4, 0x2b, 0xb0, 0xb5, 0x07, 0xb3, 0x9e, 0x00, 0x74, 0x32, 0x59, 0x24, 0xbf,
0x17, 0xd8, 0x3d, 0x1c, 0x0c, 0x06, 0x0e, 0x67, 0xea, 0xea, 0x9e, 0x7a, 0xc0, 0xee, 0xe1, 0x60, 0x30, 0x70, 0x38, 0x53, 0x57, 0xf7, 0xd4, 0x73,
0xa0, 0x88, 0x94, 0x9b, 0xd7, 0xc9, 0x07, 0x5c, 0x66, 0x6d, 0x8c, 0xf5, 0x44, 0xa4, 0xdc, 0xbc, 0x4e, 0x3e, 0xe0, 0x32, 0x6b, 0x63, 0xac, 0xd7,
0xfa, 0x26, 0x77, 0x2b, 0xa1, 0x60, 0x97, 0x2b, 0x75, 0xd2, 0xfa, 0x53, 0x37, 0xb9, 0x5b, 0x09, 0x05, 0xbb, 0x5c, 0xa9, 0x93, 0xd6, 0x9f, 0x8a,
0xf1, 0x7c, 0x26, 0xd8, 0x1c, 0x9f, 0x5a, 0xaa, 0x63, 0x1d, 0xfc, 0xfc, 0xc7, 0x32, 0xc1, 0xe6, 0xf8, 0xd4, 0x52, 0x1d, 0xeb, 0xe0, 0xe7, 0x67,
0x4c, 0xd3, 0x1b, 0x5d, 0xcd, 0xf6, 0x09, 0x6b, 0xa9, 0x15, 0x71, 0x3f, 0x9a, 0xde, 0xe8, 0x6a, 0xb6, 0x4f, 0x58, 0x4b, 0xad, 0x88, 0xfb, 0xe1,
0x7c, 0x14, 0xbd, 0xc7, 0xf1, 0xe8, 0xb0, 0x7e, 0x69, 0xff, 0xe5, 0xd2, 0xa3, 0xe8, 0x3d, 0x8e, 0x47, 0x87, 0xf5, 0x4b, 0xfb, 0x2f, 0x97, 0x56,
0x2a, 0xef, 0xe0, 0x33, 0xb5, 0xf8, 0xe7, 0x05, 0x52, 0x1a, 0x25, 0xcf, 0x79, 0x07, 0x9f, 0xa9, 0xc5, 0x3f, 0x2f, 0x90, 0xd2, 0x28, 0x79, 0x76,
0x0e, 0x54, 0x5d, 0x01, 0x9b, 0xe1, 0x65, 0x47, 0x46, 0x7b, 0xbb, 0x6a, 0xa0, 0xea, 0x0a, 0xd8, 0x0c, 0x2f, 0x3b, 0x32, 0xda, 0xdb, 0x55, 0x5b,
0xeb, 0xd8, 0x3d, 0xe5, 0x46, 0xe7, 0x65, 0xc4, 0x9e, 0x30, 0xe9, 0xa0, 0xc7, 0xee, 0x29, 0x37, 0x3a, 0x2f, 0x23, 0xf6, 0x84, 0x49, 0x07, 0xdd,
0xbb, 0x05, 0x7c, 0xc2, 0x10, 0x88, 0x74, 0x5a, 0x02, 0x1e, 0xf9, 0x77, 0x2d, 0xe0, 0x13, 0x86, 0x40, 0xa4, 0xd3, 0x12, 0xf0, 0xc8, 0xbf, 0xbb,
0x97, 0x0d, 0x62, 0xea, 0xa0, 0xb7, 0x4c, 0x7a, 0x61, 0x0c, 0xc7, 0x81, 0x6c, 0x10, 0x53, 0x07, 0xbd, 0x65, 0xd2, 0x0b, 0x63, 0x38, 0x0e, 0x44,
0xa8, 0x90, 0x90, 0x43, 0xc0, 0x95, 0x07, 0xeb, 0xcb, 0xb8, 0xd4, 0x4f, 0x85, 0x84, 0x1c, 0x02, 0xae, 0x3c, 0x58, 0x5f, 0xc6, 0xa5, 0x7e, 0x6a,
0x2d, 0xe6, 0x2b, 0xe2, 0x19, 0xd1, 0x07, 0x9b, 0x74, 0xe1, 0x39, 0x0f, 0x31, 0x5f, 0x11, 0xcf, 0x88, 0x3e, 0xd8, 0xa4, 0x0b, 0xcf, 0x79, 0x00,
0xe0, 0x72, 0xac, 0x8c, 0xbb, 0xf7, 0x64, 0xb9, 0xbc, 0xbc, 0xf8, 0x8c, 0x97, 0x63, 0x65, 0xdc, 0xbd, 0x27, 0xcb, 0xe5, 0xe5, 0xc5, 0x67, 0x7c,
0xaf, 0x92, 0x61, 0x3f, 0xa3, 0xf4, 0x28, 0xa3, 0x4d, 0x45, 0xdf, 0xf3, 0x95, 0x0c, 0xfb, 0x19, 0xa5, 0x47, 0x19, 0x6d, 0x2a, 0xfa, 0x1e, 0x7b,
0x6f, 0x1c, 0x83, 0xf6, 0xa1, 0x38, 0x10, 0x10, 0xae, 0x0b, 0x81, 0x00, 0xe3, 0x18, 0xb4, 0x0f, 0xc5, 0x81, 0x80, 0x70, 0x5d, 0x08, 0x04, 0x18,
0xe3, 0x7b, 0x1b, 0x34, 0xb0, 0xe5, 0x2d, 0x31, 0xdb, 0xa0, 0xd1, 0x22, 0xdf, 0xdb, 0xa0, 0x81, 0x2d, 0x6f, 0x89, 0xd9, 0x06, 0x8d, 0x16, 0xf1,
0x5e, 0x6b, 0xc4, 0x96, 0xbc, 0xe2, 0xfa, 0x5f, 0x5b, 0xbc, 0x96, 0x45, 0x5a, 0x23, 0xb6, 0xe4, 0x15, 0xd7, 0xff, 0xda, 0xe2, 0xb5, 0x2c, 0x12,
0xe2, 0x64, 0xaa, 0x55, 0x99, 0x84, 0x58, 0x5d, 0x28, 0x74, 0x0e, 0x5b, 0x27, 0x53, 0xad, 0xca, 0x24, 0xc4, 0xea, 0x42, 0xa1, 0x73, 0xd8, 0xaa,
0x75, 0xee, 0xed, 0x4e, 0xea, 0x1f, 0xd6, 0x24, 0xf8, 0x34, 0x0f, 0xbb, 0x73, 0x6f, 0x77, 0x52, 0xff, 0xb0, 0x26, 0xc1, 0xa7, 0x79, 0xd8, 0x8d,
0xd1, 0x06, 0x70, 0x66, 0xa8, 0x53, 0x75, 0x1f, 0x0c, 0x68, 0x94, 0x5f, 0x36, 0x80, 0x33, 0x03, 0x9b, 0xaa, 0xfb, 0x60, 0x40, 0xa3, 0xfc, 0x3a,
0x07, 0x83, 0x4c, 0xba, 0x09, 0xd6, 0x60, 0x10, 0x90, 0x3d, 0xc7, 0xac, 0x18, 0x64, 0xd2, 0x4d, 0xb0, 0x06, 0x83, 0x80, 0xec, 0x39, 0x66, 0x15,
0x62, 0x2c, 0xcf, 0x2b, 0xb0, 0x21, 0xfb, 0xf5, 0x57, 0x23, 0x6d, 0x0c, 0x63, 0x79, 0x5e, 0x81, 0x0d, 0xd9, 0xaf, 0xbf, 0x1a, 0x69, 0x63, 0x48,
0x69, 0xe8, 0xec, 0xc1, 0xb0, 0x63, 0x42, 0xee, 0xbf, 0xde, 0x05, 0x5e, 0x43, 0x67, 0x0f, 0x86, 0x1d, 0x13, 0x72, 0xff, 0xf5, 0x2e, 0xf0, 0xc2,
0xf8, 0x00, 0xf2, 0xf5, 0xc9, 0xd3, 0x2f, 0x3e, 0x63, 0xd0, 0xcd, 0x3f, 0x07, 0x90, 0xaf, 0x4f, 0x9e, 0x7e, 0xf1, 0x19, 0x83, 0x6e, 0xfe, 0xd9,
0xfb, 0xe2, 0xfd, 0x0f, 0xac, 0x57, 0xb6, 0x2a, 0xaf, 0x0b, 0x8a, 0xde, 0x17, 0xef, 0x7f, 0x60, 0xbd, 0xa9, 0x55, 0x79, 0x5d, 0x50, 0xf4, 0x6e,
0xed, 0xbf, 0x21, 0x2d, 0xf0, 0x1f, 0xfc, 0x92, 0x34, 0x27, 0xdb, 0xe8, 0xff, 0x0d, 0x69, 0x81, 0xff, 0xe0, 0x97, 0xa4, 0x39, 0xd9, 0x46, 0x77,
0xce, 0x5c, 0xd8, 0x7b, 0x2b, 0x1c, 0x06, 0x98, 0x73, 0x11, 0x8d, 0x65, 0xe6, 0xc2, 0x5e, 0x57, 0xe1, 0x30, 0xc0, 0x9c, 0x8b, 0x68, 0x2c, 0x13,
0x02, 0x99, 0xd8, 0xe8, 0x0e, 0xab, 0xbf, 0xc9, 0xde, 0xe6, 0x7b, 0x4b, 0xc8, 0xc4, 0x46, 0x77, 0x58, 0xfd, 0x4d, 0xf6, 0x36, 0xdf, 0x5b, 0xaa,
0xf5, 0x27, 0x14, 0x1f, 0xc8, 0x6d, 0x80, 0xe2, 0x25, 0x29, 0xa5, 0x20, 0x3f, 0xa1, 0xf8, 0x40, 0x6e, 0x03, 0x14, 0x2f, 0x49, 0x29, 0x05, 0xd9,
0xfb, 0x07, 0xc0, 0x02, 0xdd, 0x9b, 0xfb, 0xfa, 0xe9, 0x17, 0x5f, 0x7e, 0x3f, 0x00, 0x16, 0xe8, 0xde, 0xdc, 0xd7, 0x4f, 0xbf, 0xf8, 0xf2, 0xd3,
0xfa, 0xee, 0xf7, 0xa6, 0xbc, 0xa5, 0x5d, 0x46, 0x70, 0x71, 0x0b, 0x39, 0x77, 0xbf, 0x37, 0xe5, 0x2d, 0xed, 0x32, 0x82, 0x8b, 0x5b, 0xc8, 0x11,
0xa2, 0x21, 0xd2, 0xb2, 0xfa, 0xa5, 0x06, 0x1c, 0x7c, 0xb0, 0x52, 0x58, 0x0d, 0x91, 0x96, 0xd5, 0x2f, 0x35, 0xe0, 0xe0, 0x83, 0x95, 0xc2, 0xf2,
0x7e, 0xd8, 0x44, 0x01, 0x57, 0x53, 0xa6, 0x33, 0x01, 0x65, 0x94, 0xd5, 0xc3, 0x26, 0x0a, 0xb8, 0x9a, 0x32, 0x9d, 0x09, 0x28, 0xa3, 0xac, 0xd6,
0xda, 0x90, 0xbf, 0x96, 0xaf, 0xf3, 0x5a, 0x72, 0x6d, 0x7f, 0xf6, 0xed, 0x86, 0xfc, 0xb5, 0x7c, 0x9d, 0xd7, 0x92, 0x6b, 0xfb, 0xb3, 0x6f, 0x4f,
0x09, 0x47, 0x7b, 0x3e, 0x65, 0xf7, 0xe9, 0xa3, 0xd4, 0xfc, 0x66, 0xfa, 0x38, 0xda, 0xf3, 0x29, 0xbb, 0x4f, 0x1f, 0xa5, 0xe6, 0x37, 0xd3, 0x0f,
0xa1, 0x34, 0xae, 0x9d, 0xa6, 0x9a, 0x5d, 0x4f, 0x80, 0xd4, 0x76, 0xbe, 0xa5, 0x71, 0xed, 0x34, 0xd5, 0xec, 0x7a, 0x02, 0xa4, 0xb6, 0xf3, 0xb5,
0x56, 0x1d, 0x50, 0xeb, 0x18, 0x01, 0xdd, 0x90, 0xda, 0xe5, 0xbf, 0xa9, 0xea, 0x80, 0x5a, 0xc7, 0x08, 0xe8, 0x86, 0xd4, 0x2e, 0xff, 0x4d, 0x8d,
0x51, 0x6f, 0x70, 0x8d, 0x7a, 0xfa, 0xcd, 0xbf, 0xa6, 0x7a, 0x08, 0x1c, 0x7a, 0x83, 0x6b, 0xd4, 0xd3, 0x6f, 0xfe, 0x35, 0xd5, 0x43, 0xe0, 0xf0,
0x5e, 0xbf, 0x37, 0xc5, 0x08, 0xf1, 0xc1, 0x70, 0xb0, 0x37, 0xfc, 0xd7, 0xfa, 0xbd, 0x29, 0x46, 0x88, 0x0f, 0x86, 0x83, 0xbd, 0xe1, 0xbf, 0xa6,
0xd4, 0xb1, 0x49, 0x13, 0x1e, 0xec, 0x8a, 0x2a, 0x7e, 0x98, 0xa4, 0xf1, 0x8e, 0x4d, 0x9a, 0xf0, 0x60, 0x57, 0x54, 0xf1, 0xc3, 0x24, 0x8d, 0x47,
0x68, 0x77, 0x38, 0xfa, 0xd7, 0xd4, 0x92, 0x03, 0xd7, 0x3e, 0xcb, 0xfd, 0xbb, 0xc3, 0xd1, 0xbf, 0xa6, 0x96, 0x1c, 0xb8, 0xf6, 0x11, 0xee, 0xe7,
0xdc, 0x35, 0x40, 0xe0, 0xbf, 0xac, 0x0a, 0xce, 0x23, 0xd5, 0x66, 0x6b, 0xae, 0x01, 0x02, 0xff, 0x65, 0x55, 0x70, 0x9e, 0xa4, 0x36, 0x5b, 0x6b,
0xed, 0x36, 0xba, 0xef, 0xdf, 0x59, 0x9d, 0x9f, 0x37, 0x8a, 0x5e, 0xa4, 0xb7, 0xd1, 0x7d, 0xff, 0xce, 0xea, 0xfc, 0xbc, 0x51, 0xf4, 0x22, 0x35,
0x86, 0xca, 0x56, 0x12, 0x6c, 0xaa, 0x07, 0xae, 0x20, 0x1b, 0x20, 0x54, 0x54, 0xb6, 0x92, 0x60, 0x53, 0x3d, 0x70, 0x05, 0xd9, 0x00, 0xa1, 0x42,
0x28, 0xbd, 0xeb, 0xe6, 0xba, 0xa5, 0xb8, 0x53, 0xab, 0x80, 0x88, 0x66, 0xe9, 0x5d, 0x37, 0xd7, 0x2d, 0xc5, 0x9d, 0x5a, 0x05, 0x44, 0x34, 0x6b,
0x6d, 0x1c, 0x75, 0x8e, 0x59, 0xea, 0xa9, 0xbb, 0x8c, 0xaa, 0xda, 0xb5, 0xe3, 0xa8, 0x73, 0xcc, 0x52, 0x4f, 0xdd, 0x65, 0x54, 0xd5, 0xae, 0x05,
0xe0, 0x13, 0xf0, 0xda, 0x4d, 0xb8, 0x08, 0xb1, 0x29, 0x97, 0x9a, 0x46, 0x9f, 0x80, 0xd7, 0x6e, 0xc2, 0x45, 0x88, 0x4d, 0xb9, 0xd4, 0x34, 0xc2,
0x78, 0x27, 0xa9, 0x57, 0xc6, 0x4d, 0x64, 0x37, 0xa2, 0x05, 0x98, 0x1d, 0x3b, 0x49, 0xbd, 0x32, 0x6e, 0x22, 0xbb, 0x11, 0x2d, 0xc0, 0xec, 0xa0,
0xd4, 0xf1, 0x90, 0x07, 0xe1, 0xf1, 0xc9, 0xf7, 0x30, 0x47, 0x51, 0x62, 0x8e, 0x87, 0x3c, 0xff, 0x8e, 0x0f, 0xbc, 0x87, 0x39, 0x8a, 0x12, 0xc3,
0xb8, 0xf5, 0xa8, 0x08, 0xf5, 0x10, 0xe7, 0x54, 0x19, 0x42, 0x7e, 0x86, 0xad, 0x47, 0x45, 0xa8, 0x87, 0x38, 0xa7, 0xca, 0x10, 0xf2, 0x33, 0x2c,
0xc5, 0xdd, 0x29, 0x6f, 0x15, 0xa4, 0x32, 0x8d, 0xc1, 0x3b, 0xc8, 0xf0, 0xee, 0x4e, 0x79, 0xab, 0x20, 0x95, 0x69, 0x0c, 0xde, 0x41, 0x86, 0x17,
0x42, 0xc8, 0x45, 0x9c, 0x16, 0x40, 0x3a, 0x3b, 0xe6, 0xc1, 0xe8, 0xa1, 0x42, 0x2e, 0xe2, 0xb4, 0x00, 0xd2, 0xd9, 0x31, 0x0f, 0x46, 0x0f, 0x4d,
0xe9, 0x41, 0x1b, 0x79, 0x02, 0x1b, 0x20, 0xfc, 0x46, 0x0b, 0xdc, 0xd0, 0x0f, 0xda, 0xc8, 0x13, 0xd8, 0x00, 0xe1, 0x37, 0x5a, 0xe0, 0x86, 0x7e,
0x0f, 0xa1, 0x7f, 0xc2, 0x4a, 0xb2, 0x58, 0x63, 0xcb, 0x0c, 0xef, 0x55, 0x08, 0xfd, 0x13, 0x56, 0x92, 0xc5, 0x1a, 0x5b, 0x66, 0x78, 0xaf, 0xb2,
0x96, 0x8e, 0xe6, 0x80, 0x3a, 0xb8, 0xe2, 0xc2, 0xe5, 0x63, 0xd7, 0xb5, 0x74, 0x34, 0x07, 0xd4, 0xc1, 0x15, 0x17, 0x2e, 0x1f, 0xbb, 0xae, 0x6d,
0x2d, 0xf0, 0x51, 0xbb, 0x9e, 0x59, 0x5c, 0x75, 0xa2, 0x0b, 0xdc, 0xa2, 0x81, 0x8f, 0xda, 0xf5, 0xcc, 0xe2, 0xaa, 0x13, 0x5d, 0xe0, 0x16, 0x05,
0x40, 0x92, 0x9a, 0x25, 0x33, 0xd2, 0x1a, 0x9c, 0x2f, 0x5a, 0x78, 0xef, 0x92, 0xd4, 0x2c, 0x99, 0x91, 0xd6, 0xe0, 0x7c, 0xd1, 0xc2, 0x7b, 0x07,
0x00, 0x9e, 0x79, 0x54, 0xd6, 0x8b, 0xae, 0x0e, 0x5a, 0x7b, 0x68, 0xbc, 0xf0, 0xcc, 0xa3, 0xb2, 0x5e, 0x74, 0x75, 0xd0, 0xda, 0x43, 0xe3, 0x65,
0x0c, 0x34, 0x9c, 0x23, 0xe0, 0x3e, 0x2a, 0x64, 0x6a, 0x38, 0x81, 0xe0, 0xa0, 0xe1, 0x1c, 0x01, 0xf7, 0x51, 0x21, 0x53, 0xc3, 0x09, 0x04, 0x9f,
0x13, 0x6c, 0x45, 0x29, 0x2f, 0x62, 0x29, 0xea, 0xf0, 0x9d, 0xbd, 0xa1, 0x60, 0x2b, 0x4a, 0x79, 0x11, 0x4b, 0x51, 0x87, 0xef, 0xec, 0x0d, 0xc5,
0xd8, 0x73, 0x8e, 0x1e, 0x39, 0x29, 0x17, 0x4e, 0xca, 0xf4, 0xac, 0xab, 0x9e, 0x73, 0xf4, 0xc8, 0x49, 0xb9, 0x70, 0x52, 0xa6, 0x67, 0x5d, 0xcd,
0x59, 0xa2, 0xe0, 0xc3, 0x62, 0x8a, 0xa7, 0x1a, 0xa6, 0x46, 0x2e, 0x57, 0x12, 0x05, 0x1f, 0x16, 0x53, 0x3c, 0xd5, 0x30, 0x35, 0x72, 0xb9, 0x72,
0x6e, 0xd2, 0x85, 0x9b, 0x34, 0x1d, 0x85, 0x32, 0xb6, 0x57, 0xc2, 0x58, 0x93, 0x2e, 0xdc, 0xa4, 0xe9, 0x28, 0x94, 0xb1, 0xbd, 0x12, 0xc6, 0xea,
0x1d, 0x67, 0x7b, 0x2e, 0x67, 0x6e, 0xd2, 0x85, 0x9b, 0x34, 0xdd, 0x33, 0x38, 0xdb, 0x73, 0x39, 0x73, 0x93, 0x2e, 0xdc, 0xa4, 0xe9, 0x9e, 0xc1,
0x38, 0xbb, 0xc7, 0x4f, 0x1e, 0x0b, 0xc4, 0x78, 0x2a, 0xff, 0x58, 0x46, 0xd9, 0x3d, 0x7e, 0xf2, 0x58, 0x20, 0xc6, 0xc3, 0xf8, 0xc7, 0x32, 0x1a,
0x03, 0xa1, 0x3b, 0x3b, 0x93, 0xe5, 0xcf, 0x93, 0xaa, 0x69, 0xc2, 0x23, 0x08, 0xdd, 0xd9, 0x99, 0x2c, 0x7f, 0x9e, 0x54, 0x4d, 0x13, 0x1e, 0xf1,
0x5e, 0x27, 0x7a, 0xe4, 0xe1, 0x19, 0x87, 0xa6, 0x18, 0x72, 0xe2, 0xc2, 0x3a, 0xd1, 0x93, 0x0e, 0xcf, 0x38, 0x34, 0xc5, 0x90, 0x13, 0x17, 0x7e,
0x0f, 0xc6, 0xa8, 0x05, 0x6c, 0x9e, 0x81, 0xb8, 0xc7, 0x3c, 0x2d, 0x7a, 0x30, 0x46, 0x2d, 0x60, 0xf3, 0x0c, 0xc4, 0x3d, 0xe6, 0x69, 0xd1, 0xa3,
0x34, 0x9a, 0x13, 0x9c, 0x11, 0xf3, 0xe1, 0x6a, 0xbd, 0x5a, 0x02, 0x61, 0xd1, 0x9c, 0xe0, 0x8c, 0x98, 0x0f, 0x57, 0xeb, 0xd5, 0x12, 0x08, 0xf3,
0x5e, 0xef, 0x59, 0x21, 0x9e, 0x34, 0xce, 0x37, 0xe9, 0x92, 0x45, 0x9d, 0x7a, 0xcf, 0x0a, 0xf1, 0xa4, 0x71, 0xbe, 0x49, 0x97, 0x2c, 0xea, 0xec,
0x5d, 0x14, 0x0c, 0xb7, 0x14, 0x90, 0x3d, 0xc8, 0x57, 0x27, 0x79, 0x0a, 0xa2, 0x60, 0xb8, 0xa5, 0x80, 0xec, 0x41, 0xbe, 0x3a, 0xc9, 0x53, 0xb0,
0x36, 0x2d, 0x82, 0x40, 0xb1, 0x30, 0x02, 0x2f, 0x12, 0x98, 0xfa, 0xf4, 0x69, 0x11, 0x04, 0x8a, 0x85, 0x11, 0x78, 0x91, 0xc0, 0xd4, 0xa7, 0x3f,
0x47, 0x98, 0xfe, 0xf5, 0x7a, 0x0d, 0x1b, 0x2d, 0x93, 0x2c, 0x8e, 0x1c, 0xc2, 0xf4, 0xaf, 0xd7, 0x6b, 0xd8, 0x68, 0x99, 0x64, 0x71, 0xe4, 0x98,
0x33, 0xa4, 0x04, 0x0b, 0x5f, 0x9c, 0x22, 0x14, 0x0f, 0x12, 0x04, 0x36, 0x21, 0x25, 0x58, 0xf8, 0xe2, 0x14, 0xa1, 0x78, 0x90, 0x20, 0xb0, 0x59,
0xcb, 0xba, 0x50, 0xaa, 0x27, 0x63, 0x58, 0x96, 0x31, 0x2a, 0xcb, 0x80, 0xd6, 0x85, 0x52, 0x3d, 0x19, 0xc3, 0xb2, 0x8c, 0x51, 0x59, 0x06, 0x34,
0x06, 0x70, 0xf9, 0x59, 0x2d, 0x4f, 0xc8, 0x4c, 0x50, 0x1b, 0xf0, 0xb0, 0x80, 0xcb, 0xcf, 0x6a, 0x79, 0x42, 0x66, 0x82, 0xda, 0x80, 0x87, 0xb5,
0x76, 0x46, 0x37, 0x7b, 0xc1, 0xb3, 0x14, 0x69, 0x84, 0xc6, 0x59, 0xaf, 0x33, 0xba, 0xd9, 0x0b, 0x9e, 0xa5, 0x48, 0x23, 0x34, 0xce, 0x7a, 0x25,
0xa4, 0xd1, 0x25, 0xe4, 0xc1, 0x3a, 0xa5, 0xcf, 0xf7, 0xe3, 0xf3, 0xc9, 0x8d, 0x2e, 0x21, 0x0f, 0xd6, 0x29, 0x7d, 0xbe, 0x1f, 0x9f, 0x4f, 0x36,
0x66, 0x91, 0x93, 0x04, 0x14, 0x35, 0x0e, 0xa2, 0x5e, 0x15, 0xc9, 0x57, 0x8b, 0x9c, 0x24, 0xa0, 0xa8, 0x71, 0x10, 0xf5, 0x86, 0x48, 0xbe, 0xda,
0x9b, 0xd9, 0x25, 0xbe, 0x7f, 0xaa, 0x4c, 0x9c, 0xa4, 0x4b, 0x81, 0x08, 0xcc, 0x2e, 0xf1, 0xb5, 0x53, 0x65, 0xe2, 0x24, 0x5d, 0x0a, 0x44, 0x28,
0x05, 0xfc, 0x24, 0x85, 0xb6, 0x53, 0x76, 0x0e, 0xcb, 0x84, 0x4c, 0xcb, 0xe0, 0x27, 0x29, 0xb4, 0x9d, 0xb2, 0x73, 0x58, 0x26, 0x64, 0x5a, 0x6e,
0x4d, 0xba, 0x39, 0x64, 0x9f, 0x4d, 0xf2, 0xcb, 0x01, 0x39, 0x40, 0x91, 0xd2, 0xcd, 0x21, 0xfb, 0x6c, 0x92, 0x5f, 0x0e, 0xc8, 0x01, 0x8a, 0x74,
0x8e, 0xf9, 0x14, 0x4b, 0xa1, 0x8d, 0xc7, 0xc1, 0x1a, 0x26, 0xb7, 0xdf, 0xcc, 0xa7, 0x58, 0x0a, 0x6d, 0x3c, 0x0e, 0xd6, 0x30, 0xb9, 0xfd, 0x8e,
0xb1, 0x3e, 0x50, 0x1f, 0x80, 0x61, 0x05, 0xd3, 0xf2, 0x69, 0x7c, 0x9e, 0xf5, 0x81, 0xfa, 0x00, 0x0c, 0x2b, 0x98, 0x96, 0x4f, 0xe3, 0xf3, 0xbc,
0x77, 0x7b, 0x26, 0xa5, 0xdb, 0x50, 0x4a, 0xdf, 0x2b, 0x4a, 0x98, 0xb7, 0xdb, 0x33, 0x29, 0xdd, 0x86, 0x52, 0xfa, 0x5e, 0x51, 0xc2, 0xbc, 0x75,
0xee, 0x6a, 0xa6, 0x58, 0xaa, 0x7a, 0x79, 0xe5, 0x29, 0x9c, 0x15, 0x56, 0x57, 0x33, 0xc5, 0x52, 0xd5, 0xcb, 0x2b, 0x4f, 0xe1, 0xac, 0xb0, 0xe2,
0xbc, 0x45, 0xc5, 0x78, 0x91, 0xdf, 0x85, 0x70, 0xce, 0x41, 0xbf, 0xf7, 0x2d, 0x2a, 0xc6, 0x8b, 0xfc, 0x2e, 0x84, 0x73, 0x0e, 0xfa, 0xbd, 0x9f,
0xf3, 0xa6, 0xda, 0x51, 0x04, 0x42, 0x15, 0xdd, 0x86, 0x7a, 0xda, 0x93, 0x37, 0xd5, 0x8e, 0x22, 0x10, 0xaa, 0xe8, 0x36, 0xd4, 0xd3, 0x9e, 0x5c,
0x2b, 0xa8, 0xe3, 0xfb, 0xd0, 0xfe, 0x11, 0xf0, 0x35, 0xb8, 0xe9, 0x31, 0x41, 0x1d, 0xdf, 0x87, 0xf6, 0x8f, 0x80, 0xaf, 0xc1, 0x4d, 0x8f, 0xe1,
0xfc, 0xb8, 0x85, 0xbb, 0x65, 0xf0, 0x5f, 0x97, 0x2e, 0x61, 0x21, 0x21, 0xc7, 0x2d, 0xdc, 0x2d, 0x83, 0xff, 0xba, 0x74, 0x09, 0x0b, 0x09, 0xa9,
0x15, 0xd1, 0xf9, 0x99, 0xa0, 0xa1, 0x94, 0x9c, 0x12, 0xac, 0x38, 0x98, 0x88, 0xce, 0xcf, 0x04, 0x0d, 0xa5, 0xe4, 0x94, 0x60, 0xc5, 0xc1, 0x24,
0x64, 0x80, 0xfc, 0xf6, 0x9b, 0xc2, 0x1e, 0x61, 0xbc, 0x23, 0x33, 0x93, 0x03, 0xe4, 0xb7, 0xdf, 0x14, 0xf6, 0x08, 0xe3, 0x1d, 0x99, 0x99, 0x1c,
0xe3, 0x5b, 0x06, 0xe5, 0xb4, 0x03, 0x25, 0x42, 0x8f, 0x14, 0x24, 0xcf, 0xdf, 0x32, 0x28, 0xa7, 0x1d, 0x28, 0x11, 0x7a, 0xa4, 0x20, 0x79, 0xc6,
0xd8, 0x58, 0xb1, 0x50, 0x82, 0x90, 0x9a, 0xe0, 0xea, 0xf6, 0x83, 0x17, 0xc6, 0x8a, 0x85, 0x12, 0x84, 0xd4, 0x04, 0x57, 0xb7, 0x1f, 0xbc, 0xd0,
0xfa, 0xc2, 0x07, 0x3d, 0x2c, 0x83, 0x9e, 0xfa, 0xa0, 0x47, 0x65, 0xd0, 0x17, 0x3e, 0xe8, 0x61, 0x19, 0xf4, 0xd4, 0x07, 0x3d, 0x2a, 0x83, 0xbe,
0xd7, 0x1a, 0xb4, 0x1a, 0xc3, 0xd5, 0x79, 0x58, 0x93, 0x3b, 0xeb, 0xc8, 0xd6, 0xa0, 0xd5, 0x18, 0xae, 0xce, 0xc3, 0x9a, 0xdc, 0x59, 0x47, 0x5e,
0xab, 0xcb, 0x8c, 0x3a, 0xd5, 0xea, 0x16, 0xed, 0x9e, 0xe5, 0x71, 0xb7, 0x5d, 0x66, 0xd4, 0xa9, 0x56, 0xb7, 0x68, 0xf7, 0x2c, 0x8f, 0xbb, 0x95,
0x52, 0xb1, 0x85, 0x2a, 0xb7, 0x89, 0xfd, 0x1b, 0xbe, 0xde, 0xad, 0x67, 0x8a, 0x2d, 0x54, 0xb9, 0x4d, 0xec, 0xdf, 0xf0, 0xf5, 0x6e, 0x3d, 0x5b,
0x6b, 0xc3, 0xc3, 0x7d, 0x6e, 0xc7, 0x30, 0x2f, 0x42, 0xdb, 0x8c, 0x4e, 0x1b, 0x1e, 0xee, 0xe3, 0x3a, 0x86, 0x79, 0x11, 0xda, 0x66, 0x74, 0x02,
0x20, 0x35, 0x90, 0x6e, 0xe8, 0x7e, 0x85, 0x21, 0x14, 0x76, 0x7b, 0x0c, 0xa9, 0x81, 0x74, 0x43, 0xf7, 0x2b, 0x0c, 0xa1, 0xb0, 0xdb, 0x63, 0xf0,
0xfe, 0x13, 0x66, 0xfc, 0x3a, 0x99, 0xe7, 0x97, 0xc5, 0xaf, 0xcb, 0x18, 0x9f, 0x30, 0xe3, 0xd7, 0xc9, 0x3c, 0xbf, 0x2c, 0x7e, 0x5d, 0xc6, 0xe8,
0xfd, 0x06, 0x6d, 0x60, 0x91, 0xb4, 0x43, 0x1e, 0x33, 0xd2, 0x4b, 0x25, 0x37, 0x68, 0x03, 0x8b, 0xa4, 0x1d, 0xf2, 0x74, 0x91, 0x5e, 0x2a, 0xb1,
0x36, 0x29, 0x1d, 0xaa, 0xe1, 0x3a, 0x6e, 0x0a, 0xe8, 0x5b, 0x1c, 0x6c, 0x49, 0xe9, 0x50, 0x0d, 0xd7, 0x71, 0x53, 0x40, 0xdf, 0xe2, 0x60, 0x13,
0x22, 0xad, 0xc4, 0xa2, 0xd0, 0x9d, 0x57, 0x5f, 0x15, 0xa0, 0xaf, 0xb2, 0x69, 0x25, 0x16, 0x85, 0xee, 0xbc, 0xfa, 0xaa, 0x00, 0x7d, 0x95, 0xbd,
0xf7, 0x01, 0x32, 0x13, 0x9d, 0x0a, 0x47, 0x09, 0x99, 0xb1, 0xa3, 0x64, 0x0f, 0x90, 0x99, 0xe8, 0x54, 0x38, 0x4a, 0xc8, 0x8c, 0x1d, 0x25, 0x1b,
0xa3, 0x51, 0x33, 0x2c, 0xea, 0x2c, 0x86, 0xfa, 0xa7, 0xdf, 0xb1, 0xb1, 0x8d, 0x9a, 0x61, 0x51, 0x67, 0x31, 0xd4, 0x3f, 0xfd, 0x8e, 0x8d, 0x8d,
0x51, 0x63, 0xb6, 0xc3, 0x46, 0x47, 0x36, 0xd0, 0xf7, 0x00, 0x64, 0x08, 0x1a, 0xb3, 0x1d, 0x36, 0x3a, 0xb2, 0x81, 0xbe, 0x07, 0x20, 0x43, 0x10,
0x42, 0x42, 0xb9, 0xf7, 0x18, 0x05, 0xd5, 0x9e, 0xc4, 0x0c, 0x92, 0x27, 0x12, 0xca, 0xbd, 0xc7, 0x28, 0xa8, 0xf6, 0x24, 0x66, 0x90, 0x3c, 0xb1,
0x96, 0x44, 0xd7, 0xc4, 0xbf, 0x82, 0x8d, 0xd7, 0x4d, 0xe6, 0xb2, 0xf4, 0x24, 0xba, 0x26, 0xfe, 0x15, 0x6c, 0xbc, 0x6e, 0x32, 0x97, 0xa5, 0xc7,
0x78, 0xb0, 0xaf, 0x81, 0xc2, 0xce, 0xab, 0x06, 0x1a, 0x19, 0xb0, 0x7d, 0x83, 0x7d, 0x0d, 0x14, 0x76, 0x5e, 0x35, 0xd0, 0xc8, 0x80, 0xed, 0xb3,
0x36, 0xdc, 0xed, 0x9a, 0xec, 0x11, 0x38, 0x9b, 0xae, 0x52, 0x50, 0x38, 0xe1, 0x6e, 0xd7, 0x64, 0x8f, 0xc0, 0xd9, 0x74, 0x95, 0x82, 0xc2, 0x61,
0x4c, 0x54, 0x4d, 0x3f, 0x8d, 0x2f, 0x92, 0xe5, 0x97, 0x60, 0xc9, 0xa2, 0xa2, 0x6a, 0xfa, 0x69, 0x7c, 0x91, 0x2c, 0xbf, 0x04, 0x4b, 0x16, 0x75,
0xae, 0x0d, 0xce, 0xdb, 0xce, 0x04, 0x9f, 0xa4, 0x33, 0xb7, 0x7e, 0x3a, 0x6d, 0x70, 0xde, 0x76, 0x26, 0xf8, 0x24, 0x9d, 0xb9, 0xf5, 0xd3, 0xb9,
0x37, 0xa4, 0x3f, 0x23, 0x68, 0x16, 0xb2, 0x8e, 0x5f, 0x3e, 0xe9, 0xf1, 0x21, 0xfd, 0x19, 0x41, 0xb3, 0x90, 0x75, 0xfc, 0xf2, 0x49, 0x8f, 0xef,
0xfd, 0x4f, 0x45, 0x9c, 0xda, 0x02, 0x6f, 0xbf, 0x1a, 0x4c, 0x1d, 0xb2, 0x7f, 0x2a, 0xe2, 0xd4, 0x16, 0x78, 0xfb, 0xd5, 0x60, 0xea, 0x90, 0x45,
0x08, 0xcc, 0x60, 0x46, 0x99, 0x4b, 0x36, 0x21, 0xab, 0x8a, 0x40, 0x82, 0x60, 0x06, 0x33, 0xca, 0x5c, 0xb2, 0x09, 0x59, 0x55, 0x04, 0x12, 0x4c,
0x89, 0x17, 0xba, 0x26, 0x1b, 0x8b, 0x64, 0x19, 0x7f, 0x4b, 0x95, 0x1d, 0xbc, 0xd0, 0x35, 0xd9, 0x58, 0x24, 0xcb, 0xf8, 0x5b, 0xaa, 0xec, 0x98,
0xb3, 0xc7, 0x47, 0x66, 0x1e, 0xbf, 0xbd, 0x7f, 0x82, 0xf3, 0x74, 0xc8, 0x3d, 0x3e, 0x32, 0xf3, 0xf8, 0xed, 0xfd, 0x13, 0x9c, 0xa7, 0x43, 0x6e,
0xed, 0xbc, 0xb8, 0x4b, 0x7f, 0x1d, 0x2f, 0x54, 0xd4, 0xb5, 0x92, 0xe9, 0xe7, 0xc5, 0x5d, 0xfa, 0xeb, 0x78, 0xa1, 0xa2, 0xae, 0x95, 0x4c, 0x57,
0x8a, 0x7b, 0x21, 0x8e, 0x82, 0xe7, 0xf3, 0x64, 0xb1, 0xe0, 0x41, 0xdf, 0xdc, 0x0b, 0x71, 0x14, 0x3c, 0x9f, 0x27, 0x8b, 0x05, 0x0f, 0xfa, 0x36,
0xa6, 0xf1, 0x64, 0x93, 0x27, 0xe7, 0x9b, 0x85, 0x8c, 0xb5, 0x2b, 0x41, 0x8d, 0x27, 0x9b, 0x3c, 0x39, 0xdf, 0x2c, 0x64, 0xac, 0x5d, 0x09, 0x92,
0xf2, 0xc9, 0x8f, 0xf1, 0x92, 0xee, 0xde, 0xd2, 0xd9, 0x9c, 0x43, 0x76, 0x4f, 0x7e, 0x8c, 0x97, 0x74, 0xf7, 0x96, 0xce, 0xe6, 0x1c, 0xb2, 0xcb,
0x99, 0xe7, 0x6b, 0x88, 0xda, 0x94, 0xe5, 0xb0, 0x56, 0x00, 0xe3, 0x6e, 0x3c, 0x5f, 0x43, 0xd4, 0xa6, 0x2c, 0x87, 0xb5, 0x02, 0x18, 0x77, 0xd3,
0x7a, 0xbe, 0x58, 0x5d, 0x83, 0x55, 0xba, 0xda, 0xf9, 0x69, 0x13, 0x67, 0xf3, 0xc5, 0xea, 0x1a, 0xac, 0xd2, 0xd5, 0xce, 0x4f, 0x9b, 0x38, 0xa3,
0xb4, 0x71, 0xba, 0x33, 0x7c, 0x63, 0x74, 0xb0, 0xff, 0xc6, 0xee, 0xe3, 0x8d, 0xd3, 0x9d, 0xe1, 0x1b, 0xa3, 0x83, 0xfd, 0x37, 0x76, 0x1f, 0xef,
0x9d, 0xe9, 0x26, 0x59, 0xe0, 0x7e, 0x7b, 0x7f, 0xd2, 0x27, 0xb2, 0x7d, 0x4c, 0x37, 0xc9, 0x02, 0xf7, 0xdb, 0xfb, 0x93, 0x3e, 0x91, 0xed, 0x93,
0xf2, 0xb3, 0xfa, 0xc9, 0xb2, 0x7f, 0x99, 0x5f, 0x2d, 0xf6, 0xad, 0x77, 0x9f, 0xd5, 0x4f, 0x96, 0xfd, 0xcb, 0xfc, 0x6a, 0xb1, 0x6f, 0xbd, 0x72,
0xef, 0xc0, 0x38, 0x2c, 0xb8, 0x89, 0x11, 0x5f, 0xdf, 0x02, 0x27, 0xf3, 0x07, 0xc6, 0x61, 0xc1, 0x4d, 0x8c, 0xf8, 0xfa, 0x16, 0x38, 0x99, 0x07,
0xa0, 0xf8, 0xf5, 0x9a, 0xe5, 0x9f, 0xab, 0x67, 0x90, 0xdf, 0x15, 0x88, 0xc5, 0xaf, 0xd7, 0x2c, 0xff, 0x5c, 0x3d, 0x7a, 0xfc, 0xae, 0x40, 0x8c,
0x11, 0x07, 0xec, 0x83, 0xcf, 0xac, 0x5a, 0x0a, 0x34, 0x66, 0xf8, 0x86, 0x38, 0x60, 0x1f, 0x7c, 0x66, 0xd5, 0x52, 0xa0, 0x31, 0xc3, 0x37, 0xec,
0x1d, 0x7d, 0x1f, 0x3c, 0x55, 0x89, 0x44, 0x38, 0xa5, 0xe0, 0x7e, 0x8d, 0xe8, 0xfb, 0xe0, 0xa9, 0x4a, 0x24, 0xc2, 0x29, 0x05, 0xf7, 0x6b, 0x94,
0x72, 0x73, 0xd1, 0x05, 0x79, 0xba, 0x72, 0x74, 0x48, 0x82, 0xda, 0xba, 0x9b, 0x8b, 0x2e, 0xc8, 0xd3, 0x95, 0xa3, 0x43, 0x12, 0xd4, 0xd6, 0x35,
0x66, 0x0e, 0xba, 0x12, 0xcb, 0x4d, 0x05, 0x12, 0x66, 0xaa, 0xae, 0x93, 0x73, 0xd0, 0x95, 0x58, 0x6e, 0x2a, 0x90, 0x30, 0x53, 0x75, 0x9d, 0xb4,
0x56, 0x8e, 0x12, 0x85, 0x95, 0x01, 0x95, 0xf5, 0x25, 0x93, 0x02, 0xab, 0x72, 0x94, 0x28, 0xac, 0x0c, 0xa8, 0xac, 0x2f, 0x99, 0x14, 0x58, 0x25,
0x24, 0xc5, 0xaa, 0x5f, 0x6d, 0xdc, 0x5c, 0xd4, 0x9e, 0x42, 0x1f, 0x2f, 0x29, 0x56, 0xfd, 0x6a, 0xe3, 0xe6, 0xa2, 0xf6, 0x14, 0xfa, 0x78, 0x99,
0xb3, 0x45, 0x04, 0x63, 0x92, 0x6c, 0x2b, 0xdc, 0xf7, 0xc6, 0xc0, 0x15, 0x2d, 0x22, 0x18, 0x93, 0x64, 0x5b, 0xe1, 0xbe, 0x37, 0x06, 0xae, 0xc0,
0x78, 0x20, 0xe1, 0xe5, 0x6e, 0xa7, 0x04, 0x3b, 0x0a, 0x2b, 0xf4, 0x5e, 0x03, 0x09, 0x2f, 0x77, 0x3b, 0x25, 0xd8, 0x51, 0x58, 0xa1, 0xf7, 0x4a,
0xa9, 0x2c, 0x1a, 0x93, 0x26, 0x5d, 0x3e, 0xbf, 0x4c, 0xb2, 0x41, 0x75, 0x65, 0xd1, 0x98, 0x34, 0xe9, 0xf2, 0xf9, 0x65, 0x92, 0x0d, 0xaa, 0x7b,
0x2f, 0x4f, 0xb9, 0x30, 0x75, 0xf9, 0x29, 0x91, 0x01, 0xf5, 0x0d, 0xc2, 0x79, 0xca, 0x85, 0xa9, 0xcb, 0x4f, 0x89, 0x0c, 0xa8, 0x6f, 0x10, 0xee,
0x1d, 0x2f, 0xe0, 0x12, 0xfa, 0x75, 0x82, 0x3d, 0x3e, 0xc4, 0x72, 0x00, 0x78, 0x01, 0x97, 0xd0, 0xaf, 0x13, 0xec, 0xf1, 0x21, 0x96, 0x03, 0xb8,
0x97, 0xe1, 0x96, 0x03, 0x25, 0x81, 0x46, 0x41, 0xa0, 0x2b, 0x6b, 0x78, 0x0c, 0xb7, 0x1c, 0x28, 0x09, 0x34, 0x0a, 0x02, 0x5d, 0x59, 0xc3, 0xab,
0x75, 0xfb, 0xec, 0x02, 0xb9, 0x83, 0x64, 0xe5, 0x57, 0x89, 0x67, 0x1e, 0xdb, 0x67, 0x17, 0xc8, 0x1d, 0x24, 0x2b, 0xbf, 0x4a, 0x3c, 0xea, 0xf8,
0x3f, 0x05, 0x53, 0x31, 0x49, 0x3f, 0xe2, 0xd9, 0x72, 0x80, 0x1b, 0xbe, 0x29, 0x98, 0x8a, 0x49, 0xfa, 0x11, 0xcf, 0x96, 0x03, 0xdc, 0xf0, 0x75,
0x8e, 0x9f, 0x92, 0xb4, 0x42, 0xa7, 0x97, 0x7c, 0xf8, 0xd5, 0xae, 0x7c, 0xfc, 0x94, 0xa4, 0x15, 0x3a, 0xbd, 0xe4, 0xc3, 0xaf, 0x76, 0xe5, 0xab,
0xb5, 0x46, 0x60, 0xd8, 0x8f, 0xc6, 0x47, 0x70, 0x6a, 0x41, 0xc1, 0x53, 0x35, 0x02, 0xc3, 0x7e, 0x34, 0x3e, 0x82, 0x53, 0x0b, 0x0a, 0x9e, 0x9a,
0x93, 0xfb, 0xcf, 0x64, 0x38, 0x4a, 0xda, 0x5f, 0x27, 0x70, 0x54, 0x0a, 0xdc, 0x7f, 0x26, 0xc3, 0x51, 0xd2, 0xfe, 0x3a, 0x81, 0xa3, 0x52, 0x28,
0x25, 0x49, 0x01, 0x84, 0x57, 0x13, 0x1c, 0x5b, 0x2a, 0x5a, 0x1b, 0xcd, 0x49, 0x0a, 0x20, 0xbc, 0x9a, 0xe0, 0xd8, 0x52, 0xd1, 0xda, 0x68, 0x16,
0x62, 0xb9, 0xa1, 0x1c, 0x6d, 0xcf, 0x50, 0xd6, 0x0e, 0xcc, 0xdc, 0x8c, 0xcb, 0x0d, 0xe5, 0x68, 0x7b, 0x86, 0xb2, 0x76, 0x60, 0xe6, 0x66, 0xdc,
0xfb, 0x87, 0x66, 0xe5, 0x0d, 0x48, 0xa3, 0xb5, 0x88, 0x73, 0xa1, 0x6d, 0x3f, 0x34, 0x2b, 0x6f, 0x40, 0x1a, 0xad, 0x45, 0x9c, 0x0b, 0x6d, 0xf3,
0xbe, 0xa1, 0x59, 0xc1, 0x24, 0xe8, 0x36, 0x3b, 0x2d, 0xae, 0x9c, 0x69, 0x0d, 0xcd, 0x0a, 0x26, 0x41, 0xb7, 0xd9, 0x69, 0x71, 0xe5, 0x4c, 0x83,
0xd0, 0xa6, 0x42, 0x6b, 0xd5, 0xf7, 0xae, 0xa2, 0x40, 0xee, 0x2f, 0x10, 0x36, 0x15, 0x5a, 0xab, 0xbe, 0x77, 0x15, 0x05, 0x72, 0x7f, 0x81, 0x00,
0x20, 0x42, 0xd2, 0xcf, 0xd6, 0xac, 0x2d, 0x82, 0xdc, 0x40, 0x7e, 0x9f, 0x11, 0x92, 0x7e, 0xb6, 0x66, 0x6d, 0x11, 0xe4, 0x06, 0xf2, 0xfb, 0x1c,
0x63, 0x1e, 0xc1, 0x8f, 0xb7, 0x58, 0xf1, 0xdd, 0xdc, 0x7f, 0x57, 0x18, 0xf3, 0x08, 0x7e, 0xbc, 0xc5, 0x8a, 0xef, 0xe6, 0xfe, 0xbb, 0xc2, 0xb8,
0xb7, 0x3a, 0xc6, 0xad, 0x86, 0x71, 0x6b, 0x61, 0x48, 0x2e, 0x4e, 0x53, 0xd5, 0x31, 0x6e, 0x35, 0x8c, 0x5b, 0x0b, 0x43, 0x72, 0x71, 0x9a, 0x82,
0xf0, 0xf8, 0x2f, 0x13, 0x74, 0x50, 0x6f, 0x6e, 0x47, 0xeb, 0xd5, 0x62, 0xc7, 0x7f, 0x99, 0xa0, 0x83, 0x7a, 0x73, 0x3b, 0x5a, 0xaf, 0x16, 0x93,
0x92, 0x46, 0x30, 0x09, 0xb8, 0x45, 0x4e, 0x3d, 0x91, 0x10, 0xd8, 0xdb, 0x34, 0x82, 0x49, 0xc0, 0x2d, 0x72, 0xea, 0x89, 0x84, 0xc0, 0xde, 0x16,
0x82, 0xa2, 0x22, 0x66, 0x45, 0x7d, 0xfe, 0x31, 0x59, 0x53, 0x98, 0x67, 0x14, 0x15, 0x31, 0x2b, 0xea, 0xf3, 0x8f, 0xc9, 0x9a, 0xc2, 0x3c, 0x03,
0xa0, 0x72, 0xdb, 0x05, 0xf1, 0x80, 0x15, 0x48, 0x96, 0x20, 0x9a, 0x0c, 0x95, 0xdb, 0x2e, 0x88, 0x07, 0xac, 0x40, 0xb2, 0x04, 0xd1, 0x64, 0xa0,
0x94, 0x65, 0x92, 0xc3, 0xf8, 0x4a, 0xa3, 0x6f, 0x96, 0xcc, 0xe1, 0xf3, 0x2c, 0x93, 0x1c, 0xc6, 0x57, 0x1a, 0x7d, 0xb3, 0x64, 0x0e, 0x9f, 0xe7,
0x5c, 0x1b, 0x67, 0xbd, 0x07, 0xdb, 0xc0, 0xb5, 0xdb, 0x78, 0x0e, 0x30, 0xda, 0x38, 0xeb, 0x3d, 0xd8, 0x06, 0xae, 0xdd, 0xc6, 0x73, 0x80, 0xc9,
0xb9, 0xd5, 0x98, 0xd3, 0x1d, 0x0f, 0x60, 0x6d, 0x04, 0xdf, 0x22, 0xa8, 0xad, 0xc6, 0x9c, 0xee, 0x78, 0x00, 0x6b, 0x23, 0xf8, 0x16, 0x41, 0x85,
0x90, 0xc3, 0x3f, 0xad, 0xc7, 0x25, 0x17, 0x1b, 0x5e, 0x3e, 0x15, 0x4c, 0x1c, 0xfe, 0x69, 0x3d, 0x2e, 0xb9, 0xd8, 0xf0, 0xf2, 0xa9, 0x60, 0xb2,
0xd6, 0x04, 0x8f, 0x9a, 0xd1, 0x22, 0x25, 0x67, 0x27, 0xc9, 0xd8, 0x3a, 0x26, 0x78, 0xd4, 0x8c, 0x16, 0x29, 0x39, 0x3b, 0x49, 0xc6, 0xd6, 0xc9,
0xb9, 0x89, 0x17, 0x90, 0x46, 0x30, 0xd4, 0x3c, 0xbc, 0xad, 0x28, 0x20, 0x4d, 0xbc, 0x80, 0x34, 0x82, 0xa1, 0xe6, 0xe1, 0x6d, 0x45, 0x01, 0x79,
0xcf, 0xc0, 0x2d, 0x3b, 0x5d, 0x5d, 0x7f, 0xca, 0xcf, 0x9d, 0x8e, 0xb5, 0x06, 0x6e, 0xd9, 0xe9, 0xea, 0xfa, 0x53, 0x7e, 0xee, 0x74, 0xac, 0x35,
0xa6, 0x3e, 0x72, 0x01, 0x27, 0xf3, 0x1f, 0x36, 0x59, 0x1e, 0xcf, 0xc1, 0xf5, 0x91, 0x0b, 0x38, 0x99, 0xff, 0xb0, 0xc9, 0xf2, 0x78, 0x0e, 0x5e,
0xeb, 0x83, 0xd6, 0x7c, 0x4d, 0x02, 0x0a, 0x27, 0x0e, 0xc6, 0x69, 0x68, 0x1f, 0xb4, 0xe6, 0x6b, 0x12, 0x50, 0x38, 0x71, 0x30, 0x4e, 0x43, 0x8b,
0x71, 0x3e, 0x8c, 0x9f, 0xf6, 0xf7, 0x29, 0xa8, 0xeb, 0x19, 0x86, 0xd4, 0xf3, 0x61, 0xfc, 0xb4, 0xbf, 0x4f, 0x41, 0x5d, 0xcf, 0x30, 0xa4, 0xce,
0x39, 0xdd, 0x45, 0x3b, 0x0d, 0xdf, 0x23, 0x60, 0x48, 0x97, 0x28, 0x70, 0xe9, 0x2e, 0xda, 0x69, 0xf8, 0x1e, 0x01, 0x43, 0xba, 0x44, 0x81, 0x63,
0xec, 0xe5, 0xb1, 0x5b, 0x5e, 0x34, 0xfa, 0x92, 0xb7, 0xfe, 0xa2, 0x6f, 0x2f, 0x8f, 0xdd, 0xf2, 0xa2, 0xd1, 0x97, 0xbc, 0xf5, 0x17, 0x7d, 0xbb,
0xb7, 0x54, 0x34, 0x89, 0x53, 0x79, 0x4c, 0x58, 0x64, 0x0c, 0xcb, 0xc8, 0xa5, 0xa2, 0x49, 0x9c, 0xca, 0x63, 0xc2, 0x22, 0x63, 0x58, 0x46, 0x16,
0x42, 0xcc, 0x69, 0xfc, 0xd3, 0x26, 0x49, 0x81, 0xe0, 0x63, 0x96, 0x2d, 0x62, 0x4e, 0xe3, 0x9f, 0x36, 0x49, 0x0a, 0x04, 0x1f, 0xb3, 0x6c, 0xb1,
0x56, 0x79, 0x26, 0xe5, 0xae, 0x48, 0xba, 0x14, 0xa9, 0xb9, 0xc8, 0x97, 0xca, 0x33, 0x29, 0x77, 0x45, 0xd2, 0xa5, 0x48, 0xcd, 0x45, 0xbe, 0x84,
0x90, 0x02, 0x85, 0x1a, 0x45, 0xaa, 0x8a, 0xaf, 0xaa, 0x26, 0xe9, 0xa2, 0x14, 0x28, 0xd4, 0x28, 0x52, 0x55, 0x7c, 0x55, 0x35, 0x49, 0x17, 0xbd,
0x97, 0xa1, 0x38, 0x38, 0xf2, 0xe9, 0xce, 0x25, 0x4d, 0x9a, 0x40, 0x6f, 0x0c, 0xc5, 0xc1, 0x91, 0x4f, 0x77, 0x2e, 0x69, 0xd2, 0x04, 0x7a, 0xe3,
0x3c, 0x4d, 0x96, 0x4d, 0x60, 0xd1, 0x66, 0x22, 0x22, 0xb9, 0xa5, 0x6c, 0x69, 0xb2, 0x6c, 0x02, 0x8b, 0x36, 0x13, 0x11, 0xc9, 0x2d, 0x65, 0x3b,
0xa7, 0xbc, 0x71, 0xe5, 0xe4, 0x6b, 0x38, 0xd8, 0xf5, 0x96, 0x72, 0x0a, 0xe5, 0x8d, 0x2b, 0x27, 0x5f, 0xc3, 0xc1, 0xae, 0xb7, 0x94, 0x53, 0x98,
0x93, 0xa4, 0x1e, 0x9f, 0xe1, 0xf5, 0x68, 0x2e, 0x47, 0x93, 0xd9, 0xec, 0x24, 0xf5, 0xf8, 0x0c, 0xaf, 0x47, 0x73, 0x39, 0x9a, 0xcc, 0x66, 0x3f,
0xe7, 0x11, 0xcc, 0xa3, 0x23, 0x60, 0xa1, 0xa7, 0x95, 0xd5, 0xe3, 0xd4, 0x8f, 0x60, 0x1e, 0x1d, 0x01, 0x0b, 0x3d, 0xad, 0xac, 0x1e, 0xa7, 0xd6,
0xba, 0x3e, 0x1d, 0x5a, 0xac, 0x2f, 0x27, 0xa8, 0x68, 0xfb, 0xfb, 0x76, 0xf5, 0xe9, 0xd0, 0x62, 0x7d, 0x39, 0x41, 0x45, 0xdb, 0xdf, 0xb7, 0x8b,
0x31, 0x24, 0xb3, 0x53, 0x12, 0x0e, 0xd2, 0x86, 0xf2, 0x8e, 0xca, 0xf2, 0x21, 0x99, 0x9d, 0x92, 0x70, 0x90, 0x36, 0x94, 0x77, 0x54, 0x96, 0x0f,
0x41, 0x5e, 0x43, 0x80, 0xe1, 0xec, 0x54, 0x41, 0x8d, 0x00, 0x8a, 0xb8, 0xf2, 0x1a, 0x02, 0x0c, 0x67, 0xa7, 0x0a, 0x6a, 0x04, 0x50, 0xc4, 0x6d,
0xad, 0x02, 0xda, 0x03, 0x20, 0xce, 0x58, 0xd9, 0x32, 0xb5, 0x39, 0xc6, 0x15, 0xd0, 0x1e, 0x00, 0x71, 0xc6, 0xca, 0x96, 0xa9, 0xcd, 0x31, 0x7e,
0xaf, 0x37, 0xda, 0xaa, 0x03, 0x69, 0x10, 0x8d, 0x8c, 0xbb, 0xd6, 0xa2, 0xbd, 0xd1, 0x56, 0x1d, 0x48, 0x83, 0x68, 0x64, 0xdc, 0xb5, 0x16, 0x85,
0xb0, 0x69, 0x90, 0x4c, 0x0b, 0x0d, 0x05, 0xd2, 0x58, 0x9d, 0xfd, 0x94, 0x4d, 0x83, 0x64, 0x5a, 0x68, 0x28, 0x90, 0xc6, 0xea, 0xec, 0xa7, 0x34,
0xe6, 0xd1, 0x0d, 0xb4, 0x31, 0xf2, 0x71, 0x0b, 0x9f, 0xb7, 0xba, 0x89, 0x8f, 0x6e, 0xa0, 0x8d, 0x91, 0x8f, 0x5b, 0xf8, 0xbc, 0xd5, 0x4d, 0x2c,
0x05, 0x3b, 0x20, 0x01, 0xa1, 0xa8, 0xe5, 0x28, 0x82, 0x75, 0x8d, 0x1b, 0xd8, 0x01, 0x09, 0x08, 0x45, 0x2d, 0x47, 0x11, 0xac, 0x6b, 0xdc, 0x10,
0x02, 0x50, 0xeb, 0x71, 0xd2, 0x00, 0x5a, 0x65, 0x4b, 0x53, 0x02, 0x9f, 0x80, 0x5a, 0x8f, 0x93, 0x06, 0xd0, 0x2a, 0x5b, 0x9a, 0x12, 0xf8, 0xd4,
0x7a, 0x30, 0x60, 0xf8, 0x09, 0xea, 0x07, 0x9d, 0xe4, 0x8f, 0xdf, 0x7b, 0x83, 0x01, 0xc3, 0x4f, 0x50, 0x3f, 0xe8, 0x24, 0x7f, 0xfc, 0xde, 0x63,
0xec, 0x8f, 0xdf, 0xcf, 0x20, 0x01, 0xa6, 0xcb, 0x32, 0x5b, 0xd2, 0x04, 0x7f, 0xfc, 0x7e, 0x06, 0x09, 0x30, 0x5d, 0x96, 0xd9, 0x92, 0x26, 0x20,
0x44, 0x10, 0x2c, 0x01, 0x42, 0xbd, 0xc0, 0x3f, 0x56, 0x70, 0xaa, 0xe0, 0x82, 0x60, 0x09, 0x10, 0xea, 0x05, 0xfe, 0xb1, 0x82, 0x53, 0x05, 0x47,
0x08, 0x69, 0x03, 0xd7, 0xc2, 0xe7, 0xc0, 0x69, 0x53, 0xa4, 0xf9, 0x20, 0x48, 0x1b, 0xb8, 0x16, 0x3e, 0x07, 0x4e, 0x9b, 0x22, 0xcd, 0x07, 0x21,
0xa4, 0xb9, 0x80, 0x6a, 0xf1, 0x55, 0xad, 0x31, 0x86, 0x90, 0x66, 0x97, 0xcd, 0x05, 0x54, 0x8b, 0xaf, 0x6a, 0x8d, 0x31, 0x84, 0x34, 0xbb, 0x84,
0xd0, 0x9f, 0x41, 0x57, 0x78, 0x16, 0x50, 0x53, 0xe0, 0x9a, 0x8c, 0x80, 0xfe, 0x0c, 0xba, 0xc2, 0xb3, 0x80, 0x9a, 0x02, 0xd7, 0x64, 0x04, 0x84,
0xd0, 0x10, 0x60, 0xe0, 0x03, 0x18, 0x80, 0xe2, 0x54, 0x0e, 0x74, 0x31, 0x86, 0x00, 0x03, 0x1f, 0xc0, 0x00, 0x14, 0xa7, 0x72, 0xa0, 0x8b, 0x09,
0x41, 0x03, 0x70, 0xa3, 0x21, 0xeb, 0x0b, 0x49, 0x4e, 0xb3, 0x28, 0x22, 0x1a, 0x80, 0x1b, 0x0d, 0x59, 0x5f, 0x48, 0x72, 0x9a, 0x45, 0x11, 0x61,
0xac, 0x97, 0xd1, 0x89, 0xef, 0x83, 0xc7, 0xaf, 0xcb, 0x3c, 0x1d, 0x82, 0xbd, 0x8c, 0x4e, 0x7c, 0x1f, 0x3c, 0x7e, 0x5d, 0xe6, 0xe9, 0x10, 0xb4,
0x96, 0xc3, 0xff, 0xd3, 0xa1, 0xb1, 0x28, 0x48, 0x08, 0x6f, 0xc3, 0xc4, 0x1c, 0xfe, 0x9f, 0x0e, 0x8d, 0x45, 0x41, 0x42, 0x78, 0x1b, 0x26, 0x0e,
0x01, 0xce, 0x70, 0x51, 0x99, 0x6e, 0x7c, 0xcb, 0xe8, 0x54, 0xe1, 0xa2, 0x70, 0x86, 0x8b, 0xca, 0x74, 0xe3, 0x5b, 0x46, 0xa7, 0x0a, 0x17, 0x35,
0x46, 0x9d, 0xf2, 0xc2, 0xa1, 0xc9, 0x40, 0x37, 0xce, 0xcc, 0xf9, 0xba, 0xea, 0x94, 0x17, 0x0e, 0x4d, 0x06, 0xba, 0x71, 0x66, 0xce, 0xd7, 0x0d,
0x41, 0x73, 0xa8, 0xd3, 0x1c, 0x55, 0xd3, 0x04, 0x5a, 0x82, 0x6c, 0x35, 0x9a, 0x43, 0x9d, 0xe6, 0xa8, 0x9a, 0x26, 0xd0, 0x12, 0x64, 0xab, 0x69,
0xcd, 0x91, 0x4e, 0x73, 0xaf, 0x9a, 0xe6, 0xae, 0xa2, 0x79, 0x53, 0x45, 0x8e, 0x74, 0x9a, 0x7b, 0xd5, 0x34, 0x77, 0x15, 0xcd, 0x9b, 0x2a, 0x9a,
0x73, 0x4f, 0xa7, 0xf9, 0xb8, 0x96, 0x66, 0xc1, 0x6a, 0x15, 0xcd, 0xc7, 0x7b, 0x3a, 0xcd, 0xc7, 0xb5, 0x34, 0x0b, 0x56, 0xab, 0x68, 0x3e, 0xd6,
0x3a, 0xcd, 0xfd, 0xda, 0xba, 0xef, 0x86, 0xd0, 0xdc, 0xd7, 0x69, 0x1e, 0x69, 0xee, 0xd7, 0xd6, 0x7d, 0x37, 0x84, 0xe6, 0xbe, 0x4e, 0xf3, 0x20,
0x84, 0xb5, 0xd1, 0xae, 0xaa, 0x3b, 0x75, 0x7a, 0xa5, 0x10, 0x57, 0x85, 0xac, 0x8d, 0x76, 0x55, 0xdd, 0xa9, 0xd3, 0x2b, 0x85, 0xb8, 0x2a, 0x34,
0x06, 0xf6, 0x45, 0xd9, 0x04, 0xa5, 0xdc, 0x8f, 0x0b, 0x20, 0x46, 0xb4, 0xb0, 0x2f, 0xca, 0x26, 0x28, 0xe5, 0x7e, 0x5c, 0x00, 0x31, 0xa2, 0x45,
0x28, 0x36, 0xd6, 0x15, 0x24, 0x88, 0xcf, 0x29, 0x7d, 0x9e, 0x69, 0x5e, 0xb1, 0xb1, 0xae, 0x20, 0x41, 0x7c, 0x4e, 0xe9, 0xf3, 0x4c, 0xf3, 0x3a,
0xa7, 0xbc, 0xb6, 0x90, 0xf6, 0x2e, 0x7a, 0x53, 0xa2, 0x2a, 0x63, 0x5a, 0xe5, 0xb5, 0x85, 0xb4, 0x77, 0xd1, 0x9b, 0x12, 0x55, 0x19, 0xd3, 0x0a,
0x81, 0xc0, 0x86, 0x72, 0xc8, 0x02, 0xdb, 0x78, 0x66, 0xf6, 0x71, 0x48, 0x04, 0x36, 0x94, 0x43, 0x16, 0xd8, 0xc6, 0x33, 0xb3, 0x8f, 0x43, 0x0a,
0x01, 0x1d, 0x86, 0xb2, 0xf8, 0x97, 0x0b, 0xf1, 0x05, 0xca, 0x75, 0xd6, 0xe8, 0x30, 0x94, 0xc5, 0xbf, 0x5c, 0x88, 0x2f, 0x50, 0xae, 0xb3, 0x56,
0xca, 0xe9, 0x3e, 0xd4, 0x02, 0xc6, 0xb8, 0x08, 0x03, 0x9a, 0xea, 0xeb, 0x4e, 0xf7, 0xa1, 0x16, 0x30, 0xc6, 0x45, 0x18, 0xd0, 0x54, 0x5f, 0xc7,
0x58, 0x94, 0x30, 0xc0, 0x7f, 0x9e, 0xca, 0x45, 0x26, 0x6a, 0x51, 0x4a, 0xa2, 0x84, 0x01, 0xfe, 0xf3, 0x54, 0x2e, 0x32, 0x51, 0x8b, 0x52, 0x32,
0xa6, 0xf1, 0x2a, 0x59, 0x16, 0x21, 0xbc, 0x06, 0x66, 0x4c, 0x7f, 0x05, 0x8d, 0x57, 0xc9, 0xb2, 0x08, 0xe1, 0x35, 0x30, 0x63, 0xfa, 0x2b, 0xa0,
0x54, 0x1e, 0x87, 0xef, 0xb4, 0x80, 0x39, 0x93, 0x72, 0xac, 0x2a, 0x9b, 0xf2, 0x38, 0x7c, 0xa7, 0x05, 0xcc, 0x99, 0x94, 0x63, 0x55, 0xd9, 0xa4,
0xb4, 0xbe, 0x48, 0xa6, 0x83, 0x4b, 0x74, 0xe3, 0xe6, 0xe4, 0xf8, 0xab, 0xf5, 0x45, 0x32, 0x1d, 0x5c, 0xa2, 0x1b, 0x37, 0x27, 0xc7, 0x5f, 0x3d,
0x27, 0x5f, 0x3e, 0xc5, 0x75, 0xaf, 0xea, 0x00, 0xff, 0x84, 0x3a, 0xc3, 0xf9, 0xf2, 0x29, 0xae, 0x7b, 0x55, 0x07, 0xf8, 0x27, 0xd4, 0x19, 0xbe,
0x17, 0xe0, 0xf1, 0xfa, 0x60, 0x75, 0xa8, 0x7f, 0x25, 0x14, 0x0b, 0x0b, 0xf7, 0x8e, 0xd7, 0x07, 0xab, 0x43, 0xfd, 0x2b, 0xa1, 0x58, 0x58, 0x70,
0x0e, 0x7d, 0xfa, 0xce, 0x3d, 0x90, 0x50, 0xe5, 0x7e, 0x8e, 0xfb, 0xc8, 0xe8, 0xd3, 0x77, 0xee, 0x81, 0x84, 0x2a, 0xf7, 0x73, 0xdc, 0x47, 0x1e,
0x43, 0xe7, 0xfd, 0x2f, 0x3e, 0xa3, 0x5d, 0x1a, 0x48, 0x5b, 0x4d, 0xe6, 0x3a, 0xef, 0x7f, 0xf1, 0x19, 0xed, 0xd2, 0x40, 0xda, 0x6a, 0x32, 0x8f,
0xf1, 0x1c, 0x66, 0xa2, 0xb2, 0x01, 0x8a, 0xed, 0x09, 0xd5, 0xe6, 0x50, 0xe7, 0x30, 0x13, 0x95, 0x0d, 0x50, 0x6c, 0x4f, 0xa8, 0x36, 0x87, 0x82,
0x10, 0xb6, 0x6c, 0xba, 0x59, 0xb2, 0x2c, 0x59, 0xce, 0x62, 0x06, 0xe8, 0xb0, 0x65, 0xd3, 0xcd, 0x92, 0x65, 0xc9, 0x72, 0x16, 0x33, 0x40, 0xc7,
0x18, 0x83, 0x70, 0x41, 0xb8, 0xf4, 0xb0, 0x48, 0x8a, 0xe1, 0x0b, 0xc5, 0x18, 0x84, 0x0b, 0xc2, 0xa5, 0x87, 0x45, 0x52, 0x0c, 0x5f, 0x28, 0x16,
0x22, 0x6a, 0x9c, 0xd3, 0x75, 0x25, 0x39, 0x6f, 0xa0, 0x3c, 0x79, 0xae, 0x51, 0xe3, 0x9c, 0xae, 0x2b, 0xc9, 0x79, 0x03, 0xe5, 0xc9, 0x73, 0xf5,
0xbe, 0x22, 0x68, 0xac, 0x19, 0x8e, 0x52, 0x96, 0x6e, 0x04, 0x9a, 0x2c, 0x15, 0x41, 0x63, 0xcd, 0x70, 0x94, 0xb2, 0x74, 0x23, 0xd0, 0x64, 0x51,
0x0a, 0xe0, 0x37, 0xf9, 0x25, 0xa6, 0x39, 0x4f, 0x80, 0x3e, 0x29, 0x5f, 0x00, 0xbf, 0xc9, 0x2f, 0x31, 0xcd, 0x79, 0x02, 0xf4, 0x49, 0xf9, 0x92,
0x12, 0x34, 0xd7, 0xdb, 0x54, 0x4e, 0xe9, 0x0b, 0xe5, 0xc6, 0x75, 0xa1, 0xa0, 0xb9, 0xde, 0xa6, 0x72, 0x4a, 0xdf, 0x23, 0x37, 0xae, 0x0b, 0xbd,
0xb7, 0x76, 0xb2, 0x59, 0x9a, 0xac, 0xf3, 0xb7, 0x21, 0x89, 0x7e, 0x4e, 0xb5, 0x93, 0xcd, 0xd2, 0x64, 0x9d, 0xbf, 0x0d, 0x49, 0xf4, 0x73, 0xba,
0x57, 0xf3, 0x5b, 0xf8, 0xf1, 0xd6, 0x0e, 0xae, 0xcc, 0xc0, 0x97, 0x3f, 0x9a, 0xdf, 0xc2, 0x8f, 0xb7, 0x76, 0x70, 0x65, 0x06, 0xbe, 0xfc, 0x09,
0x01, 0xcc, 0x51, 0xfd, 0x86, 0x46, 0xa5, 0x01, 0x00 0x2a, 0x25, 0x72, 0xf5, 0x34, 0xa5, 0x01, 0x00
}; };
Arduino/McLighting/json_functions.h
+1 -9
View File
@@ -14,7 +14,6 @@ char * listStateJSONfull() {
root["start"] = segState.start; root["start"] = segState.start;
root["stop"] = segState.stop; root["stop"] = segState.stop;
root["mode"] = (uint8_t) State.mode; root["mode"] = (uint8_t) State.mode;
//getSegmentParams(segment);
root["fx_mode"] = segState.mode[State.segment]; root["fx_mode"] = segState.mode[State.segment];
root["speed"] = segState.speed[State.segment]; root["speed"] = segState.speed[State.segment];
root["brightness"] = State.brightness; root["brightness"] = State.brightness;
@@ -69,15 +68,8 @@ char * listSegmentStateJSON(uint8_t _seg) {
const size_t bufferSize = JSON_ARRAY_SIZE(12) + JSON_OBJECT_SIZE(6) + 100; const size_t bufferSize = JSON_ARRAY_SIZE(12) + JSON_OBJECT_SIZE(6) + 100;
DynamicJsonDocument jsonBuffer(bufferSize); DynamicJsonDocument jsonBuffer(bufferSize);
JsonObject root = jsonBuffer.to<JsonObject>(); JsonObject root = jsonBuffer.to<JsonObject>();
if (_seg == State.segment) {
root["start"] = segState.start;
root["stop"] = segState.stop;
} else {
root["start"] = strip->getSegment(_seg)->start; root["start"] = strip->getSegment(_seg)->start;
root["stop"] = strip->getSegment(_seg)->stop; root["stop"] = strip->getSegment(_seg)->stop;
}
//getSegmentParams(seg);
//root["fx_mode"] = strip->getMode(_seg);
root["fx_mode"] = segState.mode[_seg]; root["fx_mode"] = segState.mode[_seg];
root["speed"] = segState.speed[_seg]; root["speed"] = segState.speed[_seg];
JsonArray color = root.createNestedArray("color"); JsonArray color = root.createNestedArray("color");
@@ -94,7 +86,7 @@ char * listSegmentStateJSON(uint8_t _seg) {
color.add((segState.colors[_seg][2] >> 16) & 0xFF); color.add((segState.colors[_seg][2] >> 16) & 0xFF);
color.add((segState.colors[_seg][2] >> 8) & 0xFF); color.add((segState.colors[_seg][2] >> 8) & 0xFF);
color.add((segState.colors[_seg][2]) & 0xFF); color.add((segState.colors[_seg][2]) & 0xFF);
root["ws_fxopt"] = segState.options; root["ws_fxopt"] = strip->getOptions(_seg);
uint16_t msg_len = measureJson(root) + 1; uint16_t msg_len = measureJson(root) + 1;
char * buffer = (char *) malloc(msg_len); char * buffer = (char *) malloc(msg_len);
serializeJson(root, buffer, msg_len); serializeJson(root, buffer, msg_len);
Arduino/McLighting/mode_custom_ws2812fx_animations.h
+111 -115
View File
@@ -9,14 +9,14 @@ as a custom effect
More info on how to create custom aniamtions for WS2812FX: https://github.com/kitesurfer1404/WS2812FX/blob/master/extras/WS2812FX%20Users%20Guide.md#custom-effects More info on how to create custom aniamtions for WS2812FX: https://github.com/kitesurfer1404/WS2812FX/blob/master/extras/WS2812FX%20Users%20Guide.md#custom-effects
*/ */
// ***************************************************************************
// Functions and variables for automatic cycling
// ***************************************************************************
uint16_t handleSegmentOFF(void) { uint16_t handleSegmentOFF(void) {
WS2812FX::Segment* _seg = strip->getSegment(); WS2812FX::Segment* _seg = strip->getSegment();
return _seg->speed; return _seg->speed;
} }
// ***************************************************************************
// Function for automatic cycling
// ***************************************************************************
void handleAutoPlay(uint8_t _seg) { void handleAutoPlay(uint8_t _seg) {
//WS2812FX::Segment* _seg = strip->getSegment(); //WS2812FX::Segment* _seg = strip->getSegment();
if (autoDelay[_seg] <= millis()) { if (autoDelay[_seg] <= millis()) {
@@ -37,21 +37,28 @@ void handleAutoPlay(uint8_t _seg) {
} }
} }
uint16_t handleAuto() {
WS2812FX::Segment* _seg = strip->getSegment();
return _seg->speed;
}
uint16_t handleCustomWS(void) {
WS2812FX::Segment* _seg = strip->getSegment();
return _seg->speed;
}
#if defined(CUSTOM_WS2812FX_ANIMATIONS) #if defined(CUSTOM_WS2812FX_ANIMATIONS)
// *************************************************************************** // ***************************************************************************
// TV mode // TV mode to be reviewed
// *************************************************************************** // ***************************************************************************
uint8_t dipInterval = 10; uint16_t darkTime[10] = {250,250,250,250,250,250,250,250,250,250};
uint16_t darkTime = 250; uint8_t dipInterval[10] = {10,10,10,10,10,10,10,10,10,10};
unsigned long currentDipTime; unsigned long dipStartTime[10] = {};
unsigned long dipStartTime; uint8_t ledState[10] = {LOW,LOW,LOW,LOW,LOW,LOW,LOW,LOW,LOW,LOW};
unsigned long currentMillis; unsigned long previousMillis[10]= {0,0,0,0,0,0,0,0,0,0};
uint8_t ledState = LOW; uint16_t interv[10] = {2000,2000,2000,2000,2000,2000,2000,2000,2000,2000};
unsigned long previousMillis = 0; uint8_t twitch[10]= {50,50,50,50,50,50,50,50,50,50};
uint16_t interv = 2000; uint8_t dipCount[10] = {0,0,0,0,0,0,0,0,0,0};
uint8_t twitch = 50; bool timeToDip[10] = {false,false,false,false,false,false,false,false,false,false};
uint8_t dipCount = 0;
boolean timeToDip = false;
void hsb2rgbAN1(uint16_t index, uint8_t sat, uint8_t bright, uint16_t led) { void hsb2rgbAN1(uint16_t index, uint8_t sat, uint8_t bright, uint16_t led) {
@@ -63,6 +70,95 @@ void handleAutoPlay(uint8_t _seg) {
strip->setPixelColor(led, temp[n + 2], temp[n + 1], temp[n], 0); strip->setPixelColor(led, temp[n + 2], temp[n + 1], temp[n], 0);
} }
uint16_t handleTV(void) {
WS2812FX::Segment* _seg = strip->getSegment();
uint8_t _seg_num = strip->getSegmentIndex();
if (timeToDip[_seg_num] == false) {
if((millis() - previousMillis[_seg_num]) > interv[_seg_num]) {
DBG_OUTPUT_PORT.println("Segment:");
DBG_OUTPUT_PORT.println(_seg_num);
previousMillis[_seg_num] = millis();
//interv = random(750,4001);//Adjusts the interval for more/less frequent random light changes
interv[_seg_num] = random(800-(512 - (_seg->speed/64)),6001-(2731 - (_seg->speed/24)));
twitch[_seg_num] = random(40,100);// Twitch provides motion effect but can be a bit much if too high
dipCount[_seg_num]++;
}
if((millis() - previousMillis[_seg_num]) < twitch[_seg_num]) {
uint16_t led=random(_seg->start, _seg->stop);
ledState[_seg_num] = ledState[_seg_num] == LOW ? HIGH : LOW; // if the LED is off turn it on and vice-versa:
ledstates[led] = ((ledState[_seg_num]) ? 255 : 0);
for (uint16_t j=_seg->start; j<=_seg->stop; j++) {
uint16_t index = (j%3 == 0) ? 400 : random(0,767);
hsb2rgbAN1(index, 200, ledstates[j], j);
}
if (dipCount[_seg_num] > dipInterval[_seg_num]) {
timeToDip[_seg_num] = true;
dipCount[_seg_num] = 0;
dipStartTime[_seg_num] = millis();
darkTime[_seg_num] = random(50,150);
dipInterval[_seg_num] = random(5,250);// cycles of flicker
}
}
} else {
DBG_OUTPUT_PORT.println("Dip Time");
if (millis() - dipStartTime[_seg_num] < darkTime[_seg_num]) {
for (uint16_t i=(_seg->start + 3); i<= _seg->stop; i++) {
ledstates[i] = 0;
for (uint16_t j=_seg->start; j<=_seg->stop; j++) {
uint16_t index = (j%3 == 0) ? 400 : random(0,767);
hsb2rgbAN1(index, 200, ledstates[j], j);
}
}
} else {
timeToDip[_seg_num] = false;
}
}
return _seg->speed;
}
// ***************************************************************************
// TV mode
// ***************************************************************************
uint16_t handleE131(void) {
WS2812FX::Segment* _seg = strip->getSegment();
if (!e131->isEmpty()) {
e131_packet_t packet;
e131->pull(&packet); // Pull packet from ring buffer
uint16_t universe = htons(packet.universe);
uint8_t *data = packet.property_values + 1;
if (universe < START_UNIVERSE || universe > END_UNIVERSE) return _seg->speed; //async will take care about filling the buffer
// Serial.printf("Universe %u / %u Channels | Packet#: %u / Errors: %u / CH1: %u\n",
// htons(packet.universe), // The Universe for this packet
// htons(packet.property_value_count) - 1, // Start code is ignored, we're interested in dimmer data
// e131.stats.num_packets, // Packet counter
// e131.stats.packet_errors, // Packet error counter
// packet.property_values[1]); // Dimmer data for Channel 1
/* #if defined(RGBW)
uint16_t multipacketOffset = (universe - START_UNIVERSE) * 128; //if more than 128 LEDs * 4 colors = 512 channels, client will send in next higher universe
if (NUMLEDS <= multipacketOffset) return;
uint16_t len = (128 + multipacketOffset > Config.stripSize) ? (Config.stripSize - multipacketOffset) : 128;
#else*/
uint16_t multipacketOffset = (universe - START_UNIVERSE) * 170; //if more than 170 LEDs * 3 colors = 510 channels, client will send in next higher universe
if (Config.stripSize <= multipacketOffset) return _seg->speed;
uint16_t len = (170 + multipacketOffset > Config.stripSize) ? (Config.stripSize - multipacketOffset) : 170;
/* #endif */
for (uint16_t i = 0; i < len; i++){
if ((i >= _seg->start) && (i <= _seg->stop)) {
uint16_t j = i * 3;
/* #if defined(RGBW)
strip->setPixelColor(i + multipacketOffset, data[j], data[j + 1], data[j + 2], data[j + 3]);
#else */
strip->setPixelColor(i + multipacketOffset, data[j], data[j + 1], data[j + 2], 0);
/* #endif */
}
}
}
return _seg->speed;
}
/* /*
* paste in the Fire2012 code with a small edit at the end which uses the * paste in the Fire2012 code with a small edit at the end which uses the
* setPixelColor() function to copy the color data to the ws2812fx instance. * setPixelColor() function to copy the color data to the ws2812fx instance.
@@ -106,104 +202,6 @@ void handleAutoPlay(uint8_t _seg) {
// Default 120, suggested range 50-200. // Default 120, suggested range 50-200.
#define SPARKING 120 #define SPARKING 120
#endif
uint16_t handleAuto() {
WS2812FX::Segment* _seg = strip->getSegment();
return _seg->speed;
}
uint16_t handleCustomWS(void) {
WS2812FX::Segment* _seg = strip->getSegment();
return _seg->speed;
}
#if defined(CUSTOM_WS2812FX_ANIMATIONS)
uint16_t handleTV(void) {
WS2812FX::Segment* _seg = strip->getSegment();
if (timeToDip == false) {
currentMillis = millis();
if(currentMillis-previousMillis > interv) {
previousMillis = currentMillis;
//interv = random(750,4001);//Adjusts the interval for more/less frequent random light changes
interv = random(1000-(_seg->speed/128),5001-(_seg->speed/32));
twitch = random(40,100);// Twitch provides motion effect but can be a bit much if too high
dipCount = dipCount++;
}
if(currentMillis-previousMillis<twitch) {
uint16_t led=random(_seg->start, _seg->stop);
ledState = ledState == LOW ? HIGH : LOW; // if the LED is off turn it on and vice-versa:
ledstates[led] = ((ledState) ? 255 : 0);
for (uint16_t j=_seg->start; j<=_seg->stop; j++) {
uint16_t index = (j%3 == 0) ? 400 : random(0,767);
hsb2rgbAN1(index, 200, ledstates[j], j);
}
if (dipCount > dipInterval) {
DBG_OUTPUT_PORT.println("dip");
timeToDip = true;
dipCount = 0;
dipStartTime = millis();
darkTime = random(50,150);
dipInterval = random(5,250);// cycles of flicker
}
}
} else {
DBG_OUTPUT_PORT.println("Dip Time");
currentDipTime = millis();
if (currentDipTime - dipStartTime < darkTime) {
for (uint16_t i=(_seg->start + 3); i<= _seg->stop; i++) {
ledstates[i] = State.brightness;
for (uint16_t j=_seg->start; j<=_seg->stop; j++) {
uint16_t index = (j%3 == 0) ? 400 : random(0,767);
hsb2rgbAN1(index, 200, ledstates[j], j);
}
}
} else {
timeToDip = false;
}
}
return _seg->speed;
}
uint16_t handleE131(void) {
WS2812FX::Segment* _seg = strip->getSegment();
if (!e131->isEmpty()) {
e131_packet_t packet;
e131->pull(&packet); // Pull packet from ring buffer
uint16_t universe = htons(packet.universe);
uint8_t *data = packet.property_values + 1;
if (universe < START_UNIVERSE || universe > END_UNIVERSE) return _seg->speed; //async will take care about filling the buffer
// Serial.printf("Universe %u / %u Channels | Packet#: %u / Errors: %u / CH1: %u\n",
// htons(packet.universe), // The Universe for this packet
// htons(packet.property_value_count) - 1, // Start code is ignored, we're interested in dimmer data
// e131.stats.num_packets, // Packet counter
// e131.stats.packet_errors, // Packet error counter
// packet.property_values[1]); // Dimmer data for Channel 1
/* #if defined(RGBW)
uint16_t multipacketOffset = (universe - START_UNIVERSE) * 128; //if more than 128 LEDs * 4 colors = 512 channels, client will send in next higher universe
if (NUMLEDS <= multipacketOffset) return;
uint16_t len = (128 + multipacketOffset > Config.stripSize) ? (Config.stripSize - multipacketOffset) : 128;
#else*/
uint16_t multipacketOffset = (universe - START_UNIVERSE) * 170; //if more than 170 LEDs * 3 colors = 510 channels, client will send in next higher universe
if (Config.stripSize <= multipacketOffset) return _seg->speed;
uint16_t len = (170 + multipacketOffset > Config.stripSize) ? (Config.stripSize - multipacketOffset) : 170;
/* #endif */
for (uint16_t i = 0; i < len; i++){
if ((i >= _seg->start) && (i <= _seg->stop)) {
uint16_t j = i * 3;
/* #if defined(RGBW)
strip->setPixelColor(i + multipacketOffset, data[j], data[j + 1], data[j + 2], data[j + 3]);
#else */
strip->setPixelColor(i + multipacketOffset, data[j], data[j + 1], data[j + 2], 0);
/* #endif */
}
}
}
return _seg->speed;
}
uint16_t handleFire2012(void) { uint16_t handleFire2012(void) {
// Array of temperature readings at each simulation cell // Array of temperature readings at each simulation cell
WS2812FX::Segment* _seg = strip->getSegment(); WS2812FX::Segment* _seg = strip->getSegment();
@@ -225,8 +223,6 @@ uint16_t handleFire2012(void) {
} }
// Step 4. Map from heat cells to LED colors // Step 4. Map from heat cells to LED colors
// 98 143
for( uint16_t j = _seg->start; j <= _seg->stop; j++) { for( uint16_t j = _seg->start; j <= _seg->stop; j++) {
CRGB color = HeatColor(ledstates[j]); CRGB color = HeatColor(ledstates[j]);
uint16_t pixel; uint16_t pixel;
Arduino/McLighting/request_handlers.h
+94 -49
View File
@@ -267,14 +267,13 @@ void checkpayload(uint8_t * _payload, bool mqtt = false, uint8_t num = 0) {
// / ==> Set active segment // / ==> Set active segment
if (_payload[0] == 'S') { if (_payload[0] == 'S') {
if (_payload[1] == 's') { if (_payload[1] == 's') {
uint8_t seg = (uint8_t) strtol((const char *) &_payload[2], NULL, 10); uint8_t _seg = (uint8_t) strtol((const char *) &_payload[2], NULL, 10);
State.segment = constrain(seg, 0, Config.segments - 1); _seg = constrain(_seg, 0, Config.segments - 1);
if (prevsegment != State.segment) { if (prevsegment != _seg) {
prevsegment = State.segment; prevsegment = State.segment;
State.segment = _seg;
getSegmentParams(State.segment); getSegmentParams(State.segment);
//convertColors(); //memcpy(hexcolors_trans, segState.colors[State.segment], sizeof(hexcolors_trans));
//memcpy(segState.colors[State.segment], hexcolors_trans, sizeof(hexcolors_trans));
memcpy(hexcolors_trans, segState.colors[State.segment], sizeof(hexcolors_trans));
_updateState = true; _updateState = true;
Dbg_Prefix(mqtt, num); Dbg_Prefix(mqtt, num);
DBG_OUTPUT_PORT.printf("Set segment to: [%u]\r\n", State.segment); DBG_OUTPUT_PORT.printf("Set segment to: [%u]\r\n", State.segment);
@@ -283,7 +282,6 @@ void checkpayload(uint8_t * _payload, bool mqtt = false, uint8_t num = 0) {
// / ==> Set segment first LED // / ==> Set segment first LED
if (_payload[1] == '[') { if (_payload[1] == '[') {
uint16_t _seg_start = (uint16_t) strtol((const char *) &_payload[2], NULL, 10); uint16_t _seg_start = (uint16_t) strtol((const char *) &_payload[2], NULL, 10);
//getSegmentParams(State.segment);
_seg_start = constrain(_seg_start, 0, Config.stripSize - 1); _seg_start = constrain(_seg_start, 0, Config.stripSize - 1);
if (_seg_start != segState.start) { if (_seg_start != segState.start) {
segState.start = _seg_start; segState.start = _seg_start;
@@ -296,7 +294,6 @@ void checkpayload(uint8_t * _payload, bool mqtt = false, uint8_t num = 0) {
// / ==> Set segment last LED // / ==> Set segment last LED
if (_payload[1] == ']') { if (_payload[1] == ']') {
uint16_t _seg_stop = (uint16_t) strtol((const char *) &_payload[2], NULL, 10); uint16_t _seg_stop = (uint16_t) strtol((const char *) &_payload[2], NULL, 10);
//getSegmentParams(State.segment);
_seg_stop = constrain(_seg_stop, segState.start, Config.stripSize - 1); _seg_stop = constrain(_seg_stop, segState.start, Config.stripSize - 1);
if (_seg_stop != segState.stop) { if (_seg_stop != segState.stop) {
segState.stop = _seg_stop; segState.stop = _seg_stop;
@@ -439,6 +436,7 @@ void checkpayload(uint8_t * _payload, bool mqtt = false, uint8_t num = 0) {
if(!save_state.active()) save_state.once(3, tickerSaveState); if(!save_state.active()) save_state.once(3, tickerSaveState);
} }
if (_updateSegState) { if (_updateSegState) {
State.mode = SET;
DBG_OUTPUT_PORT.println("Saving stripstate_segment.json!"); DBG_OUTPUT_PORT.println("Saving stripstate_segment.json!");
if(!save_seg_state.active()) save_seg_state.once(3, tickerSaveSegmentState); if(!save_seg_state.active()) save_seg_state.once(3, tickerSaveSegmentState);
@@ -761,6 +759,8 @@ void webSocketEvent(uint8_t num, WStype_t type, uint8_t * payload, size_t lenght
} }
bool processJson(char* message) { bool processJson(char* message) {
bool _updateState = false;
bool _updateSegState = false;
const size_t bufferSize = JSON_OBJECT_SIZE(5) + JSON_OBJECT_SIZE(12) + 500; const size_t bufferSize = JSON_OBJECT_SIZE(5) + JSON_OBJECT_SIZE(12) + 500;
DynamicJsonDocument jsonBuffer(bufferSize); DynamicJsonDocument jsonBuffer(bufferSize);
DeserializationError error = deserializeJson(jsonBuffer, message); DeserializationError error = deserializeJson(jsonBuffer, message);
@@ -777,14 +777,25 @@ void webSocketEvent(uint8_t num, WStype_t type, uint8_t * payload, size_t lenght
const char* state_in = root["state"]; const char* state_in = root["state"];
if (strcmp(state_in, on_cmd) == 0) { if (strcmp(state_in, on_cmd) == 0) {
State.mode = SET; State.mode = SET;
_updateState = true;
} }
else if (strcmp(state_in, off_cmd) == 0) { else if (strcmp(state_in, off_cmd) == 0) {
State.mode = OFF; State.mode = OFF;
_updateState = true;
jsonBuffer.clear(); jsonBuffer.clear();
return true; return true;
} }
} }
if (root.containsKey("segment")) {
uint8_t json_segment = constrain((uint8_t) root["segment"], 0, Config.segments - 1);
if (prevsegment != json_segment) {
prevsegment = State.segment;
State.segment = json_segment;
getSegmentParams(State.segment);
State.mode = SET;
_updateState = true;
}
}
if (root.containsKey("color")) { if (root.containsKey("color")) {
JsonObject color = root["color"]; JsonObject color = root["color"];
main_color.red = (uint8_t) color["r"]; main_color.red = (uint8_t) color["r"];
@@ -799,14 +810,14 @@ void webSocketEvent(uint8_t num, WStype_t type, uint8_t * payload, size_t lenght
xtra_color.green = (uint8_t) color["g3"]; xtra_color.green = (uint8_t) color["g3"];
xtra_color.blue = (uint8_t) color["b3"]; xtra_color.blue = (uint8_t) color["b3"];
xtra_color.white = (uint8_t) color["w3"]; xtra_color.white = (uint8_t) color["w3"];
State.mode = SET; _updateSegState = true;
} }
if (root.containsKey("white_value")) { if (root.containsKey("white_value")) {
uint8_t json_white_value = constrain((uint8_t) root["white_value"], 0, 255); uint8_t json_white_value = constrain((uint8_t) root["white_value"], 0, 255);
if (json_white_value != main_color.white) { if (json_white_value != main_color.white) {
main_color.white = json_white_value; main_color.white = json_white_value;
State.mode = SET; _updateSegState = true;
} }
} }
@@ -814,7 +825,7 @@ void webSocketEvent(uint8_t num, WStype_t type, uint8_t * payload, size_t lenght
uint8_t _fx_speed = constrain((uint8_t) root["speed"], 0, 255); uint8_t _fx_speed = constrain((uint8_t) root["speed"], 0, 255);
if (_fx_speed != segState.speed[State.segment]) { if (_fx_speed != segState.speed[State.segment]) {
segState.speed[State.segment] = _fx_speed; segState.speed[State.segment] = _fx_speed;
State.mode = SET; _updateSegState = true;
} }
} }
@@ -823,7 +834,7 @@ void webSocketEvent(uint8_t num, WStype_t type, uint8_t * payload, size_t lenght
color_temp = (uint16_t) root["color_temp"]; color_temp = (uint16_t) root["color_temp"];
uint16_t kelvin = 1000000 / color_temp; uint16_t kelvin = 1000000 / color_temp;
main_color = temp2rgb(kelvin); main_color = temp2rgb(kelvin);
State.mode = SET; _updateSegState = true;
} }
if (root.containsKey("brightness")) { if (root.containsKey("brightness")) {
@@ -831,6 +842,7 @@ void webSocketEvent(uint8_t num, WStype_t type, uint8_t * payload, size_t lenght
if (json_brightness != State.brightness) { if (json_brightness != State.brightness) {
State.brightness = json_brightness; State.brightness = json_brightness;
State.mode = SET; State.mode = SET;
_updateState = true;
} }
} }
@@ -839,16 +851,32 @@ void webSocketEvent(uint8_t num, WStype_t type, uint8_t * payload, size_t lenght
#if defined(ENABLE_HOMEASSISTANT) #if defined(ENABLE_HOMEASSISTANT)
if(effectString == "OFF"){ if(effectString == "OFF"){
State.mode = OFF; State.mode = OFF;
_updateState = true;
} }
#endif #endif
for (uint8_t i = 0; i < strip->getModeCount(); i++) { for (uint8_t i = 0; i < strip->getModeCount(); i++) {
if(String(strip->getModeName(i)) == effectString) { if(String(strip->getModeName(i)) == effectString) {
State.mode = SET; State.mode = SET;
fx_mode = i; fx_mode = i;
_updateState = true;
_updateSegState = true;
break; break;
} }
} }
} }
#if defined(ENABLE_STATE_SAVE)
if (_updateState) {
DBG_OUTPUT_PORT.println("Saving stripstate.json!");
if(!save_state.active()) save_state.once(3, tickerSaveState);
}
if (_updateSegState) {
State.mode = SET;
DBG_OUTPUT_PORT.println("Saving stripstate_segment.json!");
if(!save_seg_state.active()) save_seg_state.once(3, tickerSaveSegmentState);
}
#endif
_updateState = false;
_updateSegState = false;
jsonBuffer.clear(); jsonBuffer.clear();
return true; return true;
} }
@@ -1196,6 +1224,8 @@ void webSocketEvent(uint8_t num, WStype_t type, uint8_t * payload, size_t lenght
// *************************************************************************** // ***************************************************************************
void handleRemote() { void handleRemote() {
uint8_t chng = 1; uint8_t chng = 1;
bool _updateState = false;
bool _updateSegState = false;
if (irrecv.decode(&results)) { if (irrecv.decode(&results)) {
DBG_OUTPUT_PORT.print("IR Code: 0x"); DBG_OUTPUT_PORT.print("IR Code: 0x");
DBG_OUTPUT_PORT.print(uint64ToString(results.value, HEX)); DBG_OUTPUT_PORT.print(uint64ToString(results.value, HEX));
@@ -1208,8 +1238,10 @@ void handleRemote() {
last_remote_cmd = 0; last_remote_cmd = 0;
if (State.mode == OFF) { if (State.mode == OFF) {
State.mode = SET; State.mode = SET;
_updateState = true;
} else { } else {
State.mode = OFF; State.mode = OFF;
_updateState = true;;
} }
} }
if (State.mode == HOLD) { if (State.mode == HOLD) {
@@ -1217,14 +1249,14 @@ void handleRemote() {
last_remote_cmd = results.value; last_remote_cmd = results.value;
if (State.brightness + chng <= 255) { if (State.brightness + chng <= 255) {
State.brightness = State.brightness + chng; State.brightness = State.brightness + chng;
State.mode = SET; _updateState = true;
} }
} }
if (results.value == rmt_commands[BRIGHTNESS_DOWN]) { //Brightness down if (results.value == rmt_commands[BRIGHTNESS_DOWN]) { //Brightness down
last_remote_cmd = results.value; last_remote_cmd = results.value;
if (State.brightness - chng >= 0) { if (State.brightness - chng >= 0) {
State.brightness = State.brightness - chng; State.brightness = State.brightness - chng;
State.mode = SET; _updateState = true;
} }
} }
if ((segState.mode[State.segment] < FX_MODE_CUSTOM_0) || (segState.mode[State.segment] > FX_MODE_CUSTOM_1)) { if ((segState.mode[State.segment] < FX_MODE_CUSTOM_0) || (segState.mode[State.segment] > FX_MODE_CUSTOM_1)) {
@@ -1232,14 +1264,14 @@ void handleRemote() {
last_remote_cmd = results.value; last_remote_cmd = results.value;
if (segState.speed[State.segment] + chng <= 65535) { if (segState.speed[State.segment] + chng <= 65535) {
segState.speed[State.segment] = segState.speed[State.segment] + chng; segState.speed[State.segment] = segState.speed[State.segment] + chng;
State.mode = SET; _updateSegState = true;
} }
} }
if (results.value == rmt_commands[SPEED_DOWN]) { //Speed down if (results.value == rmt_commands[SPEED_DOWN]) { //Speed down
last_remote_cmd = results.value; last_remote_cmd = results.value;
if (segState.speed[State.segment] - chng >= 0) { if (segState.speed[State.segment] - chng >= 0) {
segState.speed[State.segment] = segState.speed[State.segment] - chng; segState.speed[State.segment] = segState.speed[State.segment] - chng;
State.mode = SET; _updateSegState = true;
} }
} }
} }
@@ -1249,19 +1281,19 @@ void handleRemote() {
if (selected_color == 1) { if (selected_color == 1) {
if (main_color.red + chng <= 255) { if (main_color.red + chng <= 255) {
main_color.red = main_color.red + chng; main_color.red = main_color.red + chng;
State.mode = SET; _updateSegState = true;
} }
} }
if (selected_color == 2) { if (selected_color == 2) {
if (back_color.red + chng <= 255) { if (back_color.red + chng <= 255) {
back_color.red = back_color.red + chng; back_color.red = back_color.red + chng;
State.mode = SET; _updateSegState = true;
} }
} }
if (selected_color == 3) { if (selected_color == 3) {
if (xtra_color.red + chng <= 255) { if (xtra_color.red + chng <= 255) {
xtra_color.red = xtra_color.red + chng; xtra_color.red = xtra_color.red + chng;
State.mode = SET; _updateSegState = true;
} }
} }
} }
@@ -1270,19 +1302,19 @@ void handleRemote() {
if (selected_color == 1) { if (selected_color == 1) {
if (main_color.red - chng >= 0) { if (main_color.red - chng >= 0) {
main_color.red = main_color.red - chng; main_color.red = main_color.red - chng;
State.mode = SET; _updateSegState = true;
} }
} }
if (selected_color == 2) { if (selected_color == 2) {
if (back_color.red - chng >= 0) { if (back_color.red - chng >= 0) {
back_color.red = back_color.red - chng; back_color.red = back_color.red - chng;
State.mode = SET; _updateSegState = true;
} }
} }
if (selected_color == 3) { if (selected_color == 3) {
if (xtra_color.red - chng >= 0) { if (xtra_color.red - chng >= 0) {
xtra_color.red = xtra_color.red - chng; xtra_color.red = xtra_color.red - chng;
State.mode = SET; _updateSegState = true;
} }
} }
} }
@@ -1291,19 +1323,19 @@ void handleRemote() {
if (selected_color == 1) { if (selected_color == 1) {
if (main_color.green + chng <= 255) { if (main_color.green + chng <= 255) {
main_color.green = main_color.green + chng; main_color.green = main_color.green + chng;
State.mode = SET; _updateSegState = true;
} }
} }
if (selected_color == 2) { if (selected_color == 2) {
if (back_color.green + chng <= 255) { if (back_color.green + chng <= 255) {
back_color.green = back_color.green + chng; back_color.green = back_color.green + chng;
State.mode = SET; _updateSegState = true;
} }
} }
if (selected_color == 3) { if (selected_color == 3) {
if (xtra_color.green + chng <= 255) { if (xtra_color.green + chng <= 255) {
xtra_color.green = xtra_color.green + chng; xtra_color.green = xtra_color.green + chng;
State.mode = SET; _updateSegState = true;
} }
} }
} }
@@ -1312,19 +1344,19 @@ void handleRemote() {
if (selected_color == 1) { if (selected_color == 1) {
if (main_color.green - chng >= 0) { if (main_color.green - chng >= 0) {
main_color.green = main_color.green - chng;; main_color.green = main_color.green - chng;;
State.mode = SET; _updateSegState = true;
} }
} }
if (selected_color == 2) { if (selected_color == 2) {
if (back_color.green - chng >= 0) { if (back_color.green - chng >= 0) {
back_color.green = back_color.green - chng; back_color.green = back_color.green - chng;
State.mode = SET; _updateSegState = true;
} }
} }
if (selected_color == 3) { if (selected_color == 3) {
if (xtra_color.green - chng >= 0) { if (xtra_color.green - chng >= 0) {
xtra_color.green = xtra_color.green - chng; xtra_color.green = xtra_color.green - chng;
State.mode = SET; _updateSegState = true;
} }
} }
} }
@@ -1333,19 +1365,19 @@ void handleRemote() {
if (selected_color == 1) { if (selected_color == 1) {
if (main_color.blue + chng <= 255) { if (main_color.blue + chng <= 255) {
main_color.blue = main_color.blue + chng; main_color.blue = main_color.blue + chng;
State.mode = SET; _updateSegState = true;
} }
} }
if (selected_color == 2) { if (selected_color == 2) {
if (back_color.blue + chng <= 255) { if (back_color.blue + chng <= 255) {
back_color.blue = back_color.blue + chng; back_color.blue = back_color.blue + chng;
State.mode = SET; _updateSegState = true;
} }
} }
if (selected_color == 3) { if (selected_color == 3) {
if (xtra_color.blue + chng <= 255) { if (xtra_color.blue + chng <= 255) {
xtra_color.blue = xtra_color.blue + chng; xtra_color.blue = xtra_color.blue + chng;
State.mode = SET; _updateSegState = true;
} }
} }
} }
@@ -1354,19 +1386,19 @@ void handleRemote() {
if (selected_color == 1) { if (selected_color == 1) {
if (main_color.blue - chng >= 0) { if (main_color.blue - chng >= 0) {
main_color.blue = main_color.blue - chng; main_color.blue = main_color.blue - chng;
State.mode = SET; _updateSegState = true;
} }
} }
if (selected_color == 2) { if (selected_color == 2) {
if (back_color.blue - chng >= 0) { if (back_color.blue - chng >= 0) {
back_color.blue = back_color.blue - chng; back_color.blue = back_color.blue - chng;
State.mode = SET; _updateSegState = true;
} }
} }
if (selected_color == 3) { if (selected_color == 3) {
if (xtra_color.blue - chng >= 0) { if (xtra_color.blue - chng >= 0) {
xtra_color.blue = xtra_color.blue - chng; xtra_color.blue = xtra_color.blue - chng;
State.mode = SET; _updateSegState = true;
} }
} }
} }
@@ -1375,19 +1407,19 @@ void handleRemote() {
if (selected_color == 1) { if (selected_color == 1) {
if (main_color.white + chng <= 255) { if (main_color.white + chng <= 255) {
main_color.white = main_color.white + chng; main_color.white = main_color.white + chng;
State.mode = SET; _updateSegState = true;
} }
} }
if (selected_color == 2) { if (selected_color == 2) {
if (back_color.white + chng <= 255) { if (back_color.white + chng <= 255) {
back_color.white = back_color.white + chng; back_color.white = back_color.white + chng;
State.mode = SET; _updateSegState = true;
} }
} }
if (selected_color == 3) { if (selected_color == 3) {
if (xtra_color.white + chng <= 255) { if (xtra_color.white + chng <= 255) {
xtra_color.white = xtra_color.white + chng; xtra_color.white = xtra_color.white + chng;
State.mode = SET; _updateSegState = true;
} }
} }
} }
@@ -1396,19 +1428,19 @@ void handleRemote() {
if (selected_color == 1) { if (selected_color == 1) {
if (main_color.white - chng >= 0) { if (main_color.white - chng >= 0) {
main_color.white = main_color.white - chng; main_color.white = main_color.white - chng;
State.mode = SET; _updateSegState = true;
} }
} }
if (selected_color == 2) { if (selected_color == 2) {
if (back_color.white - chng >= 0) { if (back_color.white - chng >= 0) {
back_color.white = back_color.white - chng; back_color.white = back_color.white - chng;
State.mode = SET; _updateSegState = true;
} }
} }
if (selected_color == 3) { if (selected_color == 3) {
if (xtra_color.white - chng >= 0) { if (xtra_color.white - chng >= 0) {
xtra_color.white = xtra_color.white - chng; xtra_color.white = xtra_color.white - chng;
State.mode = SET; _updateSegState = true;
} }
} }
} }
@@ -1431,48 +1463,61 @@ void handleRemote() {
if ((segState.mode[State.segment] < strip->getModeCount()-1) && (State.mode == HOLD)) { if ((segState.mode[State.segment] < strip->getModeCount()-1) && (State.mode == HOLD)) {
fx_mode = segState.mode[State.segment] + 1; fx_mode = segState.mode[State.segment] + 1;
} }
State.mode = SET; _updateSegState = true;
} }
if (results.value == rmt_commands[MODE_DOWN]) { //Mode down if (results.value == rmt_commands[MODE_DOWN]) { //Mode down
last_remote_cmd = results.value; last_remote_cmd = results.value;
if ((segState.mode[State.segment] > 0) && (State.mode == HOLD)) { if ((segState.mode[State.segment] > 0) && (State.mode == HOLD)) {
fx_mode = segState.mode[State.segment] - 1; fx_mode = segState.mode[State.segment] - 1;
} }
State.mode = SET; _updateSegState = true;
} }
if (results.value == rmt_commands[AUTOMODE]) { // Toggle Automode if (results.value == rmt_commands[AUTOMODE]) { // Toggle Automode
last_remote_cmd = 0; last_remote_cmd = 0;
fx_mode = 56; fx_mode = 56;
State.mode = SET; _updateSegState = true;
} }
#if defined(CUSTOM_WS2812FX_ANIMATIONS) #if defined(CUSTOM_WS2812FX_ANIMATIONS)
if (results.value == rmt_commands[CUST_1]) { // Select TV Mode if (results.value == rmt_commands[CUST_1]) { // Select TV Mode
last_remote_cmd = 0; last_remote_cmd = 0;
fx_mode = 57; fx_mode = 57;
State.mode = SET; _updateSegState = true;
} }
#endif #endif
if (results.value == rmt_commands[CUST_2]) { // Select Custom Mode 2 if (results.value == rmt_commands[CUST_2]) { // Select Custom Mode 2
last_remote_cmd = 0; last_remote_cmd = 0;
fx_mode = 12; fx_mode = 12;
State.mode = SET; _updateSegState = true;
} }
if (results.value == rmt_commands[CUST_3]) { // Select Custom Mode 3 if (results.value == rmt_commands[CUST_3]) { // Select Custom Mode 3
last_remote_cmd = 0; last_remote_cmd = 0;
fx_mode = 48; fx_mode = 48;
State.mode = SET; _updateSegState = true;
} }
if (results.value == rmt_commands[CUST_4]) { // Select Custom Mode 4 if (results.value == rmt_commands[CUST_4]) { // Select Custom Mode 4
last_remote_cmd = 0; last_remote_cmd = 0;
fx_mode = 21; fx_mode = 21;
State.mode = SET; _updateSegState = true;
} }
if (results.value == rmt_commands[CUST_5]) { // Select Custom Mode 5 if (results.value == rmt_commands[CUST_5]) { // Select Custom Mode 5
last_remote_cmd = 0; last_remote_cmd = 0;
fx_mode = 46; fx_mode = 46;
State.mode = SET; _updateSegState = true;
} }
irrecv.resume(); // Receive the next value irrecv.resume(); // Receive the next value
} }
#if defined(ENABLE_STATE_SAVE)
if (_updateState) {
DBG_OUTPUT_PORT.println("Saving stripstate.json!");
if(!save_state.active()) save_state.once(3, tickerSaveState);
}
if (_updateSegState) {
State.mode = SET;
DBG_OUTPUT_PORT.println("Saving stripstate_segment.json!");
if(!save_seg_state.active()) save_seg_state.once(3, tickerSaveSegmentState);
}
#endif
_updateState = false;
_updateSegState = false;
} }
#endif #endif
Arduino/McLighting/rest_api.h
+21 -6
View File
@@ -306,12 +306,13 @@ server.on("/set", []() {
boolean _updateState = false; boolean _updateState = false;
boolean _updateSegState = false; boolean _updateSegState = false;
// Segment // Segment
if ((server.arg("seg") != "") && (server.arg("seg").toInt() >= 0) && (server.arg("seg").toInt() <= MAX_NUM_SEGMENTS)) { if ((server.arg("seg") != "") && (server.arg("seg").toInt() >= 0) && (server.arg("seg").toInt() < Config.segments)) {
State.segment = server.arg("seg").toInt(); uint8_t _seg = server.arg("seg").toInt();
if (prevsegment != State.segment) { if (prevsegment != _seg) {
prevsegment = State.segment; prevsegment = State.segment;
State.segment = _seg;
getSegmentParams(State.segment); getSegmentParams(State.segment);
memcpy(hexcolors_trans, segState.colors[State.segment], sizeof(hexcolors_trans)); //memcpy(hexcolors_trans, segState.colors[State.segment], sizeof(hexcolors_trans));
State.mode = SET; State.mode = SET;
_updateState = true; _updateState = true;
} }
@@ -350,18 +351,23 @@ server.on("/set", []() {
main_color.red = ((rgb >> 16) & 0xFF); main_color.red = ((rgb >> 16) & 0xFF);
main_color.green = ((rgb >> 8) & 0xFF); main_color.green = ((rgb >> 8) & 0xFF);
main_color.blue = ((rgb >> 0) & 0xFF); main_color.blue = ((rgb >> 0) & 0xFF);
_updateSegState = true;
} else { } else {
if ((server.arg("r") != "") && (server.arg("r").toInt() >= 0) && (server.arg("r").toInt() <= 255)) { if ((server.arg("r") != "") && (server.arg("r").toInt() >= 0) && (server.arg("r").toInt() <= 255)) {
main_color.red = server.arg("r").toInt(); main_color.red = server.arg("r").toInt();
_updateSegState = true;
} }
if ((server.arg("g") != "") && (server.arg("g").toInt() >= 0) && (server.arg("g").toInt() <= 255)) { if ((server.arg("g") != "") && (server.arg("g").toInt() >= 0) && (server.arg("g").toInt() <= 255)) {
main_color.green = server.arg("g").toInt(); main_color.green = server.arg("g").toInt();
_updateSegState = true;
} }
if ((server.arg("b") != "") && (server.arg("b").toInt() >= 0) && (server.arg("b").toInt() <= 255)) { if ((server.arg("b") != "") && (server.arg("b").toInt() >= 0) && (server.arg("b").toInt() <= 255)) {
main_color.blue = server.arg("b").toInt(); main_color.blue = server.arg("b").toInt();
_updateSegState = true;
} }
if ((server.arg("w") != "") && (server.arg("w").toInt() >= 0) && (server.arg("w").toInt() <= 255)){ if ((server.arg("w") != "") && (server.arg("w").toInt() >= 0) && (server.arg("w").toInt() <= 255)){
main_color.white = server.arg("w").toInt(); main_color.white = server.arg("w").toInt();
_updateSegState = true;
} }
} }
if (server.arg("rgb2") != "") { if (server.arg("rgb2") != "") {
@@ -370,18 +376,23 @@ server.on("/set", []() {
back_color.red = ((rgb2 >> 16) & 0xFF); back_color.red = ((rgb2 >> 16) & 0xFF);
back_color.green = ((rgb2 >> 8) & 0xFF); back_color.green = ((rgb2 >> 8) & 0xFF);
back_color.blue = ((rgb2 >> 0) & 0xFF); back_color.blue = ((rgb2 >> 0) & 0xFF);
_updateSegState = true;
} else { } else {
if ((server.arg("r2") != "") && (server.arg("r2").toInt() >= 0) && (server.arg("r2").toInt() <= 255)) { if ((server.arg("r2") != "") && (server.arg("r2").toInt() >= 0) && (server.arg("r2").toInt() <= 255)) {
back_color.red = server.arg("r2").toInt(); back_color.red = server.arg("r2").toInt();
_updateSegState = true;
} }
if ((server.arg("g2") != "") && (server.arg("g2").toInt() >= 0) && (server.arg("g2").toInt() <= 255)) { if ((server.arg("g2") != "") && (server.arg("g2").toInt() >= 0) && (server.arg("g2").toInt() <= 255)) {
back_color.green = server.arg("g2").toInt(); back_color.green = server.arg("g2").toInt();
_updateSegState = true;
} }
if ((server.arg("b2") != "") && (server.arg("b2").toInt() >= 0) && (server.arg("b2").toInt() <= 255)) { if ((server.arg("b2") != "") && (server.arg("b2").toInt() >= 0) && (server.arg("b2").toInt() <= 255)) {
back_color.blue = server.arg("b2").toInt(); back_color.blue = server.arg("b2").toInt();
_updateSegState = true;
} }
if ((server.arg("w2") != "") && (server.arg("w2").toInt() >= 0) && (server.arg("w2").toInt() <= 255)){ if ((server.arg("w2") != "") && (server.arg("w2").toInt() >= 0) && (server.arg("w2").toInt() <= 255)){
back_color.white = server.arg("w2").toInt(); back_color.white = server.arg("w2").toInt();
_updateSegState = true;
} }
} }
if (server.arg("rgb3") != "") { if (server.arg("rgb3") != "") {
@@ -390,18 +401,23 @@ server.on("/set", []() {
xtra_color.red = ((rgb3 >> 16) & 0xFF); xtra_color.red = ((rgb3 >> 16) & 0xFF);
xtra_color.green = ((rgb3 >> 8) & 0xFF); xtra_color.green = ((rgb3 >> 8) & 0xFF);
xtra_color.blue = ((rgb3 >> 0) & 0xFF); xtra_color.blue = ((rgb3 >> 0) & 0xFF);
_updateSegState = true;
} else { } else {
if ((server.arg("r3") != "") && (server.arg("r3").toInt() >= 0) && (server.arg("r3").toInt() <= 255)) { if ((server.arg("r3") != "") && (server.arg("r3").toInt() >= 0) && (server.arg("r3").toInt() <= 255)) {
xtra_color.red = server.arg("r3").toInt(); xtra_color.red = server.arg("r3").toInt();
_updateSegState = true;
} }
if ((server.arg("g3") != "") && (server.arg("g3").toInt() >= 0) && (server.arg("g3").toInt() <= 255)) { if ((server.arg("g3") != "") && (server.arg("g3").toInt() >= 0) && (server.arg("g3").toInt() <= 255)) {
xtra_color.green = server.arg("g3").toInt(); xtra_color.green = server.arg("g3").toInt();
_updateSegState = true;
} }
if ((server.arg("b3") != "") && (server.arg("b3").toInt() >= 0) && (server.arg("b3").toInt() <= 255)) { if ((server.arg("b3") != "") && (server.arg("b3").toInt() >= 0) && (server.arg("b3").toInt() <= 255)) {
xtra_color.blue = server.arg("b3").toInt(); xtra_color.blue = server.arg("b3").toInt();
_updateSegState = true;
} }
if ((server.arg("w3") != "") && (server.arg("w3").toInt() >= 0) && (server.arg("w3").toInt() <= 255)){ if ((server.arg("w3") != "") && (server.arg("w3").toInt() >= 0) && (server.arg("w3").toInt() <= 255)){
xtra_color.white = server.arg("w3").toInt(); xtra_color.white = server.arg("w3").toInt();
_updateSegState = true;
} }
} }
main_color.red = constrain(main_color.red, 0, 255); main_color.red = constrain(main_color.red, 0, 255);
@@ -421,14 +437,12 @@ server.on("/set", []() {
// Speed // Speed
if ((server.arg("s") != "") && (server.arg("s").toInt() >= 0) && (server.arg("s").toInt() <= 255)) { if ((server.arg("s") != "") && (server.arg("s").toInt() >= 0) && (server.arg("s").toInt() <= 255)) {
segState.speed[State.segment] = constrain(server.arg("s").toInt(), 0, 255); segState.speed[State.segment] = constrain(server.arg("s").toInt(), 0, 255);
State.mode = SET;
_updateSegState = true; _updateSegState = true;
} }
//Mode //Mode
if ((server.arg("m") != "") && (server.arg("m").toInt() >= 0) && (server.arg("m").toInt() <= strip->getModeCount())) { if ((server.arg("m") != "") && (server.arg("m").toInt() >= 0) && (server.arg("m").toInt() <= strip->getModeCount())) {
fx_mode = constrain(server.arg("m").toInt(), 0, strip->getModeCount() - 1); fx_mode = constrain(server.arg("m").toInt(), 0, strip->getModeCount() - 1);
if (fx_mode != segState.mode[State.segment]) { if (fx_mode != segState.mode[State.segment]) {
State.mode = SET;
_updateSegState = true; _updateSegState = true;
} }
} }
@@ -453,6 +467,7 @@ server.on("/set", []() {
} }
if (_updateSegState) { if (_updateSegState) {
DBG_OUTPUT_PORT.println("Saving stripstate_segment.json!"); DBG_OUTPUT_PORT.println("Saving stripstate_segment.json!");
State.mode = SET;
if(!save_seg_state.active()) save_seg_state.once(3, tickerSaveSegmentState); if(!save_seg_state.active()) save_seg_state.once(3, tickerSaveSegmentState);
} }
#endif #endif
Arduino/McLighting/version.h
+1 -1
View File
@@ -1 +1 @@
#define SKETCH_VERSION "3.1.0.BETA1" #define SKETCH_VERSION "3.1.0.BETA2"
Arduino/McLighting/version_info.ino
+7
View File
@@ -207,6 +207,13 @@
* further integration of multi segments * further integration of multi segments
* known problem: as always: AUTOPLAY (as it is not multi segment capable yet) * known problem: as always: AUTOPLAY (as it is not multi segment capable yet)
* *
* 07 October
* Version Bump to 3.1.0.BETA1 * Version Bump to 3.1.0.BETA1
* bugfixes * bugfixes
* adressed issue: #39 uncooment //#define ENABLE_MQTT_INCLUDE_IP in defninitions.h
*
* 09 October
* Version Bump to 3.1.0.BETA2
* bugfixes
* implemented https://github.com/FabLab-Luenen/McLighting/commit/589806d0fda737011426754a6d84c88535ded688
*/ */
clients/web/index.htm
+2 -2
View File
@@ -1929,9 +1929,9 @@ function initSettings() {
redrawColorPicker(); redrawColorPicker();
}); });
var settransitionEffects = document.getElementById("set-transitionEffects"); var settransitionEffects = document.getElementById("set-transitionEffects");
settransitionEffects.checked = config.transitionEffects; settransitionEffects.checked = config.ws_trans;
settransitionEffects.addEventListener('change', ()=>{ settransitionEffects.addEventListener('change', ()=>{
config.transitionEffects = settransitionEffects.checked; config.ws_trans = settransitionEffects.checked;
if (settransitionEffects.checked) { if (settransitionEffects.checked) {
document.getElementById("settransitionEffectsbgcolor").style.backgroundColor = settings.theme_btn; document.getElementById("settransitionEffectsbgcolor").style.backgroundColor = settings.theme_btn;
ws_send("Ce1"); ws_send("Ce1");
clients/web/index.htm.gz
BIN
View File
Binary file not shown.