jeans/WLED
jeans/WLED
1
0
Fork 0
mirror of https://github.com/wled/WLED.git synced 2025-07-26 04:06:37 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch '0_15' into psram-4-json

Browse Source
This commit is contained in:
Blaz Kristan 2023-12-28 23:38:27 +01:00
commit d3be7a3edf
16 changed files with 1644 additions and 1659 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
wled00/FX.cpp
View File

@ -5292,7 +5292,6 @@ uint16_t mode_2Dmatrix(void) { // Matrix2D. By Jeremy Williams.
if (!SEGENV.allocateData(dataSize)) return mode_static(); //allocation failed if (!SEGENV.allocateData(dataSize)) return mode_static(); //allocation failed
if (SEGENV.call == 0) { if (SEGENV.call == 0) {
memset(SEGMENT.data, 0, dataSize); // no falling spawns
SEGMENT.fill(BLACK); SEGMENT.fill(BLACK);
SEGENV.step = 0; SEGENV.step = 0;
} }

22
wled00/FX.h
View File

@ -543,9 +543,9 @@ typedef struct Segment {
// runtime data functions // runtime data functions
inline uint16_t dataSize(void) const { return _dataLen; } inline uint16_t dataSize(void) const { return _dataLen; }
bool allocateData(size_t len); bool allocateData(size_t len); // allocates effect data buffer in heap and clears it
void deallocateData(void); void deallocateData(void); // deallocates (frees) effect data buffer from heap
void resetIfRequired(void); void resetIfRequired(void); // sets all SEGENV variables to 0 and clears data buffer
/** /**
* Flags that before the next effect is calculated, * Flags that before the next effect is calculated,
* the internal segment state should be reset. * the internal segment state should be reset.
@ -559,10 +559,10 @@ typedef struct Segment {
void stopTransition(void); void stopTransition(void);
void handleTransition(void); void handleTransition(void);
#ifndef WLED_DISABLE_MODE_BLEND #ifndef WLED_DISABLE_MODE_BLEND
void swapSegenv(tmpsegd_t &tmpSegD); void swapSegenv(tmpsegd_t &tmpSegD); // copies segment data into specifed buffer, if buffer is not a transition buffer, segment data is overwritten from transition buffer
void restoreSegenv(tmpsegd_t &tmpSegD); void restoreSegenv(tmpsegd_t &tmpSegD); // restores segment data from buffer, if buffer is not transition buffer, changed values are copied to transition buffer
#endif #endif
uint16_t progress(void); //transition progression between 0-65535 uint16_t progress(void); // transition progression between 0-65535
uint8_t currentBri(bool useCct = false); uint8_t currentBri(bool useCct = false);
uint8_t currentMode(void); uint8_t currentMode(void);
uint32_t currentColor(uint8_t slot); uint32_t currentColor(uint8_t slot);
@ -760,7 +760,7 @@ class WS2812FX { // 96 bytes
resetSegments(), resetSegments(),
makeAutoSegments(bool forceReset = false), makeAutoSegments(bool forceReset = false),
fixInvalidSegments(), fixInvalidSegments(),
setPixelColor(int n, uint32_t c), setPixelColor(unsigned n, uint32_t c),
show(void), show(void),
setTargetFps(uint8_t fps), setTargetFps(uint8_t fps),
addEffect(uint8_t id, mode_ptr mode_fn, const char *mode_name), // add effect to the list; defined in FX.cpp addEffect(uint8_t id, mode_ptr mode_fn, const char *mode_name), // add effect to the list; defined in FX.cpp
@ -769,10 +769,10 @@ class WS2812FX { // 96 bytes
inline void restartRuntime() { for (Segment &seg : _segments) seg.markForReset(); } inline void restartRuntime() { for (Segment &seg : _segments) seg.markForReset(); }
inline void setTransitionMode(bool t) { for (Segment &seg : _segments) seg.startTransition(t ? _transitionDur : 0); } inline void setTransitionMode(bool t) { for (Segment &seg : _segments) seg.startTransition(t ? _transitionDur : 0); }
inline void setColor(uint8_t slot, uint8_t r, uint8_t g, uint8_t b, uint8_t w = 0) { setColor(slot, RGBW32(r,g,b,w)); } inline void setColor(uint8_t slot, uint8_t r, uint8_t g, uint8_t b, uint8_t w = 0) { setColor(slot, RGBW32(r,g,b,w)); }
inline void fill(uint32_t c) { for (int i = 0; i < getLengthTotal(); i++) setPixelColor(i, c); } // fill whole strip with color (inline) inline void fill(uint32_t c) { for (unsigned i = 0; i < getLengthTotal(); i++) setPixelColor(i, c); } // fill whole strip with color (inline)
// outsmart the compiler :) by correctly overloading // outsmart the compiler :) by correctly overloading
inline void setPixelColor(int n, uint8_t r, uint8_t g, uint8_t b, uint8_t w = 0) { setPixelColor(n, RGBW32(r,g,b,w)); } inline void setPixelColor(unsigned n, uint8_t r, uint8_t g, uint8_t b, uint8_t w = 0) { setPixelColor(n, RGBW32(r,g,b,w)); }
inline void setPixelColor(int n, CRGB c) { setPixelColor(n, c.red, c.green, c.blue); } inline void setPixelColor(unsigned n, CRGB c) { setPixelColor(n, c.red, c.green, c.blue); }
inline void trigger(void) { _triggered = true; } // Forces the next frame to be computed on all active segments. inline void trigger(void) { _triggered = true; } // Forces the next frame to be computed on all active segments.
inline void setShowCallback(show_callback cb) { _callback = cb; } inline void setShowCallback(show_callback cb) { _callback = cb; }
inline void setTransition(uint16_t t) { _transitionDur = t; } inline void setTransition(uint16_t t) { _transitionDur = t; }
@ -878,7 +878,7 @@ class WS2812FX { // 96 bytes
void setUpMatrix(); void setUpMatrix();
// outsmart the compiler :) by correctly overloading // outsmart the compiler :) by correctly overloading
inline void setPixelColorXY(int x, int y, uint32_t c) { setPixelColor(y * Segment::maxWidth + x, c); } inline void setPixelColorXY(int x, int y, uint32_t c) { setPixelColor((unsigned)(y * Segment::maxWidth + x), c); }
inline void setPixelColorXY(int x, int y, byte r, byte g, byte b, byte w = 0) { setPixelColorXY(x, y, RGBW32(r,g,b,w)); } inline void setPixelColorXY(int x, int y, byte r, byte g, byte b, byte w = 0) { setPixelColorXY(x, y, RGBW32(r,g,b,w)); }
inline void setPixelColorXY(int x, int y, CRGB c) { setPixelColorXY(x, y, RGBW32(c.r,c.g,c.b,0)); } inline void setPixelColorXY(int x, int y, CRGB c) { setPixelColorXY(x, y, RGBW32(c.r,c.g,c.b,0)); }

21
wled00/FX_2Dfcn.cpp
View File

@ -36,14 +36,9 @@
// so matrix should disable regular ledmap processing // so matrix should disable regular ledmap processing
void WS2812FX::setUpMatrix() { void WS2812FX::setUpMatrix() {
#ifndef WLED_DISABLE_2D #ifndef WLED_DISABLE_2D
// erase old ledmap, just in case.
if (customMappingTable != nullptr) delete[] customMappingTable;
customMappingTable = nullptr;
customMappingSize = 0;
// isMatrix is set in cfg.cpp or set.cpp // isMatrix is set in cfg.cpp or set.cpp
if (isMatrix) { if (isMatrix) {
// calculate width dynamically because it will have gaps // calculate width dynamically because it may have gaps
Segment::maxWidth = 1; Segment::maxWidth = 1;
Segment::maxHeight = 1; Segment::maxHeight = 1;
for (size_t i = 0; i < panel.size(); i++) { for (size_t i = 0; i < panel.size(); i++) {
@ -68,15 +63,17 @@ void WS2812FX::setUpMatrix() {
return; return;
} }
customMappingTable = new uint16_t[Segment::maxWidth * Segment::maxHeight]; customMappingSize = 0; // prevent use of mapping if anything goes wrong
if (customMappingTable == nullptr) customMappingTable = new uint16_t[getLengthTotal()];
if (customMappingTable != nullptr) { if (customMappingTable != nullptr) {
customMappingSize = Segment::maxWidth * Segment::maxHeight; customMappingSize = getLengthTotal();
// fill with empty in case we don't fill the entire matrix // fill with empty in case we don't fill the entire matrix
for (size_t i = 0; i< customMappingSize; i++) { unsigned matrixSize = Segment::maxWidth * Segment::maxHeight;
customMappingTable[i] = (uint16_t)-1; for (unsigned i = 0; i<matrixSize; i++) customMappingTable[i] = 0xFFFFU;
} for (unsigned i = matrixSize; i<getLengthTotal(); i++) customMappingTable[i] = i; // trailing LEDs for ledmap (after matrix) if it exist
// we will try to load a "gap" array (a JSON file) // we will try to load a "gap" array (a JSON file)
// the array has to have the same amount of values as mapping array (or larger) // the array has to have the same amount of values as mapping array (or larger)
@ -101,7 +98,7 @@ void WS2812FX::setUpMatrix() {
// 1 ... active pixel (it will count and will be mapped) // 1 ... active pixel (it will count and will be mapped)
JsonArray map = pDoc->as<JsonArray>(); JsonArray map = pDoc->as<JsonArray>();
gapSize = map.size(); gapSize = map.size();
if (!map.isNull() && gapSize >= customMappingSize) { // not an empty map if (!map.isNull() && gapSize >= matrixSize) { // not an empty map
gapTable = new int8_t[gapSize]; gapTable = new int8_t[gapSize];
if (gapTable) for (size_t i = 0; i < gapSize; i++) { if (gapTable) for (size_t i = 0; i < gapSize; i++) {
gapTable[i] = constrain(map[i], -1, 1); gapTable[i] = constrain(map[i], -1, 1);

110
wled00/FX_fcn.cpp
View File

@ -143,27 +143,28 @@ Segment& Segment::operator= (Segment &&orig) noexcept {
return *this; return *this;
} }
// allocates effect data buffer on heap and initialises (erases) it
bool IRAM_ATTR Segment::allocateData(size_t len) { bool IRAM_ATTR Segment::allocateData(size_t len) {
if (len == 0) return false; // nothing to do
if (data && _dataLen >= len) { // already allocated enough (reduce fragmentation) if (data && _dataLen >= len) { // already allocated enough (reduce fragmentation)
if (call == 0) memset(data, 0, len); // erase buffer if called during effect initialisation if (call == 0) memset(data, 0, len); // erase buffer if called during effect initialisation
return true; return true;
} }
//DEBUG_PRINTF("-- Allocating data (%d): %p\n", len, this); //DEBUG_PRINTF("-- Allocating data (%d): %p\n", len, this);
deallocateData(); deallocateData(); // if the old buffer was smaller release it first
if (len == 0) return false; // nothing to do
if (Segment::getUsedSegmentData() + len > MAX_SEGMENT_DATA) { if (Segment::getUsedSegmentData() + len > MAX_SEGMENT_DATA) {
// not enough memory // not enough memory
DEBUG_PRINT(F("!!! Effect RAM depleted: ")); DEBUG_PRINT(F("!!! Effect RAM depleted: "));
DEBUG_PRINTF("%d/%d !!!\n", len, Segment::getUsedSegmentData()); DEBUG_PRINTF("%d/%d !!!\n", len, Segment::getUsedSegmentData());
errorFlag = ERR_NORAM;
return false; return false;
} }
// do not use SPI RAM on ESP32 since it is slow // do not use SPI RAM on ESP32 since it is slow
data = (byte*) malloc(len); data = (byte*)calloc(len, sizeof(byte));
if (!data) { DEBUG_PRINTLN(F("!!! Allocation failed. !!!")); return false; } // allocation failed if (!data) { DEBUG_PRINTLN(F("!!! Allocation failed. !!!")); return false; } // allocation failed
Segment::addUsedSegmentData(len); Segment::addUsedSegmentData(len);
//DEBUG_PRINTF("--- Allocated data (%p): %d/%d -> %p\n", this, len, Segment::getUsedSegmentData(), data); //DEBUG_PRINTF("--- Allocated data (%p): %d/%d -> %p\n", this, len, Segment::getUsedSegmentData(), data);
_dataLen = len; _dataLen = len;
memset(data, 0, len);
return true; return true;
} }
@ -194,7 +195,7 @@ void IRAM_ATTR Segment::deallocateData() {
void Segment::resetIfRequired() { void Segment::resetIfRequired() {
if (!reset) return; if (!reset) return;
//DEBUG_PRINTF("-- Segment reset: %p\n", this); //DEBUG_PRINTF("-- Segment reset: %p\n", this);
deallocateData(); if (data && _dataLen > 0) memset(data, 0, _dataLen); // prevent heap fragmentation (just erase buffer instead of deallocateData())
next_time = 0; step = 0; call = 0; aux0 = 0; aux1 = 0; next_time = 0; step = 0; call = 0; aux0 = 0; aux1 = 0;
reset = false; reset = false;
} }
@ -561,35 +562,36 @@ void Segment::setOption(uint8_t n, bool val) {
} }
void Segment::setMode(uint8_t fx, bool loadDefaults) { void Segment::setMode(uint8_t fx, bool loadDefaults) {
// skip reserved
while (fx < strip.getModeCount() && strncmp_P("RSVD", strip.getModeData(fx), 4) == 0) fx++;
if (fx >= strip.getModeCount()) fx = 0; // set solid mode
// if we have a valid mode & is not reserved // if we have a valid mode & is not reserved
if (fx < strip.getModeCount() && strncmp_P("RSVD", strip.getModeData(fx), 4)) { if (fx != mode) {
if (fx != mode) {
#ifndef WLED_DISABLE_MODE_BLEND #ifndef WLED_DISABLE_MODE_BLEND
if (modeBlending) startTransition(strip.getTransition()); // set effect transitions if (modeBlending) startTransition(strip.getTransition()); // set effect transitions
#endif #endif
mode = fx; mode = fx;
// load default values from effect string // load default values from effect string
if (loadDefaults) { if (loadDefaults) {
int16_t sOpt; int16_t sOpt;
sOpt = extractModeDefaults(fx, "sx"); speed = (sOpt >= 0) ? sOpt : DEFAULT_SPEED; sOpt = extractModeDefaults(fx, "sx"); speed = (sOpt >= 0) ? sOpt : DEFAULT_SPEED;
sOpt = extractModeDefaults(fx, "ix"); intensity = (sOpt >= 0) ? sOpt : DEFAULT_INTENSITY; sOpt = extractModeDefaults(fx, "ix"); intensity = (sOpt >= 0) ? sOpt : DEFAULT_INTENSITY;
sOpt = extractModeDefaults(fx, "c1"); custom1 = (sOpt >= 0) ? sOpt : DEFAULT_C1; sOpt = extractModeDefaults(fx, "c1"); custom1 = (sOpt >= 0) ? sOpt : DEFAULT_C1;
sOpt = extractModeDefaults(fx, "c2"); custom2 = (sOpt >= 0) ? sOpt : DEFAULT_C2; sOpt = extractModeDefaults(fx, "c2"); custom2 = (sOpt >= 0) ? sOpt : DEFAULT_C2;
sOpt = extractModeDefaults(fx, "c3"); custom3 = (sOpt >= 0) ? sOpt : DEFAULT_C3; sOpt = extractModeDefaults(fx, "c3"); custom3 = (sOpt >= 0) ? sOpt : DEFAULT_C3;
sOpt = extractModeDefaults(fx, "o1"); check1 = (sOpt >= 0) ? (bool)sOpt : false; sOpt = extractModeDefaults(fx, "o1"); check1 = (sOpt >= 0) ? (bool)sOpt : false;
sOpt = extractModeDefaults(fx, "o2"); check2 = (sOpt >= 0) ? (bool)sOpt : false; sOpt = extractModeDefaults(fx, "o2"); check2 = (sOpt >= 0) ? (bool)sOpt : false;
sOpt = extractModeDefaults(fx, "o3"); check3 = (sOpt >= 0) ? (bool)sOpt : false; sOpt = extractModeDefaults(fx, "o3"); check3 = (sOpt >= 0) ? (bool)sOpt : false;
sOpt = extractModeDefaults(fx, "m12"); if (sOpt >= 0) map1D2D = constrain(sOpt, 0, 7); else map1D2D = M12_Pixels; // reset mapping if not defined (2D FX may not work) sOpt = extractModeDefaults(fx, "m12"); if (sOpt >= 0) map1D2D = constrain(sOpt, 0, 7); else map1D2D = M12_Pixels; // reset mapping if not defined (2D FX may not work)
sOpt = extractModeDefaults(fx, "si"); if (sOpt >= 0) soundSim = constrain(sOpt, 0, 3); sOpt = extractModeDefaults(fx, "si"); if (sOpt >= 0) soundSim = constrain(sOpt, 0, 3);
sOpt = extractModeDefaults(fx, "rev"); if (sOpt >= 0) reverse = (bool)sOpt; sOpt = extractModeDefaults(fx, "rev"); if (sOpt >= 0) reverse = (bool)sOpt;
sOpt = extractModeDefaults(fx, "mi"); if (sOpt >= 0) mirror = (bool)sOpt; // NOTE: setting this option is a risky business sOpt = extractModeDefaults(fx, "mi"); if (sOpt >= 0) mirror = (bool)sOpt; // NOTE: setting this option is a risky business
sOpt = extractModeDefaults(fx, "rY"); if (sOpt >= 0) reverse_y = (bool)sOpt; sOpt = extractModeDefaults(fx, "rY"); if (sOpt >= 0) reverse_y = (bool)sOpt;
sOpt = extractModeDefaults(fx, "mY"); if (sOpt >= 0) mirror_y = (bool)sOpt; // NOTE: setting this option is a risky business sOpt = extractModeDefaults(fx, "mY"); if (sOpt >= 0) mirror_y = (bool)sOpt; // NOTE: setting this option is a risky business
sOpt = extractModeDefaults(fx, "pal"); if (sOpt >= 0) setPalette(sOpt); //else setPalette(0); sOpt = extractModeDefaults(fx, "pal"); if (sOpt >= 0) setPalette(sOpt); //else setPalette(0);
}
markForReset();
stateChanged = true; // send UDP/WS broadcast
} }
markForReset();
stateChanged = true; // send UDP/WS broadcast
} }
} }
@ -751,10 +753,10 @@ void IRAM_ATTR Segment::setPixelColor(int i, uint32_t col)
uint32_t tmpCol = col; uint32_t tmpCol = col;
// set all the pixels in the group // set all the pixels in the group
for (int j = 0; j < grouping; j++) { for (int j = 0; j < grouping; j++) {
uint16_t indexSet = i + ((reverse) ? -j : j); unsigned indexSet = i + ((reverse) ? -j : j);
if (indexSet >= start && indexSet < stop) { if (indexSet >= start && indexSet < stop) {
if (mirror) { //set the corresponding mirrored pixel if (mirror) { //set the corresponding mirrored pixel
uint16_t indexMir = stop - indexSet + start - 1; unsigned indexMir = stop - indexSet + start - 1;
indexMir += offset; // offset/phase indexMir += offset; // offset/phase
if (indexMir >= stop) indexMir -= len; // wrap if (indexMir >= stop) indexMir -= len; // wrap
#ifndef WLED_DISABLE_MODE_BLEND #ifndef WLED_DISABLE_MODE_BLEND
@ -1121,17 +1123,14 @@ void WS2812FX::finalizeInit(void) {
#endif #endif
} }
if (isMatrix) setUpMatrix(); Segment::maxWidth = _length;
else { Segment::maxHeight = 1;
Segment::maxWidth = _length;
Segment::maxHeight = 1;
}
//segments are created in makeAutoSegments(); //segments are created in makeAutoSegments();
DEBUG_PRINTLN(F("Loading custom palettes")); DEBUG_PRINTLN(F("Loading custom palettes"));
loadCustomPalettes(); // (re)load all custom palettes loadCustomPalettes(); // (re)load all custom palettes
DEBUG_PRINTLN(F("Loading custom ledmaps")); DEBUG_PRINTLN(F("Loading custom ledmaps"));
deserializeMap(); // (re)load default ledmap deserializeMap(); // (re)load default ledmap (will also setUpMatrix() if ledmap does not exist)
} }
void WS2812FX::service() { void WS2812FX::service() {
@ -1210,7 +1209,7 @@ void WS2812FX::service() {
#endif #endif
} }
void IRAM_ATTR WS2812FX::setPixelColor(int i, uint32_t col) { void IRAM_ATTR WS2812FX::setPixelColor(unsigned i, uint32_t col) {
if (i < customMappingSize) i = customMappingTable[i]; if (i < customMappingSize) i = customMappingTable[i];
if (i >= _length) return; if (i >= _length) return;
busses.setPixelColor(i, col); busses.setPixelColor(i, col);
@ -1658,41 +1657,30 @@ bool WS2812FX::deserializeMap(uint8_t n) {
strcat_P(fileName, PSTR(".json")); strcat_P(fileName, PSTR(".json"));
bool isFile = WLED_FS.exists(fileName); bool isFile = WLED_FS.exists(fileName);
if (!isFile) { customMappingSize = 0; // prevent use of mapping if anything goes wrong
// erase custom mapping if selecting nonexistent ledmap.json (n==0)
if (!isMatrix && !n && customMappingTable != nullptr) { if (!isFile && n==0 && isMatrix) {
customMappingSize = 0; setUpMatrix();
delete[] customMappingTable;
customMappingTable = nullptr;
}
return false; return false;
} }
if (!requestJSONBufferLock(7)) return false; if (!isFile || !requestJSONBufferLock(7)) return false; // this will trigger setUpMatrix() when called from wled.cpp
if (!readObjectFromFile(fileName, nullptr, pDoc)) { if (!readObjectFromFile(fileName, nullptr, pDoc)) {
DEBUG_PRINT(F("ERROR Invalid ledmap in ")); DEBUG_PRINTLN(fileName);
releaseJSONBufferLock(); releaseJSONBufferLock();
return false; //if file does not exist just exit return false; // if file does not load properly then exit
} }
DEBUG_PRINT(F("Reading LED map from ")); DEBUG_PRINT(F("Reading LED map from ")); DEBUG_PRINTLN(fileName);
DEBUG_PRINTLN(fileName);
// erase old custom ledmap if (customMappingTable == nullptr) customMappingTable = new uint16_t[getLengthTotal()];
if (customMappingTable != nullptr) {
customMappingSize = 0;
delete[] customMappingTable;
customMappingTable = nullptr;
}
JsonObject root = pDoc->as<JsonObject>(); JsonObject root = pDoc->as<JsonObject>();
JsonArray map = root[F("map")]; JsonArray map = root[F("map")];
if (!map.isNull() && map.size()) { // not an empty map if (!map.isNull() && map.size()) { // not an empty map
customMappingSize = map.size(); customMappingSize = min((unsigned)map.size(), (unsigned)getLengthTotal());
customMappingTable = new uint16_t[customMappingSize]; for (unsigned i=0; i<customMappingSize; i++) customMappingTable[i] = (uint16_t) (map[i]<0 ? 0xFFFFU : map[i]);
for (unsigned i=0; i<customMappingSize; i++) {
customMappingTable[i] = (uint16_t) (map[i]<0 ? 0xFFFFU : map[i]);
}
} }
releaseJSONBufferLock(); releaseJSONBufferLock();

15
wled00/bus_manager.cpp
View File

@ -258,23 +258,8 @@ void BusDigital::setBrightness(uint8_t b) {
if (_pins[0] == LED_BUILTIN || _pins[1] == LED_BUILTIN) reinit(); if (_pins[0] == LED_BUILTIN || _pins[1] == LED_BUILTIN) reinit();
} }
#endif #endif
uint8_t prevBri = _bri;
Bus::setBrightness(b); Bus::setBrightness(b);
PolyBus::setBrightness(_busPtr, _iType, b); PolyBus::setBrightness(_busPtr, _iType, b);
/*
if (_data) return; // use _buffering this causes ~20% FPS drop
// must update/repaint every LED in the NeoPixelBus buffer to the new brightness
// the only case where repainting is unnecessary is when all pixels are set after the brightness change but before the next show
// (which we can't rely on)
uint16_t hwLen = _len;
if (_type == TYPE_WS2812_1CH_X3) hwLen = NUM_ICS_WS2812_1CH_3X(_len); // only needs a third of "RGB" LEDs for NeoPixelBus
for (unsigned i = 0; i < hwLen; i++) {
// use 0 as color order, actual order does not matter here as we just update the channel values as-is
uint32_t c = restoreColorLossy(PolyBus::getPixelColor(_busPtr, _iType, i, 0), prevBri);
PolyBus::setPixelColor(_busPtr, _iType, i, c, 0);
}
*/
} }
//If LEDs are skipped, it is possible to use the first as a status LED. //If LEDs are skipped, it is possible to use the first as a status LED.

4
wled00/cfg.cpp
View File

@ -79,7 +79,7 @@ bool deserializeConfig(JsonObject doc, bool fromFS) {
noWifiSleep = doc[F("wifi")][F("sleep")] | !noWifiSleep; // inverted noWifiSleep = doc[F("wifi")][F("sleep")] | !noWifiSleep; // inverted
noWifiSleep = !noWifiSleep; noWifiSleep = !noWifiSleep;
//int wifi_phy = doc[F("wifi")][F("phy")]; //force phy mode n? force802_3g = doc[F("wifi")][F("phy")] | force802_3g; //force phy mode g?
JsonObject hw = doc[F("hw")]; JsonObject hw = doc[F("hw")];
@ -695,7 +695,7 @@ void serializeConfig() {
JsonObject wifi = root.createNestedObject("wifi"); JsonObject wifi = root.createNestedObject("wifi");
wifi[F("sleep")] = !noWifiSleep; wifi[F("sleep")] = !noWifiSleep;
//wifi[F("phy")] = 1; wifi[F("phy")] = (int)force802_3g;
#ifdef WLED_USE_ETHERNET #ifdef WLED_USE_ETHERNET
JsonObject ethernet = root.createNestedObject("eth"); JsonObject ethernet = root.createNestedObject("eth");

1
wled00/const.h
View File

@ -345,6 +345,7 @@
#define ERR_CONCURRENCY 2 // Conurrency (client active) #define ERR_CONCURRENCY 2 // Conurrency (client active)
#define ERR_NOBUF 3 // JSON buffer was not released in time, request cannot be handled at this time #define ERR_NOBUF 3 // JSON buffer was not released in time, request cannot be handled at this time
#define ERR_NOT_IMPL 4 // Not implemented #define ERR_NOT_IMPL 4 // Not implemented
#define ERR_NORAM 8 // effect RAM depleted
#define ERR_JSON 9 // JSON parsing failed (input too large?) #define ERR_JSON 9 // JSON parsing failed (input too large?)
#define ERR_FS_BEGIN 10 // Could not init filesystem (no partition?) #define ERR_FS_BEGIN 10 // Could not init filesystem (no partition?)
#define ERR_FS_QUOTA 11 // The FS is full or the maximum file size is reached #define ERR_FS_QUOTA 11 // The FS is full or the maximum file size is reached

44
wled00/data/index.js
View File

@ -329,7 +329,6 @@ function openTab(tabI, force = false)
var timeout; var timeout;
function showToast(text, error = false) function showToast(text, error = false)
{ {
if (error) gId('connind').style.backgroundColor = "var(--c-r)";
var x = gId('toast'); var x = gId('toast');
//if (error) text += '<i class="icons btn-icon" style="transform:rotate(45deg);position:absolute;top:10px;right:0px;" onclick="clearErrorToast(100);">&#xe18a;</i>'; //if (error) text += '<i class="icons btn-icon" style="transform:rotate(45deg);position:absolute;top:10px;right:0px;" onclick="clearErrorToast(100);">&#xe18a;</i>';
x.innerHTML = text; x.innerHTML = text;
@ -342,6 +341,7 @@ function showToast(text, error = false)
function showErrorToast() function showErrorToast()
{ {
gId('connind').style.backgroundColor = "var(--c-r)";
showToast('Connection to light failed!', true); showToast('Connection to light failed!', true);
} }
@ -1492,25 +1492,31 @@ function readState(s,command=false)
gId('checkO3').checked = !(!i.o3); gId('checkO3').checked = !(!i.o3);
if (s.error && s.error != 0) { if (s.error && s.error != 0) {
var errstr = ""; var errstr = "";
switch (s.error) { switch (s.error) {
case 10: case 8:
errstr = "Could not mount filesystem!"; errstr = "Effect RAM depleted!";
break; break;
case 11: case 9:
errstr = "Not enough space to save preset!"; errstr = "JSON parsing error!";
break; break;
case 12: case 10:
errstr = "Preset not found."; errstr = "Could not mount filesystem!";
break; break;
case 13: case 11:
errstr = "Missing ir.json."; errstr = "Not enough space to save preset!";
break; break;
case 19: case 12:
errstr = "A filesystem error has occured."; errstr = "Preset not found.";
break; break;
case 13:
errstr = "Missing ir.json.";
break;
case 19:
errstr = "A filesystem error has occured.";
break;
} }
showToast('Error ' + s.error + ": " + errstr, true); showToast('Error ' + s.error + ": " + errstr, true);
} }
selectedPal = i.pal; selectedPal = i.pal;

1
wled00/data/settings_wifi.htm
View File

@ -192,6 +192,7 @@
<option value="3">Never (not recommended)</option></select><br> <option value="3">Never (not recommended)</option></select><br>
AP IP: <span class="sip"> Not active </span><br> AP IP: <span class="sip"> Not active </span><br>
<h3>Experimental</h3> <h3>Experimental</h3>
Force 802.11g mode (ESP8266 only): <input type="checkbox" name="FG"><br>
Disable WiFi sleep: <input type="checkbox" name="WS"><br> Disable WiFi sleep: <input type="checkbox" name="WS"><br>
<i>Can help with connectivity issues.<br> <i>Can help with connectivity issues.<br>
Do not enable if WiFi is working correctly, increases power consumption.</i> Do not enable if WiFi is working correctly, increases power consumption.</i>

322
wled00/html_settings.h
View File

@ -145,167 +145,169 @@ const uint8_t PAGE_settings[] PROGMEM = {
// Autogenerated from wled00/data/settings_wifi.htm, do not edit!! // Autogenerated from wled00/data/settings_wifi.htm, do not edit!!
const uint16_t PAGE_settings_wifi_length = 2533; const uint16_t PAGE_settings_wifi_length = 2567;
const uint8_t PAGE_settings_wifi[] PROGMEM = { const uint8_t PAGE_settings_wifi[] PROGMEM = {
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x13, 0xad, 0x59, 0xfb, 0x73, 0xdb, 0xb8, 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x13, 0xad, 0x59, 0x6d, 0x53, 0xdb, 0x48,
0x11, 0xfe, 0x5d, 0x7f, 0x05, 0x8c, 0x76, 0x3c, 0xe4, 0x98, 0xa6, 0x2c, 0xfb, 0x1e, 0xa9, 0x2c, 0x12, 0xfe, 0xee, 0x5f, 0x31, 0xcc, 0x5d, 0x51, 0x52, 0x21, 0x64, 0x0c, 0xd9, 0x6c, 0xce, 0x58,
0x2a, 0xf5, 0x43, 0x97, 0xb8, 0xe7, 0x38, 0x6e, 0xe4, 0x9e, 0xa7, 0x93, 0x66, 0xae, 0x34, 0x09, 0xce, 0xf1, 0xe2, 0x24, 0xdc, 0x12, 0xc2, 0xc5, 0xdc, 0x52, 0x57, 0xb9, 0xd4, 0xae, 0x90, 0xc6,
0x49, 0x48, 0x28, 0x82, 0x25, 0x40, 0xc9, 0x1e, 0xdb, 0xff, 0x7b, 0xbf, 0x05, 0x48, 0xbd, 0x6c, 0xf6, 0x24, 0xb2, 0x46, 0xab, 0x19, 0x61, 0x28, 0xe0, 0xbf, 0xdf, 0xd3, 0x33, 0x92, 0xdf, 0x80,
0xe7, 0x3a, 0x69, 0x26, 0x33, 0x11, 0x09, 0x2c, 0xf6, 0xbd, 0x1f, 0x76, 0xe9, 0xde, 0xd6, 0xe9, 0xec, 0x55, 0x2e, 0xb5, 0x55, 0x8b, 0xa5, 0xe9, 0xe9, 0x97, 0xa7, 0xbb, 0x9f, 0xe9, 0x51, 0x7a,
0xfb, 0x93, 0xab, 0x7f, 0x5e, 0x0e, 0xd8, 0xc4, 0x4c, 0xb3, 0x7e, 0x8f, 0xfe, 0x67, 0x59, 0x9c, 0x1b, 0xc7, 0x1f, 0x8e, 0x2e, 0xfe, 0x7d, 0x3e, 0x60, 0x13, 0x33, 0xcd, 0xfa, 0x3d, 0xfa, 0x3f,
0x8f, 0x23, 0x2e, 0x72, 0x8e, 0x77, 0x11, 0xa7, 0xfd, 0xde, 0x54, 0x98, 0x98, 0x25, 0x93, 0xb8, 0xcb, 0xe2, 0x7c, 0x1c, 0x71, 0x91, 0x73, 0x3c, 0x8b, 0x38, 0xed, 0xf7, 0xa6, 0xc2, 0xc4, 0x2c,
0xd4, 0xc2, 0x44, 0xbc, 0x32, 0xa3, 0xdd, 0x57, 0xbc, 0x5e, 0x6d, 0x25, 0x2a, 0x37, 0x22, 0xc7, 0x99, 0xc4, 0xa5, 0x16, 0x26, 0xe2, 0x95, 0x19, 0x6d, 0xbf, 0xe2, 0xf5, 0xdb, 0x56, 0xa2, 0x72,
0xf2, 0x5c, 0xa6, 0x66, 0x12, 0xa5, 0x62, 0x26, 0x13, 0xb1, 0x6b, 0x5f, 0x02, 0x99, 0x4b, 0x23, 0x23, 0x72, 0xbc, 0x9e, 0xc9, 0xd4, 0x4c, 0xa2, 0x54, 0x5c, 0xcb, 0x44, 0x6c, 0xdb, 0x87, 0x40,
0xe3, 0x6c, 0x57, 0x27, 0x71, 0x26, 0xa2, 0x4e, 0x30, 0x8d, 0x6f, 0xe5, 0xb4, 0x9a, 0x2e, 0xde, 0xe6, 0xd2, 0xc8, 0x38, 0xdb, 0xd6, 0x49, 0x9c, 0x89, 0xa8, 0x13, 0x4c, 0xe3, 0x1b, 0x39, 0xad,
0x2b, 0x2d, 0x4a, 0xfb, 0x12, 0xdf, 0xe0, 0x3d, 0x57, 0x9c, 0xb5, 0xf2, 0x78, 0x2a, 0x22, 0x3e, 0xa6, 0xf3, 0xe7, 0x4a, 0x8b, 0xd2, 0x3e, 0xc4, 0x57, 0x78, 0xce, 0x15, 0x67, 0xad, 0x3c, 0x9e,
0x93, 0x62, 0x5e, 0xa8, 0xd2, 0x40, 0x8a, 0x91, 0x26, 0x13, 0xfd, 0x6b, 0xf9, 0x8b, 0x64, 0x43, 0x8a, 0x88, 0x5f, 0x4b, 0x31, 0x2b, 0x54, 0x69, 0x60, 0xc5, 0x48, 0x93, 0x89, 0xfe, 0xa5, 0x7c,
0x61, 0x8c, 0xcc, 0xc7, 0xba, 0xd7, 0x76, 0x8b, 0x3d, 0x9d, 0x94, 0xb2, 0x30, 0xfd, 0xd6, 0x2c, 0x23, 0xd9, 0x50, 0x18, 0x23, 0xf3, 0xb1, 0xee, 0xb5, 0xdd, 0xcb, 0x9e, 0x4e, 0x4a, 0x59, 0x98,
0x2e, 0x59, 0xa6, 0x12, 0x59, 0x04, 0x69, 0x94, 0xaa, 0xa4, 0x9a, 0x42, 0xa1, 0x00, 0x0b, 0xd1, 0x7e, 0xeb, 0x3a, 0x2e, 0x59, 0xa6, 0x12, 0x59, 0x04, 0x69, 0x94, 0xaa, 0xa4, 0x9a, 0xc2, 0xa1,
0x56, 0x87, 0x7e, 0x8a, 0x52, 0x19, 0x15, 0xf1, 0x89, 0x31, 0x45, 0x97, 0x07, 0x90, 0x97, 0x9f, 0x00, 0x2f, 0xa2, 0x8d, 0x0e, 0xfd, 0x29, 0x4a, 0x65, 0x54, 0xc4, 0x27, 0xc6, 0x14, 0x5d, 0x1e,
0x2b, 0x55, 0xe8, 0x68, 0x2f, 0x28, 0x4a, 0x31, 0xc4, 0xeb, 0x70, 0x78, 0x76, 0x1a, 0x71, 0x7e, 0xc0, 0x5e, 0x7e, 0xaa, 0x54, 0xa1, 0xa3, 0x9d, 0xa0, 0x28, 0xc5, 0x10, 0x8f, 0xc3, 0xe1, 0xc9,
0x38, 0xaa, 0xf2, 0xc4, 0x48, 0x95, 0xb3, 0xf1, 0x59, 0xea, 0x19, 0xff, 0xbe, 0x14, 0xa6, 0x2a, 0x71, 0xc4, 0xf9, 0xfe, 0xa8, 0xca, 0x13, 0x23, 0x55, 0xce, 0xc6, 0x27, 0xa9, 0x67, 0xfc, 0xbb,
0x73, 0x96, 0x86, 0x63, 0x61, 0x06, 0x99, 0x20, 0xb6, 0xc7, 0x77, 0x76, 0xeb, 0x71, 0x41, 0x9a, 0x52, 0x98, 0xaa, 0xcc, 0x59, 0x1a, 0x8e, 0x85, 0x19, 0x64, 0x82, 0xd4, 0x1e, 0xde, 0xda, 0xa5,
0x0c, 0xd6, 0x28, 0x93, 0x52, 0xc4, 0x46, 0xd4, 0xc4, 0x6b, 0x84, 0x46, 0x8d, 0xc7, 0x99, 0x20, 0x87, 0xb9, 0x68, 0x32, 0x58, 0x91, 0x4c, 0x4a, 0x11, 0x1b, 0x51, 0x0b, 0xaf, 0x08, 0x1a, 0x35,
0x62, 0xc7, 0x3d, 0x4c, 0xb2, 0x58, 0xeb, 0x73, 0xa9, 0x4d, 0x58, 0x6f, 0xf1, 0x89, 0x4c, 0x05, 0x1e, 0x67, 0x82, 0x84, 0x9d, 0xf6, 0x30, 0xc9, 0x62, 0xad, 0x4f, 0xa5, 0x36, 0x61, 0xbd, 0xc4,
0xf7, 0x03, 0xda, 0xe7, 0x17, 0x8a, 0xef, 0x7c, 0x85, 0x68, 0xc9, 0xf7, 0xad, 0xe7, 0xdf, 0xcf, 0x27, 0x32, 0x15, 0xdc, 0x0f, 0x68, 0x9d, 0x9f, 0x29, 0xbe, 0xf5, 0x0d, 0xa1, 0x85, 0xde, 0x77,
0x65, 0x9e, 0xaa, 0x79, 0xa8, 0x0a, 0x91, 0x7b, 0xd6, 0x4e, 0xdd, 0x6d, 0xb7, 0xbf, 0xe4, 0x2a, 0x9e, 0x7f, 0x37, 0x93, 0x79, 0xaa, 0x66, 0xa1, 0x2a, 0x44, 0xee, 0xd9, 0x38, 0x75, 0xb7, 0xdd,
0x9c, 0x67, 0x82, 0xb4, 0x6f, 0x8f, 0xa0, 0x55, 0x55, 0x0a, 0xdd, 0xd6, 0xb5, 0x0f, 0xdb, 0x7f, 0xfe, 0x9a, 0xab, 0x70, 0x96, 0x09, 0xf2, 0xbe, 0x3d, 0x82, 0x57, 0x55, 0x29, 0x74, 0x5b, 0xd7,
0x9a, 0xcb, 0x91, 0xdc, 0x6d, 0x5e, 0x57, 0x19, 0x1e, 0x6f, 0x30, 0x84, 0xf1, 0xff, 0xf8, 0x70, 0x18, 0xb6, 0xff, 0x32, 0x93, 0x23, 0xb9, 0xdd, 0x3c, 0x2e, 0x2b, 0x3c, 0x5c, 0x53, 0x88, 0xe0,
0xee, 0xf1, 0xf6, 0x92, 0x38, 0xe0, 0xbf, 0x6b, 0x91, 0x8d, 0x56, 0x4f, 0x5d, 0xe0, 0x14, 0x72, 0xff, 0xf5, 0xf1, 0xd4, 0xe3, 0xed, 0x85, 0x70, 0xc0, 0x7f, 0xd3, 0x22, 0x1b, 0x2d, 0xef, 0x3a,
0x41, 0x1b, 0x66, 0x22, 0x6b, 0x00, 0xf9, 0x99, 0xfb, 0x87, 0x26, 0x4c, 0xa5, 0xa6, 0xf8, 0xa6, 0xc3, 0x2e, 0xd4, 0x82, 0x36, 0xcc, 0x44, 0x36, 0x00, 0xc2, 0x99, 0xfb, 0xfb, 0x26, 0x4c, 0xa5,
0xd1, 0xd6, 0x5e, 0x00, 0x33, 0xc4, 0xad, 0x39, 0x69, 0x72, 0x86, 0x9c, 0x9f, 0x83, 0x65, 0x18, 0xa6, 0xfc, 0xa6, 0xd1, 0xc6, 0x4e, 0x80, 0x30, 0xc4, 0x8d, 0x39, 0x6a, 0x6a, 0x86, 0xc0, 0xcf,
0x86, 0x3c, 0x18, 0x09, 0x93, 0x4c, 0x96, 0xd2, 0x3e, 0x6b, 0x95, 0xb7, 0x73, 0x61, 0xb8, 0xef, 0xa1, 0x32, 0x0c, 0x43, 0x1e, 0x8c, 0x84, 0x49, 0x26, 0x0b, 0x6b, 0x5f, 0xb4, 0xca, 0xdb, 0xb9,
0x87, 0x66, 0x02, 0x3d, 0x4c, 0xd4, 0x37, 0x21, 0xad, 0x7a, 0x2b, 0x2b, 0xef, 0x6f, 0x3e, 0x8b, 0x30, 0xdc, 0xf7, 0x43, 0x33, 0x81, 0x1f, 0x26, 0xea, 0x9b, 0x90, 0xde, 0x7a, 0x4b, 0x6f, 0x3e,
0xc4, 0x84, 0x70, 0x92, 0x1c, 0xe7, 0xde, 0xfd, 0x63, 0x70, 0x8f, 0x23, 0x73, 0x55, 0x7e, 0xd1, 0x5c, 0x7d, 0x11, 0x89, 0x09, 0x01, 0x92, 0x1c, 0xe7, 0xde, 0xdd, 0x43, 0x70, 0x87, 0x2d, 0x33,
0xdd, 0x8f, 0x9f, 0x1e, 0x03, 0x78, 0xb0, 0x79, 0x0f, 0x35, 0x12, 0xca, 0xf3, 0x4c, 0x20, 0xfc, 0x55, 0x7e, 0xd5, 0xdd, 0x4f, 0x9f, 0x1f, 0x02, 0x20, 0xd8, 0x3c, 0x87, 0x1a, 0x05, 0xe5, 0x79,
0xa8, 0x2f, 0xc2, 0x12, 0x27, 0x76, 0x8d, 0xfd, 0xf1, 0xc3, 0x52, 0xa4, 0x55, 0x22, 0x9a, 0x4d, 0x26, 0x10, 0x7e, 0xd4, 0x17, 0x61, 0x89, 0x1d, 0xdb, 0xc6, 0xfe, 0xf1, 0xc3, 0x52, 0xa4, 0x55,
0xcf, 0x80, 0x76, 0x2a, 0x9c, 0x40, 0xec, 0xa7, 0x51, 0x14, 0x09, 0xfb, 0xe0, 0x3f, 0x3c, 0x98, 0x22, 0x9a, 0x45, 0xcf, 0x40, 0x76, 0x2a, 0x9c, 0x41, 0xac, 0xa7, 0x51, 0x14, 0x09, 0xfb, 0xc3,
0xb0, 0xa8, 0xf4, 0xc4, 0x13, 0x3e, 0x78, 0x07, 0x1f, 0x3f, 0x35, 0xaa, 0x88, 0xa8, 0x7f, 0x2f, 0xbf, 0xbf, 0x37, 0x61, 0x51, 0xe9, 0x89, 0x27, 0x7c, 0xe8, 0x0e, 0x3e, 0x7d, 0x6e, 0x5c, 0x11,
0x47, 0xde, 0x9e, 0x25, 0xcd, 0x44, 0x3e, 0x36, 0x93, 0xed, 0xed, 0x45, 0xaa, 0xf5, 0x3a, 0x7b, 0x51, 0xff, 0x4e, 0x8e, 0xbc, 0x1d, 0x2b, 0x9a, 0x89, 0x7c, 0x6c, 0x26, 0x9b, 0x9b, 0xf3, 0x52,
0x7e, 0x9d, 0x22, 0x8b, 0xb5, 0x9d, 0x9d, 0x60, 0xa6, 0x64, 0xca, 0xe0, 0xd5, 0x2b, 0x39, 0x15, 0xeb, 0x75, 0x76, 0xfc, 0xba, 0x44, 0xe6, 0xef, 0xb6, 0xb6, 0x82, 0x6b, 0x25, 0x53, 0x06, 0x54,
0xaa, 0x32, 0xde, 0x45, 0xd0, 0x11, 0x07, 0xfe, 0xe1, 0x4a, 0x86, 0x1e, 0x66, 0xc2, 0x30, 0xe5, 0x2f, 0xe4, 0x54, 0xa8, 0xca, 0x78, 0x67, 0x41, 0x47, 0xec, 0xf9, 0xfb, 0x4b, 0x15, 0xba, 0x9f,
0x1c, 0x7a, 0x32, 0x84, 0x3b, 0x21, 0x43, 0xf9, 0xf7, 0xb4, 0x6a, 0x22, 0xa4, 0x1e, 0x47, 0x18, 0x09, 0xc3, 0x94, 0x03, 0xf4, 0x68, 0x08, 0x38, 0x61, 0x43, 0xf9, 0x77, 0xf4, 0xd6, 0x44, 0x28,
0x60, 0xbf, 0xf5, 0x33, 0x18, 0x1d, 0x19, 0x53, 0xca, 0x9b, 0xca, 0x20, 0x4d, 0x64, 0xca, 0x03, 0x3d, 0x8e, 0x34, 0x20, 0x7e, 0x8b, 0x33, 0x14, 0x1d, 0x18, 0x53, 0xca, 0xab, 0xca, 0xa0, 0x4c,
0x7b, 0x24, 0xd8, 0xdc, 0xa1, 0x12, 0x7b, 0x69, 0x4f, 0xe5, 0x28, 0xf3, 0x7c, 0x4c, 0xfb, 0x57, 0x64, 0xca, 0x03, 0xbb, 0x25, 0x58, 0x5f, 0xa1, 0x16, 0x7b, 0x6e, 0x4d, 0xe5, 0x68, 0xf3, 0x7c,
0x9e, 0x0f, 0x82, 0xd5, 0x0a, 0x51, 0xe1, 0x2c, 0xce, 0x2a, 0x71, 0x38, 0x52, 0xa5, 0x47, 0x1a, 0x4c, 0xeb, 0x17, 0x9e, 0x0f, 0x81, 0xe5, 0x0e, 0x51, 0xe1, 0x75, 0x9c, 0x55, 0x62, 0x7f, 0xa4,
0x08, 0xe8, 0x27, 0x7a, 0x26, 0x4c, 0x26, 0x32, 0x4b, 0x4b, 0x91, 0xd7, 0x76, 0x1f, 0x8a, 0x9d, 0x4a, 0x8f, 0x3c, 0x10, 0xf0, 0x4f, 0xf4, 0x4c, 0x98, 0x4c, 0x64, 0x96, 0x96, 0x22, 0xaf, 0xe3,
0x1d, 0x1f, 0x9e, 0x15, 0x53, 0x35, 0x13, 0x27, 0xb4, 0xe7, 0x2d, 0x69, 0x3e, 0x8a, 0x4f, 0xfe, 0xde, 0x17, 0x5b, 0x5b, 0x3e, 0x90, 0x15, 0x53, 0x75, 0x2d, 0x8e, 0x68, 0xcd, 0x5b, 0xc8, 0x7c,
0x82, 0x41, 0x0e, 0x06, 0x79, 0xaf, 0xf1, 0xd7, 0x61, 0x8e, 0x73, 0x75, 0x0e, 0x49, 0x6b, 0x9c, 0x12, 0x9f, 0xfd, 0xb9, 0x82, 0x1c, 0x0a, 0xf2, 0x5e, 0x83, 0xd7, 0x7e, 0x8e, 0x7d, 0x75, 0x0d,
0x2a, 0x28, 0xb5, 0xc8, 0xea, 0x0d, 0x35, 0xad, 0x1e, 0x3c, 0x10, 0x1f, 0xf3, 0x4f, 0x2e, 0x2e, 0x49, 0x1b, 0x9c, 0x2a, 0xa8, 0xb4, 0x28, 0xea, 0x35, 0x37, 0xad, 0x1f, 0x3c, 0x10, 0x9f, 0xf2,
0x81, 0x5c, 0x4b, 0xac, 0x7f, 0xff, 0xf9, 0x7e, 0xb1, 0xf7, 0xc8, 0xbc, 0xfa, 0x8d, 0x62, 0xfd, 0xcf, 0x2e, 0x2f, 0x81, 0x5c, 0x29, 0xac, 0xdf, 0xff, 0x7a, 0x37, 0x5f, 0x7b, 0x60, 0x5e, 0xfd,
0xc8, 0xd2, 0xe3, 0xa9, 0xff, 0xef, 0xe5, 0x51, 0x04, 0xac, 0xb6, 0x6b, 0x7b, 0x7b, 0x53, 0x8c, 0x44, 0xb9, 0x7e, 0x60, 0xe9, 0xe1, 0xd4, 0xff, 0x7d, 0xb1, 0x15, 0x09, 0xab, 0xe3, 0xda, 0xdc,
0x73, 0xae, 0x20, 0x4f, 0x2e, 0x1e, 0xc9, 0x67, 0x71, 0x81, 0xba, 0x48, 0x9d, 0x69, 0xd2, 0x7f, 0x5c, 0x37, 0xe3, 0xc0, 0x15, 0x84, 0xe4, 0xfc, 0x27, 0x61, 0x16, 0x17, 0xe8, 0x8b, 0xd4, 0x85,
0x74, 0x2a, 0xe7, 0xeb, 0x2a, 0xe7, 0xcf, 0xab, 0xcc, 0xb7, 0x4e, 0xa8, 0x7e, 0xf2, 0xf5, 0x3a, 0x26, 0xfd, 0x07, 0xe7, 0x72, 0xbe, 0xea, 0x72, 0xfe, 0xb4, 0xcb, 0x7c, 0xe3, 0x88, 0xfa, 0x27,
0x78, 0x8f, 0x1c, 0x2a, 0x59, 0x9d, 0xa9, 0xb6, 0x18, 0xd6, 0x85, 0xe4, 0x7e, 0xa0, 0xe0, 0xd0, 0x5f, 0xed, 0x83, 0x0f, 0xa8, 0xa1, 0x92, 0xd5, 0x95, 0x6a, 0x9b, 0x61, 0xd5, 0x48, 0xee, 0x07,
0x22, 0x8b, 0x13, 0x71, 0x2d, 0xcd, 0x84, 0x80, 0x65, 0xb5, 0xb0, 0x3a, 0xcf, 0x15, 0x16, 0x7f, 0x0a, 0x80, 0x16, 0x59, 0x9c, 0x88, 0x4b, 0x69, 0x26, 0x44, 0x2c, 0xcb, 0x8d, 0xd5, 0x79, 0xaa,
0x5c, 0x29, 0x4f, 0x44, 0xb3, 0xce, 0x9a, 0xb5, 0x5c, 0xda, 0x32, 0x0f, 0x0f, 0x56, 0xa5, 0xad, 0xb1, 0xf8, 0xc3, 0x52, 0x7b, 0x22, 0x9b, 0x75, 0xd5, 0xac, 0xd4, 0xd2, 0x86, 0xb9, 0xbf, 0xb7,
0xc8, 0x38, 0x2f, 0xd4, 0x79, 0x7a, 0xe8, 0x02, 0x4c, 0x26, 0xc9, 0xbc, 0xa8, 0x28, 0xc3, 0x44, 0x2e, 0x6d, 0x44, 0xc6, 0xa1, 0x50, 0xd7, 0xe9, 0xbe, 0x4b, 0x30, 0x85, 0x24, 0xf3, 0xa2, 0xa2,
0x68, 0xee, 0x0a, 0x80, 0x33, 0x09, 0x82, 0xef, 0x43, 0xf8, 0x8e, 0xf8, 0xe0, 0xc9, 0x81, 0xb6, 0x0a, 0x13, 0xa1, 0xb9, 0x2d, 0x40, 0xce, 0x64, 0x08, 0xd8, 0x87, 0xc0, 0x8e, 0xf4, 0xe0, 0x97,
0x7b, 0x5e, 0xb7, 0x1a, 0x88, 0xef, 0x82, 0xcb, 0x83, 0x83, 0x7d, 0x1f, 0xdb, 0x56, 0x46, 0xb4, 0x23, 0x6d, 0xf7, 0x7b, 0x35, 0x6a, 0x30, 0xbe, 0x4b, 0x2e, 0x0f, 0xf6, 0x76, 0x7d, 0x2c, 0x5b,
0x92, 0x55, 0x81, 0x59, 0x33, 0x4c, 0xac, 0xe8, 0x9c, 0xa9, 0x38, 0xfd, 0xdb, 0x90, 0x8a, 0x12, 0x1b, 0xd1, 0x52, 0x55, 0x05, 0x66, 0x25, 0x30, 0xb1, 0xe4, 0x73, 0xa6, 0xe2, 0xf4, 0x1f, 0x43,
0xd0, 0xe1, 0xd4, 0x57, 0x2e, 0xe9, 0x2d, 0xee, 0x43, 0x25, 0xb5, 0x19, 0xb0, 0x32, 0xe1, 0x54, 0x6a, 0x4a, 0x50, 0x87, 0x73, 0x5f, 0xb9, 0xa2, 0xb7, 0xbc, 0x0f, 0x97, 0xd4, 0x7a, 0xc2, 0xca,
0x97, 0x9b, 0xeb, 0xa4, 0x38, 0x7c, 0x4f, 0x9a, 0xb7, 0x3f, 0xc7, 0xb3, 0xb8, 0x61, 0xf0, 0x84, 0x84, 0x53, 0x5f, 0xae, 0xbf, 0x27, 0xc7, 0x81, 0x3d, 0x79, 0xde, 0xfe, 0x12, 0x5f, 0xc7, 0x8d,
0x30, 0xd6, 0x77, 0x39, 0x58, 0xa0, 0xba, 0xd3, 0xf0, 0x46, 0xa5, 0x77, 0x6b, 0x51, 0x50, 0x44, 0x82, 0x47, 0x82, 0xb1, 0xbe, 0xcd, 0xa1, 0x02, 0xdd, 0x9d, 0x86, 0x57, 0x2a, 0xbd, 0x5d, 0xc9,
0x1f, 0xa7, 0xe9, 0x60, 0x06, 0x1f, 0x13, 0x26, 0x8b, 0x5c, 0x94, 0x1e, 0x27, 0x35, 0x79, 0xe0, 0x82, 0x22, 0xf9, 0x38, 0x4d, 0x07, 0xd7, 0xc0, 0x98, 0x38, 0x59, 0xe4, 0xa2, 0xf4, 0x38, 0xb9,
0x01, 0x38, 0xee, 0xdf, 0x08, 0xf3, 0x9b, 0xe7, 0x3f, 0x3e, 0x4f, 0x27, 0xca, 0x52, 0x95, 0x50, 0xc9, 0x03, 0x0f, 0xc4, 0x71, 0xf7, 0x56, 0x98, 0x5f, 0x3d, 0xff, 0xe1, 0x69, 0x39, 0x51, 0x96,
0x0f, 0x74, 0x94, 0x31, 0x2a, 0x43, 0xe2, 0xab, 0xb1, 0xc7, 0x07, 0xb4, 0xce, 0x6a, 0x7b, 0x01, 0xaa, 0x84, 0x7b, 0x90, 0xa3, 0x8a, 0x51, 0x19, 0x0a, 0x5f, 0x8d, 0x3d, 0x3e, 0xa0, 0xf7, 0xac,
0x86, 0x6c, 0x24, 0x33, 0x61, 0xcd, 0xc0, 0x2d, 0x09, 0xc8, 0xe2, 0xe7, 0xf5, 0xba, 0x1a, 0x31, 0x8e, 0x17, 0x64, 0xc8, 0x46, 0x32, 0x13, 0x36, 0x0c, 0x9c, 0x92, 0xa0, 0x2c, 0x7e, 0x5a, 0xbf,
0x1c, 0x1c, 0xc9, 0x71, 0x55, 0xc6, 0xd6, 0x41, 0xce, 0x0c, 0x36, 0x8a, 0x25, 0xc1, 0xfc, 0xbf, 0x57, 0x23, 0x86, 0x8d, 0x23, 0x39, 0xae, 0xca, 0xd8, 0x02, 0xe4, 0xc2, 0x60, 0xa3, 0x58, 0x12,
0xf2, 0xb3, 0x3c, 0x51, 0xd3, 0x02, 0x7e, 0x12, 0xac, 0x88, 0xc7, 0x82, 0xa5, 0xb1, 0x89, 0xb7, 0xcd, 0xff, 0x27, 0x3f, 0xc9, 0x13, 0x35, 0x2d, 0x80, 0x93, 0x60, 0x45, 0x3c, 0x16, 0x2c, 0x8d,
0x00, 0xd2, 0x2b, 0x3e, 0x1d, 0x2e, 0xf2, 0xa0, 0x86, 0x78, 0xdc, 0x8f, 0x96, 0x19, 0x65, 0x03, 0x4d, 0xbc, 0x01, 0x92, 0x5e, 0xc2, 0x74, 0x38, 0xaf, 0x83, 0x9a, 0xe2, 0x71, 0x3e, 0x5a, 0x65,
0x27, 0xc9, 0x5d, 0x1e, 0x21, 0x17, 0xec, 0x9d, 0x99, 0xa8, 0xcc, 0xb7, 0xd7, 0xe8, 0x5e, 0xe0, 0x54, 0x0d, 0x9c, 0x2c, 0x77, 0x79, 0x84, 0x5a, 0xb0, 0x67, 0x66, 0xa2, 0x32, 0xdf, 0x1e, 0xa3,
0xd9, 0xfb, 0x35, 0x22, 0xea, 0x6c, 0x68, 0x54, 0x09, 0xf6, 0x74, 0x2b, 0x9e, 0x19, 0x31, 0x25, 0x3b, 0x81, 0x67, 0xcf, 0xd7, 0x88, 0xa4, 0xb3, 0xa1, 0x51, 0x25, 0xd4, 0xd3, 0xa9, 0x78, 0x62,
0x0f, 0x24, 0x67, 0x05, 0x70, 0xfa, 0xe1, 0xa1, 0x26, 0xc3, 0xe9, 0x69, 0x01, 0xcd, 0x7f, 0x01, 0xc4, 0x94, 0x10, 0x48, 0x4e, 0x0a, 0xf0, 0xf4, 0xfd, 0x7d, 0x2d, 0x86, 0xdd, 0xd3, 0x02, 0x9e,
0x3f, 0xf6, 0x4e, 0xa5, 0x22, 0x64, 0x97, 0x99, 0x88, 0xb5, 0x60, 0xf0, 0x08, 0x32, 0xfd, 0xfa, 0xbf, 0x81, 0x3e, 0xf6, 0x5e, 0xa5, 0x22, 0x64, 0xe7, 0x99, 0x88, 0xb5, 0x60, 0x40, 0x04, 0x95,
0x7c, 0x70, 0xca, 0xce, 0x2e, 0xa1, 0x5b, 0xb0, 0xc6, 0x51, 0xaf, 0x73, 0x0c, 0x2c, 0x37, 0x1f, 0x7e, 0x79, 0x3a, 0x38, 0x66, 0x27, 0xe7, 0xf0, 0x2d, 0x58, 0xd1, 0xa8, 0x57, 0x35, 0x06, 0x56,
0xa9, 0x97, 0x69, 0x71, 0xef, 0x32, 0x12, 0xaa, 0xc5, 0x66, 0x42, 0x19, 0x17, 0x28, 0x42, 0xe5, 0x9b, 0x8f, 0xd2, 0xcb, 0xb4, 0xb8, 0x73, 0x15, 0x09, 0xd7, 0x62, 0x33, 0xa1, 0x8a, 0x0b, 0x14,
0x0c, 0xed, 0x86, 0xd7, 0x41, 0x66, 0x21, 0x4c, 0xda, 0xa6, 0x10, 0x6f, 0x73, 0xff, 0xf5, 0x6e, 0xb1, 0x72, 0x86, 0x71, 0xc3, 0xeb, 0xa0, 0xb2, 0x90, 0x26, 0x6d, 0x4b, 0x88, 0xb7, 0xb9, 0xff,
0xa7, 0x6b, 0xd1, 0x75, 0xcf, 0x0f, 0x75, 0x91, 0x49, 0x63, 0x57, 0x91, 0x2f, 0x2e, 0x1b, 0xfb, 0x7a, 0xbb, 0xd3, 0xb5, 0xec, 0xba, 0xe3, 0x87, 0xba, 0xc8, 0xa4, 0xb1, 0x6f, 0x51, 0x2f, 0xae,
0xfb, 0xdb, 0xdb, 0x9e, 0x0a, 0x0b, 0x55, 0x78, 0x14, 0x2b, 0xf7, 0xbb, 0xe8, 0x14, 0x96, 0xd6, 0x1a, 0xfb, 0xbb, 0x9b, 0x9b, 0x9e, 0x0a, 0x0b, 0x55, 0x78, 0x94, 0x2b, 0xf7, 0x77, 0x3e, 0x29,
0x07, 0xb5, 0xf5, 0xce, 0x2a, 0x13, 0x4e, 0x94, 0x36, 0x24, 0x7a, 0x07, 0x88, 0x46, 0xfd, 0xc9, 0x2c, 0xa2, 0x0f, 0xea, 0xe8, 0x5d, 0x54, 0x26, 0x9c, 0x28, 0x6d, 0xc8, 0xf4, 0x16, 0x18, 0x8d,
0x6b, 0xde, 0xc5, 0x2d, 0x6d, 0x1f, 0xbb, 0x9c, 0xfb, 0x3b, 0x10, 0xb2, 0xa3, 0xc2, 0xcf, 0x4a, 0xe6, 0x93, 0xd7, 0xbc, 0x8b, 0x53, 0xda, 0xfe, 0xec, 0x72, 0xee, 0x6f, 0xc1, 0xc8, 0x96, 0x0a,
0xe6, 0x56, 0x9e, 0xff, 0x58, 0xa7, 0xf0, 0x93, 0x2b, 0xb4, 0xad, 0x71, 0x93, 0xbd, 0x2e, 0xa2, 0xbf, 0x28, 0x99, 0x5b, 0x7b, 0xfe, 0x43, 0x5d, 0xc2, 0x8f, 0x8e, 0xd0, 0xb6, 0xc6, 0x49, 0xf6,
0x0e, 0x3c, 0xb0, 0xd5, 0xb1, 0xb2, 0xa1, 0x51, 0x1a, 0x0e, 0x47, 0x61, 0x6c, 0x03, 0x15, 0x3d, 0xba, 0x88, 0x3a, 0x40, 0x60, 0xa3, 0x63, 0x6d, 0xc3, 0xa3, 0x34, 0x1c, 0x8e, 0xc2, 0xd8, 0x26,
0x3d, 0x42, 0x17, 0x36, 0xf1, 0x5c, 0x76, 0x29, 0x8e, 0x64, 0xd1, 0x7e, 0x90, 0xf3, 0x5f, 0x37, 0x2a, 0x7a, 0xbc, 0x85, 0x0e, 0x6c, 0xd2, 0xb9, 0x98, 0x52, 0x9c, 0xc8, 0x7c, 0xfc, 0x20, 0xf0,
0x56, 0x40, 0x17, 0x28, 0x63, 0x15, 0xb7, 0xaa, 0x99, 0xc7, 0x56, 0xaf, 0x5d, 0x37, 0x4c, 0x3d, 0x5f, 0x37, 0x51, 0xc0, 0x17, 0x38, 0x63, 0x1d, 0xb7, 0xae, 0x99, 0x87, 0x56, 0xaf, 0x5d, 0x0f,
0x6d, 0xee, 0xd0, 0x3f, 0xfd, 0x55, 0x4e, 0x49, 0x73, 0x56, 0x95, 0x19, 0x4a, 0x87, 0x96, 0xc2, 0x4c, 0x3d, 0x6d, 0x6e, 0x31, 0x3f, 0xfd, 0x5d, 0x4e, 0xc9, 0x73, 0x56, 0x95, 0x19, 0x5a, 0x87,
0x44, 0x03, 0x9d, 0x0e, 0x41, 0x68, 0x09, 0x7a, 0x6d, 0xd7, 0xff, 0x51, 0x25, 0x20, 0x41, 0xc9, 0x5e, 0x85, 0x89, 0x06, 0x3b, 0xed, 0x43, 0xd0, 0x0a, 0xf4, 0xda, 0x6e, 0xfe, 0xa3, 0x4e, 0x40,
0x18, 0x40, 0x0b, 0xee, 0x85, 0x7e, 0x0f, 0x10, 0x3e, 0x6d, 0x31, 0x82, 0x00, 0x7a, 0xfa, 0x5d, 0x81, 0x52, 0x30, 0xa0, 0x16, 0x9c, 0x0b, 0xfd, 0x1e, 0x28, 0x7c, 0xda, 0x62, 0x44, 0x01, 0xf4,
0x73, 0xe6, 0x40, 0x60, 0x38, 0xe2, 0x0c, 0x8d, 0xe1, 0x44, 0x61, 0xa7, 0x80, 0xb7, 0x40, 0x9a, 0xeb, 0x37, 0xcd, 0x99, 0x23, 0x81, 0xe1, 0x88, 0x33, 0x0c, 0x86, 0x13, 0x85, 0x95, 0x02, 0x68,
0xca, 0x19, 0xb3, 0x6d, 0x0c, 0xa0, 0x43, 0x41, 0xb7, 0xf9, 0xfa, 0xda, 0x44, 0x64, 0xc5, 0x31, 0x41, 0x34, 0x95, 0xd7, 0xcc, 0x8e, 0x31, 0xa0, 0x0e, 0x05, 0xdf, 0x66, 0xab, 0xef, 0x26, 0x22,
0xef, 0xb7, 0x7a, 0xa8, 0x40, 0x43, 0x7d, 0x92, 0x05, 0x19, 0xf7, 0xc2, 0x21, 0x35, 0x41, 0x84, 0x2b, 0x0e, 0x79, 0xbf, 0xd5, 0x43, 0x07, 0x1a, 0x9a, 0x93, 0x2c, 0xc9, 0xb8, 0x07, 0x0e, 0xab,
0xbf, 0x44, 0xfc, 0x2d, 0x89, 0x7d, 0xdd, 0x6b, 0xbb, 0x0d, 0xa8, 0x06, 0x16, 0xfd, 0xe7, 0xcf, 0x09, 0x32, 0xfc, 0x35, 0xe2, 0xef, 0xc8, 0xec, 0xeb, 0x5e, 0xdb, 0x2d, 0xc0, 0x35, 0xa8, 0xe8,
0xb4, 0x16, 0x87, 0x8e, 0xe9, 0xd0, 0x71, 0x9c, 0x7c, 0x59, 0x9e, 0x5b, 0x3b, 0xa1, 0xab, 0x9b, 0x3f, 0xbd, 0xa7, 0x35, 0xdf, 0x74, 0x48, 0x9b, 0x0e, 0xe3, 0xe4, 0xeb, 0x62, 0xdf, 0xca, 0x0e,
0xa9, 0x84, 0x8e, 0xc3, 0x78, 0x26, 0xd8, 0x36, 0x03, 0x7c, 0xe6, 0x40, 0xf9, 0x25, 0xf1, 0xa4, 0x5d, 0x5d, 0x4d, 0x25, 0x7c, 0x1c, 0xc6, 0xd7, 0x82, 0x6d, 0x32, 0xd0, 0x67, 0x0e, 0x96, 0x5f,
0x84, 0x5e, 0x4e, 0xd2, 0x64, 0xdf, 0x35, 0xa1, 0x08, 0x47, 0x55, 0xc0, 0x31, 0xfb, 0x58, 0x3a, 0x08, 0x4f, 0x4a, 0xf8, 0xe5, 0x2c, 0x4d, 0x76, 0xdd, 0x10, 0x8a, 0x74, 0x54, 0x05, 0x80, 0xd9,
0xe8, 0xd7, 0x27, 0xd0, 0xdc, 0x31, 0x71, 0x8b, 0x4a, 0xa7, 0x32, 0xad, 0x61, 0x1c, 0x34, 0x07, 0xc5, 0xab, 0xbd, 0x7e, 0xbd, 0x03, 0xc3, 0x1d, 0x13, 0x37, 0xe8, 0x74, 0x6a, 0xd3, 0x9a, 0xc6,
0x0b, 0x71, 0xad, 0x75, 0x0d, 0xc9, 0x6f, 0xb6, 0x3f, 0x5a, 0xda, 0x77, 0x41, 0xaa, 0x12, 0x28, 0x21, 0xb3, 0x37, 0x37, 0xd7, 0x5a, 0xf5, 0x90, 0x70, 0xb3, 0xf3, 0xd1, 0x22, 0xbe, 0x33, 0x72,
0xae, 0xa8, 0x0a, 0xe9, 0x17, 0x8e, 0x99, 0xf5, 0x2e, 0xf3, 0x2c, 0x60, 0x32, 0x81, 0xda, 0xba, 0x95, 0x48, 0x71, 0xc9, 0x55, 0x58, 0x3f, 0x73, 0xca, 0x2c, 0xba, 0xcc, 0xb3, 0x84, 0xc9, 0x04,
0x23, 0x91, 0xb9, 0x32, 0x84, 0x08, 0xa4, 0x81, 0xdf, 0x25, 0xf2, 0x9e, 0xc5, 0x6a, 0xb6, 0x82, 0x7a, 0xeb, 0x96, 0x4c, 0xe6, 0xca, 0x10, 0x23, 0x90, 0x07, 0x7e, 0x97, 0xc4, 0x7b, 0x96, 0xab,
0xd3, 0xac, 0x46, 0xe9, 0xa6, 0xb3, 0xa6, 0xc7, 0x05, 0x28, 0x47, 0xfc, 0x60, 0x9f, 0x5b, 0x39, 0xd9, 0x12, 0x4f, 0xb3, 0x9a, 0xa5, 0x9b, 0xc9, 0x9a, 0x7e, 0xce, 0x49, 0x39, 0xe2, 0x7b, 0xbb,
0x8d, 0x98, 0x02, 0x21, 0xc1, 0x43, 0xfa, 0x94, 0x5b, 0xb3, 0xb3, 0xe4, 0x74, 0xb9, 0xc6, 0xe9, 0xdc, 0xda, 0x69, 0xcc, 0x14, 0x48, 0x09, 0x7e, 0xa4, 0x8f, 0xb5, 0x35, 0x2b, 0x0b, 0x4d, 0xe7,
0xa7, 0x03, 0xc7, 0x69, 0x68, 0x00, 0x27, 0x09, 0x8a, 0x9b, 0xe1, 0x8a, 0x27, 0xb7, 0xc6, 0x86, 0x2b, 0x9a, 0x5e, 0xee, 0x39, 0x4d, 0x43, 0x03, 0x3a, 0x49, 0xd0, 0xdc, 0x0c, 0x47, 0x3c, 0xc1,
0xed, 0x85, 0xf6, 0x1f, 0x43, 0xaa, 0xb0, 0xd3, 0xb7, 0x27, 0x97, 0x6b, 0xca, 0xd6, 0xec, 0xce, 0x1a, 0x1b, 0xb6, 0x13, 0xda, 0xff, 0x18, 0x4a, 0x85, 0x1d, 0xbf, 0x3b, 0x3a, 0x5f, 0x71, 0xb6,
0xf6, 0x78, 0x2d, 0x29, 0xaf, 0xa6, 0x37, 0xa2, 0xe4, 0x4d, 0x7e, 0x20, 0xb5, 0xa6, 0x32, 0x8f, 0x56, 0x77, 0xb2, 0xc3, 0x6b, 0x4b, 0x79, 0x35, 0xbd, 0x12, 0x25, 0x6f, 0xea, 0x03, 0xa5, 0x35,
0xf8, 0x9e, 0x15, 0x17, 0xf1, 0xfd, 0x1f, 0x7f, 0xe4, 0xac, 0x14, 0xff, 0xa9, 0x24, 0xba, 0xb6, 0x95, 0x79, 0xc4, 0x77, 0xac, 0xb9, 0x88, 0xef, 0xfe, 0xf4, 0x13, 0x67, 0xa5, 0xf8, 0xa3, 0x92,
0x3e, 0x0b, 0xd9, 0x06, 0x9f, 0xce, 0x77, 0xe2, 0xb3, 0xff, 0x9d, 0xf8, 0x1c, 0x7c, 0x13, 0x9f, 0x98, 0xda, 0xfa, 0x2c, 0x64, 0x6b, 0x7a, 0x3a, 0x3f, 0x48, 0xcf, 0xee, 0x0f, 0xd2, 0xb3, 0xf7,
0x15, 0x57, 0x8e, 0x31, 0x50, 0xcc, 0xe3, 0xbb, 0x6e, 0x6b, 0xc5, 0x69, 0x8e, 0xf7, 0x9b, 0x6f, 0x5d, 0x7a, 0x96, 0xa0, 0x1c, 0xe3, 0x42, 0x31, 0x8b, 0x6f, 0xbb, 0xad, 0x25, 0xd0, 0x9c, 0xee,
0xf6, 0x59, 0x6b, 0x9d, 0xcf, 0x77, 0xf2, 0xd9, 0x9b, 0xef, 0xe4, 0xb3, 0x37, 0xdf, 0xee, 0xb3, 0xb7, 0xdf, 0x8d, 0x59, 0x6b, 0x55, 0xcf, 0x0f, 0xc2, 0xec, 0xed, 0x0f, 0xc2, 0xec, 0xed, 0xf7,
0x56, 0xed, 0x34, 0x54, 0x36, 0xea, 0x10, 0x54, 0xfa, 0x4b, 0xf7, 0x89, 0xdf, 0x86, 0xff, 0x83, 0x63, 0xd6, 0xaa, 0x41, 0x43, 0x67, 0xa3, 0x0f, 0x21, 0xa5, 0xbf, 0x76, 0x1f, 0xe1, 0x36, 0xfc,
0xdf, 0x5a, 0x5f, 0x55, 0xb4, 0xe6, 0xd3, 0xf9, 0x4e, 0x7c, 0xf6, 0xbf, 0x13, 0x9f, 0x83, 0x6f, 0x1f, 0x70, 0x6b, 0x7d, 0xd3, 0xd1, 0x5a, 0x4f, 0xe7, 0x07, 0xe9, 0xd9, 0xfd, 0x41, 0x7a, 0xf6,
0xe3, 0x43, 0x0e, 0x9a, 0x9e, 0x5e, 0x0c, 0x19, 0x9a, 0x16, 0x0c, 0x89, 0xba, 0x29, 0x5d, 0x07, 0xbe, 0x4f, 0x0f, 0x01, 0x34, 0x3d, 0x3e, 0x1b, 0x32, 0x0c, 0x2d, 0xb8, 0x24, 0xea, 0xa6, 0x75,
0x34, 0x54, 0xb5, 0xb9, 0x62, 0x44, 0xe0, 0x0a, 0xd7, 0x0e, 0xd2, 0xed, 0x76, 0x2d, 0xbb, 0xb5, 0x1d, 0xd1, 0x50, 0xd7, 0xe6, 0x8a, 0x91, 0x80, 0x6b, 0x5c, 0x7b, 0x91, 0x6e, 0xb7, 0x6b, 0xdb,
0x06, 0x37, 0x35, 0x36, 0xbc, 0x7b, 0x82, 0x32, 0xcc, 0x76, 0x1a, 0x19, 0x9d, 0x3f, 0xc9, 0x24, 0xad, 0x15, 0xba, 0xa9, 0xb9, 0xe1, 0xfd, 0x23, 0x96, 0x61, 0x76, 0xd2, 0xc8, 0x68, 0xff, 0x51,
0xda, 0x00, 0x40, 0x44, 0x97, 0xf5, 0x74, 0x11, 0xe7, 0x0b, 0x2d, 0x65, 0x81, 0x7b, 0xe0, 0x62, 0x26, 0x31, 0x06, 0x80, 0x22, 0xba, 0xac, 0xa7, 0x8b, 0x38, 0x9f, 0x7b, 0x29, 0x0b, 0x9c, 0x03,
0x09, 0x6a, 0x22, 0xc5, 0x4d, 0x04, 0x02, 0xab, 0x60, 0x0d, 0xb7, 0xb6, 0xfd, 0x11, 0xec, 0x28, 0x67, 0x0b, 0x52, 0x13, 0x29, 0x4e, 0x22, 0x08, 0x58, 0x07, 0x6b, 0xba, 0xb5, 0xe3, 0x8f, 0x60,
0x49, 0x48, 0xd1, 0x4b, 0x5c, 0xb5, 0xc6, 0x22, 0x6d, 0xeb, 0xe8, 0x92, 0x11, 0x3c, 0x3e, 0xab, 0x07, 0x49, 0x42, 0x8e, 0x9e, 0xe3, 0xa8, 0x35, 0x96, 0x69, 0x5b, 0x07, 0xe7, 0x8c, 0xe8, 0xf1,
0xfb, 0xd1, 0xe5, 0x8b, 0xf8, 0xe8, 0x14, 0x3e, 0x7a, 0x0a, 0x8b, 0xb6, 0xdc, 0xde, 0x62, 0xd8, 0x49, 0xdf, 0x0f, 0xce, 0x9f, 0xe5, 0x47, 0xe7, 0xf0, 0xc1, 0x63, 0x5a, 0xb4, 0xed, 0xf6, 0x0e,
0xc6, 0x69, 0x4b, 0xd5, 0x65, 0x6b, 0xc7, 0x93, 0x89, 0x48, 0xbe, 0xdc, 0xa8, 0xdb, 0x05, 0x8b, 0x97, 0x6d, 0xec, 0xb6, 0x52, 0x5d, 0xb6, 0xb2, 0x3d, 0x99, 0x88, 0xe4, 0xeb, 0x95, 0xba, 0x99,
0xb7, 0x0e, 0x00, 0x49, 0x91, 0x06, 0x2c, 0x9f, 0x2a, 0x43, 0x13, 0xb5, 0xff, 0x35, 0x74, 0xad, 0xab, 0x78, 0xe7, 0x08, 0x90, 0x1c, 0x69, 0xc8, 0xf2, 0xb1, 0x33, 0x74, 0xa3, 0xf6, 0xbf, 0xc5,
0x99, 0x5d, 0xba, 0x48, 0xad, 0xa0, 0x2b, 0x98, 0x1a, 0xf4, 0x4e, 0x88, 0xa2, 0x17, 0xde, 0xbf, 0xae, 0xb5, 0xb2, 0x73, 0x97, 0xa9, 0x25, 0x76, 0x85, 0x52, 0x83, 0xd9, 0x09, 0x59, 0xf4, 0xc2,
0x0a, 0x7e, 0x3a, 0x78, 0xf4, 0x1f, 0x70, 0x67, 0x30, 0xfb, 0x2d, 0x24, 0xe2, 0x03, 0x2b, 0x02, 0xbb, 0x57, 0xc1, 0xcb, 0xbd, 0x07, 0xff, 0x1e, 0x67, 0x06, 0xb3, 0xdf, 0x42, 0x22, 0x3e, 0xb0,
0x12, 0x10, 0xe8, 0x90, 0xbd, 0xb2, 0x9f, 0x6b, 0xd0, 0x4a, 0x88, 0x52, 0x37, 0x6a, 0xad, 0x78, 0x26, 0x60, 0x01, 0x89, 0x0e, 0xd9, 0x2b, 0xfb, 0xb9, 0x06, 0xa3, 0x84, 0x28, 0x75, 0xe3, 0xd6,
0x8c, 0xd9, 0xab, 0x8c, 0x46, 0xbd, 0x5c, 0x64, 0xdd, 0xf5, 0x24, 0x3a, 0x3a, 0x79, 0x21, 0x89, 0x12, 0x62, 0xcc, 0x1e, 0x65, 0x74, 0xd5, 0xcb, 0x45, 0xd6, 0x5d, 0x2d, 0xa2, 0x83, 0xa3, 0x67,
0x6e, 0x9b, 0x2c, 0xea, 0x34, 0x59, 0xd4, 0x39, 0xd8, 0x48, 0x22, 0x98, 0x4e, 0x06, 0x6a, 0x0a, 0x8a, 0xe8, 0xa6, 0xa9, 0xa2, 0x4e, 0x53, 0x45, 0x9d, 0xbd, 0xb5, 0x22, 0x42, 0xe8, 0x14, 0xa0,
0xac, 0x1d, 0x98, 0x1a, 0x9e, 0xb8, 0xe0, 0x7b, 0x6e, 0x34, 0x62, 0x6e, 0x02, 0x40, 0x2a, 0x52, 0xa6, 0xc4, 0xda, 0x0b, 0x53, 0xa3, 0x13, 0x07, 0x7c, 0xcf, 0x5d, 0x8d, 0x98, 0xbb, 0x01, 0xa0,
0xa8, 0x9b, 0x48, 0xd3, 0x46, 0x3c, 0xa2, 0xd6, 0xf0, 0x46, 0x29, 0x04, 0xd4, 0xd1, 0x6e, 0x9e, 0x14, 0x29, 0xd5, 0x4d, 0xa6, 0x69, 0x21, 0x1e, 0xd1, 0x68, 0x78, 0xa5, 0x14, 0x12, 0xea, 0x64,
0xe9, 0xf0, 0xfe, 0xa9, 0xd4, 0x2b, 0xc9, 0xb1, 0x41, 0xd6, 0xaa, 0xe9, 0x10, 0xbd, 0xa3, 0x0c, 0xd7, 0xf7, 0x74, 0x78, 0xff, 0x58, 0xea, 0xa5, 0xe2, 0x58, 0x13, 0x6b, 0xd5, 0x72, 0xc8, 0xde,
0x90, 0xa9, 0x5f, 0x62, 0x84, 0xbb, 0xea, 0x42, 0xcc, 0x20, 0xcd, 0xa3, 0x2b, 0xb4, 0x14, 0x68, 0x41, 0x06, 0xca, 0xd4, 0xcf, 0x29, 0xc2, 0x59, 0x75, 0x26, 0xae, 0x61, 0xcd, 0xa3, 0x23, 0xb4,
0x9b, 0xa7, 0xe8, 0x1f, 0x45, 0xea, 0x2f, 0x4e, 0x50, 0xb7, 0x64, 0x4d, 0x68, 0x0c, 0x7b, 0x3e, 0x14, 0x18, 0x9b, 0xa7, 0x98, 0x1f, 0x45, 0xea, 0xcf, 0x77, 0xd0, 0xb4, 0x64, 0x43, 0x68, 0x02,
0x5d, 0x29, 0x5b, 0xa9, 0x63, 0x9b, 0x89, 0x8d, 0x54, 0x1d, 0xdc, 0x16, 0xa2, 0x94, 0xf4, 0x15, 0x7b, 0xba, 0x5c, 0xa9, 0x5a, 0x69, 0x62, 0xbb, 0x16, 0x6b, 0xa5, 0x3a, 0xb8, 0x29, 0x44, 0x29,
0x08, 0x49, 0x6f, 0x13, 0xf4, 0xd4, 0x8d, 0x6b, 0xce, 0xf7, 0x3a, 0x13, 0xa2, 0xf8, 0x83, 0x8c, 0xe9, 0x2b, 0x10, 0x8a, 0xde, 0x16, 0xe8, 0x1b, 0x55, 0x26, 0x82, 0xbd, 0xda, 0xd9, 0x0d, 0x3b,
0xba, 0x1e, 0xba, 0xd0, 0xf5, 0x64, 0xbf, 0x75, 0x02, 0xb9, 0xd4, 0x29, 0xb1, 0x39, 0x5a, 0xdc, 0x9d, 0x31, 0x9b, 0x62, 0x2a, 0x66, 0xde, 0x60, 0x78, 0xfe, 0x6a, 0xf7, 0xe5, 0x4b, 0x1a, 0xae,
0x85, 0xd7, 0x66, 0x12, 0x31, 0x97, 0x5a, 0x57, 0x42, 0x87, 0x36, 0xc8, 0xa7, 0xae, 0x29, 0x10, 0x6e, 0xfd, 0x3f, 0x29, 0xb0, 0x37, 0x6f, 0xeb, 0x4c, 0x1e, 0xbb, 0x7b, 0x9f, 0x4b, 0xa2, 0xce,
0xb9, 0x95, 0x24, 0x47, 0x4e, 0x98, 0xd4, 0x8c, 0x6e, 0x77, 0x6a, 0x4e, 0x12, 0x55, 0xc2, 0x5c, 0x84, 0x28, 0xfe, 0x64, 0xe7, 0xe5, 0xd0, 0xed, 0xec, 0xc9, 0x7e, 0xeb, 0x08, 0x01, 0xd0, 0xc8,
0x93, 0xdd, 0x05, 0x4c, 0xe6, 0xf4, 0xb1, 0x4a, 0x0b, 0xcd, 0x0a, 0x35, 0x87, 0x2f, 0x68, 0x28, 0xc5, 0x66, 0x98, 0x95, 0xe7, 0xf0, 0x5f, 0x4b, 0x14, 0x8f, 0xd4, 0xba, 0x12, 0x3a, 0x74, 0x36,
0xa9, 0xa6, 0xd6, 0xfa, 0xb0, 0xd7, 0x96, 0xd6, 0x8a, 0xd6, 0x60, 0x78, 0xb9, 0x7b, 0xf1, 0xfe, 0xdc, 0x74, 0x21, 0x72, 0x6b, 0x49, 0x8e, 0x9c, 0x31, 0xa9, 0x19, 0x8d, 0x09, 0x34, 0xe5, 0x24,
0x1a, 0x7c, 0x4a, 0x78, 0x43, 0x6b, 0xd7, 0xd5, 0x50, 0xfb, 0x46, 0x8d, 0xc5, 0x85, 0xc2, 0x3e, 0xaa, 0x04, 0x6e, 0x26, 0xbb, 0x0d, 0x98, 0xcc, 0xe9, 0xab, 0x97, 0x16, 0x9a, 0x15, 0x6a, 0x06,
0xb6, 0x17, 0x39, 0x62, 0x3f, 0x4e, 0x41, 0xe1, 0xe6, 0x7d, 0x1e, 0x97, 0x39, 0x02, 0x7d, 0x35, 0x50, 0xe9, 0x76, 0x53, 0x4d, 0x2d, 0x8c, 0x61, 0xaf, 0x2d, 0x2d, 0x1c, 0x2d, 0x44, 0xba, 0x7d,
0x81, 0x0a, 0x23, 0x59, 0x4e, 0xf1, 0x2e, 0xd8, 0x4d, 0x85, 0x69, 0x8a, 0xa5, 0x0a, 0x92, 0x49, 0xf6, 0xe1, 0x12, 0x7a, 0x4a, 0xc0, 0xaa, 0xb5, 0x1b, 0x8f, 0x68, 0x0e, 0xa4, 0x09, 0xe5, 0x4c,
0x59, 0xe8, 0x91, 0x55, 0x28, 0xb3, 0x46, 0x94, 0xae, 0x0a, 0x6a, 0x4b, 0xad, 0x41, 0x56, 0x0f, 0x61, 0x1d, 0xcb, 0xf3, 0x62, 0xb3, 0x5f, 0xb9, 0xe0, 0x70, 0xf3, 0x3c, 0x8b, 0xcb, 0x1c, 0x15,
0xd7, 0x80, 0x91, 0xcc, 0x16, 0x09, 0xad, 0x45, 0xf6, 0x07, 0xce, 0xc8, 0xfa, 0xd8, 0x1f, 0xf8, 0x73, 0x31, 0x81, 0x0b, 0x23, 0x59, 0x4e, 0xf1, 0x2c, 0xd8, 0x55, 0x85, 0x6b, 0x19, 0x4b, 0x15,
0xf2, 0xc3, 0x60, 0xe9, 0x4b, 0x37, 0x92, 0xd9, 0x72, 0x14, 0x34, 0xa2, 0x69, 0xa6, 0x28, 0x17, 0x2c, 0x93, 0xb3, 0xf0, 0x23, 0xab, 0x80, 0x6a, 0x63, 0x4a, 0x57, 0x05, 0xcd, 0xb7, 0x36, 0x20,
0x6a, 0x46, 0xd6, 0x8f, 0xbf, 0x22, 0x3a, 0xac, 0x99, 0xaf, 0xc9, 0x8f, 0xa4, 0x68, 0xa5, 0xc9, 0xeb, 0x87, 0x9b, 0xe4, 0xc8, 0x66, 0x8b, 0x8c, 0xd6, 0x26, 0xfb, 0x03, 0x17, 0x64, 0xbd, 0xed,
0x83, 0x31, 0xa3, 0x2f, 0x1b, 0x18, 0xb1, 0x70, 0x7c, 0x5e, 0x7b, 0x85, 0xd1, 0xd8, 0xf8, 0x75, 0x4f, 0xb0, 0xfc, 0x38, 0x58, 0x60, 0xe9, 0xee, 0x76, 0xb6, 0xaf, 0x05, 0xdd, 0xf5, 0x34, 0x53,
0x8f, 0xb6, 0x1a, 0x73, 0x2e, 0x63, 0x2a, 0x17, 0xf6, 0xc1, 0x31, 0x79, 0x77, 0x74, 0xb2, 0xa1, 0x54, 0x54, 0xb5, 0x22, 0x8b, 0xe3, 0x2f, 0xc8, 0x0e, 0x6b, 0x2e, 0xea, 0x84, 0x23, 0x39, 0x5a,
0xf9, 0x2a, 0x2c, 0x7d, 0x78, 0x47, 0xd5, 0x88, 0xa2, 0x6b, 0x70, 0xa0, 0xb3, 0xbf, 0x8e, 0x0b, 0x69, 0x42, 0x30, 0x66, 0xf4, 0x89, 0x04, 0x77, 0x35, 0x6c, 0x9f, 0xd5, 0xa8, 0x30, 0xba, 0x7f,
0x9d, 0xba, 0x7f, 0x3b, 0x8f, 0xb5, 0x61, 0xee, 0xdb, 0x2b, 0x3a, 0x54, 0x91, 0x6f, 0xa4, 0x6a, 0x7e, 0x1b, 0xd1, 0x56, 0x13, 0xce, 0x79, 0x4c, 0x7d, 0xc7, 0x3e, 0x3a, 0x25, 0xef, 0x0f, 0x8e,
0x99, 0xc9, 0x74, 0xb5, 0x2f, 0xb6, 0x83, 0x06, 0x31, 0xaf, 0xe7, 0x71, 0x83, 0xf8, 0xac, 0x7e, 0xd6, 0x3c, 0x5f, 0xe6, 0xb7, 0x8f, 0xef, 0xa9, 0xad, 0xd1, 0xbd, 0x0d, 0xa1, 0x74, 0x76, 0x57,
0x40, 0xe0, 0xcc, 0x0e, 0x00, 0x70, 0x63, 0x55, 0x6a, 0x55, 0x76, 0x0b, 0x02, 0x0d, 0x40, 0x01, 0x09, 0xa6, 0x53, 0x0f, 0x82, 0xa7, 0xb1, 0x36, 0xcc, 0x7d, 0xc4, 0xc5, 0xa8, 0x2b, 0xf2, 0xb5,
0xd2, 0x3d, 0x6f, 0x12, 0xbd, 0x36, 0x68, 0x11, 0x1b, 0x0a, 0x0d, 0x1a, 0xff, 0x94, 0xbb, 0xf4, 0x9a, 0x2f, 0x33, 0x99, 0x2e, 0x0f, 0xd8, 0xf6, 0xc6, 0x42, 0xca, 0xeb, 0x8b, 0xbd, 0x41, 0x7e,
0xa7, 0x2f, 0x1a, 0x74, 0x03, 0x5f, 0xc1, 0x28, 0x97, 0x34, 0x6b, 0x88, 0x30, 0xb8, 0x7a, 0xcb, 0x96, 0xbf, 0x44, 0x70, 0x66, 0x6f, 0x12, 0x80, 0xb1, 0x2a, 0xb5, 0x2a, 0xbb, 0x05, 0xb1, 0x0f,
0x9f, 0xd4, 0xed, 0x5e, 0x23, 0xe0, 0xf9, 0xaa, 0xfd, 0x0b, 0xca, 0xfa, 0xf8, 0x64, 0xcb, 0x4d, 0x38, 0x05, 0x7d, 0x93, 0x37, 0x1d, 0x53, 0x07, 0x34, 0xcf, 0x0d, 0xa5, 0x06, 0x37, 0x88, 0x94,
0x8f, 0xbf, 0xfd, 0x70, 0x80, 0x8e, 0x9d, 0xe6, 0x5d, 0xdc, 0xf7, 0x88, 0xd2, 0x4a, 0xe1, 0xae, 0xbb, 0x3e, 0xa2, 0x4f, 0x23, 0x74, 0x94, 0x5f, 0x20, 0x28, 0x57, 0x34, 0x2b, 0xd4, 0x32, 0xb8,
0x9f, 0x82, 0x87, 0x10, 0xd9, 0x83, 0xfd, 0xdd, 0xcb, 0xf7, 0x83, 0x97, 0x38, 0xff, 0x54, 0xd3, 0x78, 0xc7, 0x1f, 0x11, 0xc0, 0x4e, 0x63, 0xe0, 0xe9, 0xf6, 0xff, 0x1b, 0xf8, 0xe1, 0xf0, 0x68,
0x9c, 0x8a, 0xea, 0xf6, 0x45, 0x54, 0xf9, 0x99, 0xf7, 0x7f, 0x3d, 0xbb, 0xda, 0xfd, 0xed, 0x45, 0xc3, 0x5d, 0x43, 0x7f, 0x7d, 0xb1, 0x87, 0xd1, 0x9f, 0x2e, 0xce, 0x18, 0x1c, 0x90, 0xa5, 0x25,
0x2e, 0xaf, 0x78, 0xff, 0xef, 0x95, 0xcc, 0xa1, 0xdd, 0xee, 0xa9, 0x1c, 0xef, 0xbe, 0x4f, 0x4c, 0x06, 0x58, 0xdd, 0x05, 0x84, 0x90, 0xd9, 0xbd, 0xdd, 0xed, 0xf3, 0x0f, 0x83, 0xe7, 0x34, 0xbf,
0x0c, 0x15, 0xaf, 0x76, 0x61, 0xeb, 0x9a, 0xf0, 0x4d, 0x0d, 0x7f, 0x58, 0x9e, 0xb3, 0x5a, 0xbc, 0xac, 0x65, 0x8e, 0x45, 0x75, 0xf3, 0x2c, 0x3d, 0xfd, 0xcc, 0xfb, 0xbf, 0x9c, 0x5c, 0x6c, 0xff,
0x08, 0x7f, 0xf0, 0xcf, 0x50, 0x94, 0xe3, 0x9f, 0x7f, 0x20, 0x96, 0x2b, 0x74, 0x9b, 0x0c, 0x7f, 0xfa, 0xac, 0x96, 0x57, 0xbc, 0xff, 0xcf, 0x4a, 0xe6, 0xf0, 0x6e, 0xfb, 0x58, 0x8e, 0xb7, 0x3f,
0xe4, 0xfd, 0xab, 0xb9, 0xcc, 0xe4, 0x78, 0x62, 0xce, 0x71, 0xa9, 0x7c, 0x9d, 0x2b, 0xb0, 0xf0, 0x24, 0x26, 0x86, 0x8b, 0x17, 0xdb, 0x88, 0x75, 0xc5, 0xf8, 0xba, 0x87, 0x2f, 0x16, 0xfb, 0xac,
0x7a, 0x9d, 0xa0, 0xf5, 0x14, 0x76, 0xaf, 0xaf, 0xe0, 0x40, 0x08, 0xdd, 0xeb, 0x2c, 0xd9, 0xac, 0x17, 0xcf, 0xf2, 0x28, 0xf0, 0x19, 0x8a, 0x72, 0xfc, 0xf3, 0x0b, 0x52, 0xb9, 0x24, 0xb7, 0xae,
0xe2, 0xe3, 0x4a, 0x2e, 0x4c, 0xca, 0x97, 0xa6, 0x9e, 0xff, 0x73, 0x2c, 0x6b, 0xad, 0x0c, 0x7f, 0xf0, 0x27, 0xde, 0xbf, 0x98, 0xc9, 0x4c, 0x8e, 0x27, 0xe6, 0x14, 0xa7, 0xd3, 0xb7, 0xb5, 0x82,
0x34, 0x74, 0xe2, 0x87, 0x06, 0x53, 0x9a, 0x52, 0xe9, 0x6f, 0x17, 0xff, 0x05, 0xcb, 0xf4, 0x3f, 0x54, 0x2f, 0x57, 0x05, 0x5a, 0x8f, 0xf9, 0xfb, 0xf2, 0x02, 0x00, 0xc2, 0xe8, 0x4e, 0x67, 0xa1,
0xb3, 0xcb, 0x18, 0x00, 0x00 0x66, 0x99, 0x68, 0x97, 0x6a, 0x61, 0x52, 0x3e, 0x77, 0x7d, 0xfa, 0x3f, 0xef, 0x77, 0xad, 0xa5,
0x5b, 0x24, 0xdd, 0x5e, 0xf1, 0x87, 0x6e, 0xb8, 0x74, 0xdd, 0xa5, 0x7f, 0x04, 0xf9, 0x2f, 0x2f,
0x45, 0xbc, 0x82, 0x14, 0x19, 0x00, 0x00
}; };

2742
wled00/html_ui.h
View File

File diff suppressed because it is too large Load Diff

8
wled00/overlay.cpp
View File

@ -15,11 +15,11 @@ void _overlayAnalogClock()
float minuteP = ((float)minute(localTime))/60.0f; float minuteP = ((float)minute(localTime))/60.0f;
hourP = hourP + minuteP/12.0f; hourP = hourP + minuteP/12.0f;
float secondP = ((float)second(localTime))/60.0f; float secondP = ((float)second(localTime))/60.0f;
int hourPixel = floorf(analogClock12pixel + overlaySize*hourP); unsigned hourPixel = floorf(analogClock12pixel + overlaySize*hourP);
if (hourPixel > overlayMax) hourPixel = overlayMin -1 + hourPixel - overlayMax; if (hourPixel > overlayMax) hourPixel = overlayMin -1 + hourPixel - overlayMax;
int minutePixel = floorf(analogClock12pixel + overlaySize*minuteP); unsigned minutePixel = floorf(analogClock12pixel + overlaySize*minuteP);
if (minutePixel > overlayMax) minutePixel = overlayMin -1 + minutePixel - overlayMax; if (minutePixel > overlayMax) minutePixel = overlayMin -1 + minutePixel - overlayMax;
int secondPixel = floorf(analogClock12pixel + overlaySize*secondP); unsigned secondPixel = floorf(analogClock12pixel + overlaySize*secondP);
if (secondPixel > overlayMax) secondPixel = overlayMin -1 + secondPixel - overlayMax; if (secondPixel > overlayMax) secondPixel = overlayMin -1 + secondPixel - overlayMax;
if (analogClockSecondsTrail) if (analogClockSecondsTrail)
{ {
@ -36,7 +36,7 @@ void _overlayAnalogClock()
{ {
for (byte i = 0; i <= 12; i++) for (byte i = 0; i <= 12; i++)
{ {
int pix = analogClock12pixel + roundf((overlaySize / 12.0f) *i); unsigned pix = analogClock12pixel + roundf((overlaySize / 12.0f) *i);
if (pix > overlayMax) pix -= overlaySize; if (pix > overlayMax) pix -= overlaySize;
strip.setPixelColor(pix, 0x00FFAA); strip.setPixelColor(pix, 0x00FFAA);
} }

1
wled00/set.cpp
View File

@ -46,6 +46,7 @@ void handleSettingsSet(AsyncWebServerRequest *request, byte subPage)
if (t != apChannel) forceReconnect = true; if (t != apChannel) forceReconnect = true;
if (t > 0 && t < 14) apChannel = t; if (t > 0 && t < 14) apChannel = t;
force802_3g = request->hasArg(F("FG"));
noWifiSleep = request->hasArg(F("WS")); noWifiSleep = request->hasArg(F("WS"));
#ifndef WLED_DISABLE_ESPNOW #ifndef WLED_DISABLE_ESPNOW

7
wled00/wled.cpp
View File

@ -178,7 +178,7 @@ void WLED::loop()
doSerializeConfig = true; doSerializeConfig = true;
} }
if (loadLedmap >= 0) { if (loadLedmap >= 0) {
if (!strip.deserializeMap(loadLedmap) && strip.isMatrix && loadLedmap == 0) strip.setUpMatrix(); strip.deserializeMap(loadLedmap);
loadLedmap = -1; loadLedmap = -1;
} }
yield(); yield();
@ -709,7 +709,7 @@ void WLED::initConnection()
WiFi.disconnect(true); // close old connections WiFi.disconnect(true); // close old connections
#ifdef ESP8266 #ifdef ESP8266
WiFi.setPhyMode(WIFI_PHY_MODE_11N); WiFi.setPhyMode(force802_3g ? WIFI_PHY_MODE_11G : WIFI_PHY_MODE_11N);
#endif #endif
if (staticIP[0] != 0 && staticGateway[0] != 0) { if (staticIP[0] != 0 && staticGateway[0] != 0) {
@ -733,9 +733,10 @@ void WLED::initConnection()
WiFi.mode(WIFI_STA); WiFi.mode(WIFI_STA);
} }
} }
showWelcomePage = false;
if (WLED_WIFI_CONFIGURED) { if (WLED_WIFI_CONFIGURED) {
showWelcomePage = false;
DEBUG_PRINT(F("Connecting to ")); DEBUG_PRINT(F("Connecting to "));
DEBUG_PRINT(clientSSID); DEBUG_PRINT(clientSSID);
DEBUG_PRINTLN("..."); DEBUG_PRINTLN("...");

3
wled00/wled.h
View File

@ -8,7 +8,7 @@
*/ */
// version code in format yymmddb (b = daily build) // version code in format yymmddb (b = daily build)
#define VERSION 2312210 #define VERSION 2312270
//uncomment this if you have a "my_config.h" file you'd like to use //uncomment this if you have a "my_config.h" file you'd like to use
//#define WLED_USE_MY_CONFIG //#define WLED_USE_MY_CONFIG
@ -319,6 +319,7 @@ WLED_GLOBAL bool noWifiSleep _INIT(true); // disabling
#else #else
WLED_GLOBAL bool noWifiSleep _INIT(false); WLED_GLOBAL bool noWifiSleep _INIT(false);
#endif #endif
WLED_GLOBAL bool force802_3g _INIT(false);
#ifdef WLED_USE_ETHERNET #ifdef WLED_USE_ETHERNET
#ifdef WLED_ETH_DEFAULT // default ethernet board type if specified #ifdef WLED_ETH_DEFAULT // default ethernet board type if specified

1
wled00/xml.cpp
View File

@ -277,6 +277,7 @@ void getSettingsJS(byte subPage, char* dest)
sappends('s',SET_F("AP"),fapass); sappends('s',SET_F("AP"),fapass);
sappend('v',SET_F("AC"),apChannel); sappend('v',SET_F("AC"),apChannel);
sappend('c',SET_F("FG"),force802_3g);
sappend('c',SET_F("WS"),noWifiSleep); sappend('c',SET_F("WS"),noWifiSleep);
#ifndef WLED_DISABLE_ESPNOW #ifndef WLED_DISABLE_ESPNOW