Merge remote-tracking branch 'origin/main' into mdev

2022-10-28 11:36:49 +02:00
parent 80adc3f560 7211e6b929
commit 306fb01991
22 changed files with 2635 additions and 93 deletions
--- a/.github/FUNDING.yml
+++ b/.github/FUNDING.yml
@@ -1,5 +1,2 @@
-github: [Aircoookie]
-custom: ['https://paypal.me/Aircoookie']
-
-github: [blazoncek]
-custom: ['https://paypal.me/blazoncek']
+github: [Aircoookie,blazoncek]
+custom: ['https://paypal.me/Aircoookie','https://paypal.me/blazoncek']
--- a/.github/ISSUE_TEMPLATE/config.yml
+++ b/.github/ISSUE_TEMPLATE/config.yml
@@ -0,0 +1,11 @@
+blank_issues_enabled: false
+contact_links:
+  - name: WLED Discord community
+    url: https://discord.gg/KuqP7NE
+    about: Please ask and answer questions and discuss setup issues here!
+  - name: WLED community forum
+    url: https://wled.discourse.group/
+    about: For issues and ideas that might need longer discussion.
+  - name: kno.wled.ge base
+    url:  https://kno.wled.ge/basics/faq/
+    about: Take a look at the frequently asked questions and documentation, perhaps your question is already answered!
--- a/.github/ISSUE_TEMPLATE/question.md
+++ b/.github/ISSUE_TEMPLATE/question.md
@@ -1,19 +0,0 @@
---
-name: Question
-about: Have a question about using WLED?
-title: ''
-labels: question
-assignees: ''
-
---
-
-**Take a look at the wiki and FAQ, perhaps your question is already answered!**
-[FAQ](https://github.com/Aircoookie/WLED/wiki/FAQ)
-
-**Please consider asking your question on the WLED forum or Discord**
-[Forum](https://wled.discourse.group/)
-[Discord](https://discord.gg/KuqP7NE)
-[What to post where?](https://github.com/Aircoookie/WLED/issues/658)
-
-**If you do not like to use these platforms, delete this template and ask away!**
-Please keep in mind though that the issue section is generally not the preferred place for general questions.
--- a/usermods/BH1750_v2/usermod_bh1750.h
+++ b/usermods/BH1750_v2/usermod_bh1750.h
@@ -42,7 +42,7 @@ private:
  bool getLuminanceComplete = false;

  // flag set at startup
-  bool disabled = false;
+  bool enabled = true;

  // strings to reduce flash memory usage (used more than twice)
  static const char _name[];
@@ -133,7 +133,7 @@ public:

  void loop()
  {
-    if (disabled || strip.isUpdating())
+    if ((!enabled) || strip.isUpdating())
      return;

    unsigned long now = millis();
@@ -205,7 +205,7 @@ public:
  {
    // we add JSON object.
    JsonObject top = root.createNestedObject(FPSTR(_name)); // usermodname
-    top[FPSTR(_enabled)] = !disabled;
+    top[FPSTR(_enabled)] = enabled;
    top[FPSTR(_maxReadInterval)] = maxReadingInterval;
    top[FPSTR(_minReadInterval)] = minReadingInterval;
    top[FPSTR(_HomeAssistantDiscovery)] = HomeAssistantDiscovery;
@@ -233,7 +233,7 @@ public:
    }
    bool configComplete = !top.isNull();

-    configComplete &= getJsonValue(top[FPSTR(_enabled)], disabled, false);
+    configComplete &= getJsonValue(top[FPSTR(_enabled)], enabled, false);
    configComplete &= getJsonValue(top[FPSTR(_maxReadInterval)], maxReadingInterval, 10000); //ms
    configComplete &= getJsonValue(top[FPSTR(_minReadInterval)], minReadingInterval, 500); //ms
    configComplete &= getJsonValue(top[FPSTR(_HomeAssistantDiscovery)], HomeAssistantDiscovery, false);
--- a/usermods/PIR_sensor_switch/usermod_PIR_sensor_switch.h
+++ b/usermods/PIR_sensor_switch/usermod_PIR_sensor_switch.h
@@ -22,36 +22,20 @@
 * 
 * v2 usermods are class inheritance based and can (but don't have to) implement more functions, each of them is shown in this example.
 * Multiple v2 usermods can be added to one compilation easily.
- * 
- * Creating a usermod:
- * This file serves as an example. If you want to create a usermod, it is recommended to use usermod_v2_empty.h from the usermods folder as a template.
- * Please remember to rename the class and file to a descriptive name.
- * You may also use multiple .h and .cpp files.
- * 
- * Using a usermod:
- * 1. Copy the usermod into the sketch folder (same folder as wled00.ino)
- * 2. Register the usermod by adding #include "usermod_filename.h" in the top and registerUsermod(new MyUsermodClass()) in the bottom of usermods_list.cpp
 */

 class PIRsensorSwitch : public Usermod
 {
 public:
-  /**
-   * constructor
-   */
+  // constructor
  PIRsensorSwitch() {}
-  /**
-   * desctructor
-   */
+  // destructor
  ~PIRsensorSwitch() {}

-  /**
-   * Enable/Disable the PIR sensor
-   */
+  //Enable/Disable the PIR sensor
  void EnablePIRsensor(bool en) { enabled = en; }
-  /**
-   * Get PIR sensor enabled/disabled state
-   */
+  
+  // Get PIR sensor enabled/disabled state
  bool PIRsensorEnabled() { return enabled; }

 private:
@@ -78,6 +62,9 @@ private:
  bool m_offOnly            = false;
  bool m_offMode            = offMode;

+  // Home Assistant
+  bool HomeAssistantDiscovery = false;        // is HA discovery turned on
+
  // strings to reduce flash memory usage (used more than twice)
  static const char _name[];
  static const char _switchOffDelay[];
@@ -87,6 +74,7 @@ private:
  static const char _nightTime[];
  static const char _mqttOnly[];
  static const char _offOnly[];
+  static const char _haDiscovery[];
  static const char _notify[];

  /**
@@ -167,7 +155,7 @@ private:
  void publishMqtt(const char* state)
  {
    //Check if MQTT Connected, otherwise it will crash the 8266
-    if (WLED_MQTT_CONNECTED){
+    if (WLED_MQTT_CONNECTED) {
      char subuf[64];
      strcpy(subuf, mqttDeviceTopic);
      strcat_P(subuf, PSTR("/motion"));
@@ -175,6 +163,40 @@ private:
    }
  }

+  // Create an MQTT Binary Sensor for Home Assistant Discovery purposes, this includes a pointer to the topic that is published to in the Loop.
+  void publishHomeAssistantAutodiscovery()
+  {
+    if (WLED_MQTT_CONNECTED) {
+      StaticJsonDocument<600> doc;
+      char uid[24], json_str[1024], buf[128];
+
+      sprintf_P(buf, PSTR("%s Motion"), serverDescription); //max length: 33 + 7 = 40
+      doc[F("name")] = buf;
+      sprintf_P(buf, PSTR("%s/motion"), mqttDeviceTopic);   //max length: 33 + 7 = 40
+      doc[F("stat_t")] = buf;
+      doc[F("pl_on")]  = "on";
+      doc[F("pl_off")] = "off";
+      sprintf_P(uid, PSTR("%s_motion"), escapedMac.c_str());
+      doc[F("uniq_id")] = uid;
+      doc[F("dev_cla")] = F("motion");
+      doc[F("exp_aft")] = 1800;
+
+      JsonObject device = doc.createNestedObject(F("device")); // attach the sensor to the same device
+      device[F("name")] = serverDescription;
+      device[F("ids")]  = String(F("wled-sensor-")) + mqttClientID;
+      device[F("mf")]   = "WLED";
+      device[F("mdl")]  = F("FOSS");
+      device[F("sw")]   = versionString;
+      
+      sprintf_P(buf, PSTR("homeassistant/binary_sensor/%s/config"), uid);
+      DEBUG_PRINTLN(buf);
+      size_t payload_size = serializeJson(doc, json_str);
+      DEBUG_PRINTLN(json_str);
+
+      mqtt->publish(buf, 0, true, json_str, payload_size); // do we really need to retain?
+    }
+  }
+
  /**
   * Read and update PIR sensor state.
   * Initilize/reset switch off timer
@@ -251,6 +273,15 @@ public:
  {
  }

+  /**
+   * onMqttConnect() is called when MQTT connection is established
+   */
+  void onMqttConnect(bool sessionPresent) {
+    if (HomeAssistantDiscovery) {
+      publishHomeAssistantAutodiscovery();
+    }
+  }
+
  /**
   * loop() is called continuously. Here you can check for events, read sensors, etc.
   */
@@ -371,10 +402,17 @@ public:
    top[FPSTR(_nightTime)]      = m_nightTimeOnly;
    top[FPSTR(_mqttOnly)]       = m_mqttOnly;
    top[FPSTR(_offOnly)]        = m_offOnly;
+    top[FPSTR(_haDiscovery)]    = HomeAssistantDiscovery;
    top[FPSTR(_notify)]         = (NotifyUpdateMode != CALL_MODE_NO_NOTIFY);
    DEBUG_PRINTLN(F("PIR config saved."));
  }

+  void appendConfigData()
+  {
+    oappend(SET_F("addInfo('PIRsensorSwitch:HA-discovery',1,'HA=Home Assistant');"));     // 0 is field type, 1 is actual field
+    oappend(SET_F("addInfo('PIRsensorSwitch:notifications',1,'Periodic WS updates');"));  // 0 is field type, 1 is actual field
+  }
+
  /**
   * restore the changeable values
   * readFromConfig() is called before setup() to populate properties from values stored in cfg.json
@@ -407,6 +445,7 @@ public:
    m_nightTimeOnly = top[FPSTR(_nightTime)] | m_nightTimeOnly;
    m_mqttOnly      = top[FPSTR(_mqttOnly)] | m_mqttOnly;
    m_offOnly       = top[FPSTR(_offOnly)] | m_offOnly;
+    HomeAssistantDiscovery = top[FPSTR(_haDiscovery)] | HomeAssistantDiscovery;

    NotifyUpdateMode = top[FPSTR(_notify)] ? CALL_MODE_DIRECT_CHANGE : CALL_MODE_NO_NOTIFY;

@@ -435,7 +474,7 @@ public:
      DEBUG_PRINTLN(F(" config (re)loaded."));
    }
    // use "return !top["newestParameter"].isNull();" when updating Usermod with new features
-    return !top[FPSTR(_notify)].isNull();
+    return !top[FPSTR(_haDiscovery)].isNull();
  }

  /**
@@ -457,4 +496,5 @@ const char PIRsensorSwitch::_offPreset[]      PROGMEM = "off-preset";
 const char PIRsensorSwitch::_nightTime[]      PROGMEM = "nighttime-only";
 const char PIRsensorSwitch::_mqttOnly[]       PROGMEM = "mqtt-only";
 const char PIRsensorSwitch::_offOnly[]        PROGMEM = "off-only";
+const char PIRsensorSwitch::_haDiscovery[]    PROGMEM = "HA-discovery";
 const char PIRsensorSwitch::_notify[]         PROGMEM = "notifications";
--- a/usermods/word-clock-matrix/readme.md
+++ b/usermods/word-clock-matrix/readme.md
@@ -4,3 +4,16 @@ By @bwente

 See https://www.hackster.io/bwente/word-clock-with-just-two-components-073834 for the hardware guide!
 Includes a customizable feature to lower the brightness at night.
+
+![image](https://user-images.githubusercontent.com/371964/197094071-f8ccaf59-1d85-4dd2-8e09-1389675291e1.png)
+
+
+![image](https://user-images.githubusercontent.com/371964/197094211-6c736257-95ff-491f-9f0d-35d5135ecfea.png)
+
+
+
+
+
+![mini_8x8_word_clock_reverse_stencil_sZFti6chj4(1)](https://user-images.githubusercontent.com/371964/197094410-7c275f3f-743b-477a-bc15-5e7bdbcbd833.svg)
+
+![mini_8x8_word_clock_box_epUWJOBOhr(1)](https://user-images.githubusercontent.com/371964/197094496-fa49b355-164b-4bf5-84fd-f22f5206c645.svg)
--- a/usermods/word-clock-matrix/usermod_word_clock_matrix.h
+++ b/usermods/word-clock-matrix/usermod_word_clock_matrix.h
@@ -0,0 +1,338 @@
+#pragma once
+
+#include "wled.h"
+
+/*
+ * Things to do...
+ * Turn on ntp clock 24h format
+ * 64 LEDS
+ */
+
+
+class WordClockMatrix : public Usermod
+{
+private:
+  unsigned long lastTime = 0;
+  uint8_t minuteLast = 99;
+  int dayBrightness = 128;
+  int nightBrightness = 16;
+
+public:
+  void setup()
+  {
+    Serial.println("Hello from my usermod!");
+
+    //saveMacro(14, "A=128", false);
+    //saveMacro(15, "A=64", false);
+    //saveMacro(16, "A=16", false);
+
+    //saveMacro(1, "&FX=0&R=255&G=255&B=255", false);
+
+    //strip.getSegment(1).setOption(SEG_OPTION_SELECTED, true);
+
+    //select first two segments (background color + FX settable)
+    WS2812FX::Segment &seg = strip.getSegment(0);
+    seg.colors[0] = ((0 << 24) | ((0 & 0xFF) << 16) | ((0 & 0xFF) << 8) | ((0 & 0xFF)));
+    strip.getSegment(0).setOption(0, false);
+    strip.getSegment(0).setOption(2, false);
+    //other segments are text
+    for (int i = 1; i < 10; i++)
+    {
+      WS2812FX::Segment &seg = strip.getSegment(i);
+      seg.colors[0] = ((0 << 24) | ((0 & 0xFF) << 16) | ((190 & 0xFF) << 8) | ((180 & 0xFF)));
+      strip.getSegment(i).setOption(0, true);
+      strip.setBrightness(64);
+    }
+  }
+
+  void connected()
+  {
+    Serial.println("Connected to WiFi!");
+  }
+
+  void selectWordSegments(bool state)
+  {
+    for (int i = 1; i < 10; i++)
+    {
+      //WS2812FX::Segment &seg = strip.getSegment(i);
+      strip.getSegment(i).setOption(0, state);
+      // strip.getSegment(1).setOption(SEG_OPTION_SELECTED, true);
+      //seg.mode = 12;
+      //seg.palette = 1;
+      //strip.setBrightness(255);
+    }
+    strip.getSegment(0).setOption(0, !state);
+  }
+
+  void hourChime()
+  {
+    //strip.resetSegments();
+    selectWordSegments(true);
+    colorUpdated(CALL_MODE_FX_CHANGED);
+    savePreset(13, false);
+    selectWordSegments(false);
+    //strip.getSegment(0).setOption(0, true);
+    strip.getSegment(0).setOption(2, true);
+    applyPreset(12);
+    colorUpdated(CALL_MODE_FX_CHANGED);
+  }
+
+  void displayTime(byte hour, byte minute)
+  {
+    bool isToHour = false;      //true if minute > 30
+    strip.setSegment(0, 0, 64); // background
+    strip.setSegment(1, 0, 2);  //It is
+
+    strip.setSegment(2, 0, 0);
+    strip.setSegment(3, 0, 0); //disable minutes
+    strip.setSegment(4, 0, 0); //past
+    strip.setSegment(6, 0, 0); //to
+    strip.setSegment(8, 0, 0); //disable o'clock
+
+    if (hour < 24) //valid time, display
+    {
+      if (minute == 30)
+      {
+        strip.setSegment(2, 3, 6); //half
+        strip.setSegment(3, 0, 0); //minutes
+      }
+      else if (minute == 15 || minute == 45)
+      {
+        strip.setSegment(3, 0, 0); //minutes
+      }
+      else if (minute == 10)
+      {
+        //strip.setSegment(5, 6, 8); //ten
+      }
+      else if (minute == 5)
+      {
+        //strip.setSegment(5, 16, 18); //five
+      }
+      else if (minute == 0)
+      {
+        strip.setSegment(3, 0, 0); //minutes
+        //hourChime();
+      }
+      else
+      {
+        strip.setSegment(3, 18, 22); //minutes
+      }
+
+      //past or to?
+      if (minute == 0)
+      {                              //full hour
+        strip.setSegment(3, 0, 0);   //disable minutes
+        strip.setSegment(4, 0, 0);   //disable past
+        strip.setSegment(6, 0, 0);   //disable to
+        strip.setSegment(8, 60, 64); //o'clock
+      }
+      else if (minute > 34)
+      {
+        //strip.setSegment(6, 22, 24); //to
+        //minute = 60 - minute;
+        isToHour = true;
+      }
+      else
+      {
+        //strip.setSegment(4, 24, 27); //past
+        //isToHour = false;
+      }
+    }
+
+    //byte minuteRem = minute %10;
+
+    if (minute <= 4)
+    {
+      strip.setSegment(3, 0, 0);   //nothing
+      strip.setSegment(5, 0, 0);   //nothing
+      strip.setSegment(6, 0, 0);   //nothing
+      strip.setSegment(8, 60, 64); //o'clock
+    }
+    else if (minute <= 9)
+    {
+      strip.setSegment(5, 16, 18); // five past
+      strip.setSegment(4, 24, 27); //past
+    }
+    else if (minute <= 14)
+    {
+      strip.setSegment(5, 6, 8);   // ten past
+      strip.setSegment(4, 24, 27); //past
+    }
+    else if (minute <= 19)
+    {
+      strip.setSegment(5, 8, 12);  // quarter past
+      strip.setSegment(3, 0, 0);   //minutes
+      strip.setSegment(4, 24, 27); //past
+    }
+    else if (minute <= 24)
+    {
+      strip.setSegment(5, 12, 16); // twenty past
+      strip.setSegment(4, 24, 27); //past
+    }
+    else if (minute <= 29)
+    {
+      strip.setSegment(5, 12, 18); // twenty-five past
+      strip.setSegment(4, 24, 27); //past
+    }
+    else if (minute <= 34)
+    {
+      strip.setSegment(5, 3, 6);   // half past
+      strip.setSegment(3, 0, 0);   //minutes
+      strip.setSegment(4, 24, 27); //past
+    }
+    else if (minute <= 39)
+    {
+      strip.setSegment(5, 12, 18); // twenty-five to
+      strip.setSegment(6, 22, 24); //to
+    }
+    else if (minute <= 44)
+    {
+      strip.setSegment(5, 12, 16); // twenty to
+      strip.setSegment(6, 22, 24); //to
+    }
+    else if (minute <= 49)
+    {
+      strip.setSegment(5, 8, 12);  // quarter to
+      strip.setSegment(3, 0, 0);   //minutes
+      strip.setSegment(6, 22, 24); //to
+    }
+    else if (minute <= 54)
+    {
+      strip.setSegment(5, 6, 8);   // ten to
+      strip.setSegment(6, 22, 24); //to
+    }
+    else if (minute <= 59)
+    {
+      strip.setSegment(5, 16, 18); // five to
+      strip.setSegment(6, 22, 24); //to
+    }
+
+    //hours
+    if (hour > 23)
+      return;
+    if (isToHour)
+      hour++;
+    if (hour > 12)
+      hour -= 12;
+    if (hour == 0)
+      hour = 12;
+
+    switch (hour)
+    {
+    case 1:
+      strip.setSegment(7, 27, 29);
+      break; //one
+    case 2:
+      strip.setSegment(7, 35, 37);
+      break; //two
+    case 3:
+      strip.setSegment(7, 29, 32);
+      break; //three
+    case 4:
+      strip.setSegment(7, 32, 35);
+      break; //four
+    case 5:
+      strip.setSegment(7, 37, 40);
+      break; //five
+    case 6:
+      strip.setSegment(7, 43, 45);
+      break; //six
+    case 7:
+      strip.setSegment(7, 40, 43);
+      break; //seven
+    case 8:
+      strip.setSegment(7, 45, 48);
+      break; //eight
+    case 9:
+      strip.setSegment(7, 48, 50);
+      break; //nine
+    case 10:
+      strip.setSegment(7, 54, 56);
+      break; //ten
+    case 11:
+      strip.setSegment(7, 50, 54);
+      break; //eleven
+    case 12:
+      strip.setSegment(7, 56, 60);
+      break; //twelve
+    }
+
+    selectWordSegments(true);
+    applyMacro(1);
+  }
+
+  void timeOfDay()
+  {
+    // NOT USED: use timed macros instead
+    //Used to set brightness dependant of time of day - lights dimmed at night
+
+    //monday to thursday and sunday
+
+    if ((weekday(localTime) == 6) | (weekday(localTime) == 7))
+    {
+      if ((hour(localTime) > 0) | (hour(localTime) < 8))
+      {
+        strip.setBrightness(nightBrightness);
+      }
+      else
+      {
+        strip.setBrightness(dayBrightness);
+      }
+    }
+    else
+    {
+      if ((hour(localTime) < 6) | (hour(localTime) >= 22))
+      {
+        strip.setBrightness(nightBrightness);
+      }
+      else
+      {
+        strip.setBrightness(dayBrightness);
+      }
+    }
+  }
+
+  //loop. You can use "if (WLED_CONNECTED)" to check for successful connection
+  void loop()
+  {
+
+      if (millis() - lastTime > 1000) {
+        //Serial.println("I'm alive!");
+        Serial.println(hour(localTime));
+        lastTime = millis();
+      }
+
+
+    if (minute(localTime) != minuteLast)
+    {
+      updateLocalTime();
+      //timeOfDay();
+      minuteLast = minute(localTime);
+      displayTime(hour(localTime), minute(localTime));
+      if (minute(localTime) == 0)
+      {
+        hourChime();
+      }
+      if (minute(localTime) == 1)
+      {
+        //turn off background segment;
+        strip.getSegment(0).setOption(2, false);
+        //applyPreset(13);
+      }
+    }
+  }
+
+    void addToConfig(JsonObject& root)
+    {
+      JsonObject modName = root.createNestedObject("id");
+      modName["mdns"] = "wled-word-clock";
+      modName["name"] = "WLED WORD CLOCK";
+    }
+
+    uint16_t getId()
+    {
+      return USERMOD_ID_WORD_CLOCK_MATRIX;
+    }
+
+
+};
--- a/wled00/alexa.cpp
+++ b/wled00/alexa.cpp
@@ -14,17 +14,25 @@ void onAlexaChange(EspalexaDevice* dev);

 void alexaInit()
 {
-  if (alexaEnabled && WLED_CONNECTED)
-  {
-    if (espalexaDevice == nullptr) //only init once
+  if (!alexaEnabled || !WLED_CONNECTED) return;
+
+  espalexa.removeAllDevices();
+  // the original configured device for on/off or macros (added first, i.e. index 0)
+  espalexaDevice = new EspalexaDevice(alexaInvocationName, onAlexaChange, EspalexaDeviceType::extendedcolor);
+  espalexa.addDevice(espalexaDevice);
+
+  // up to 9 devices (added second, third, ... i.e. index 1 to 9) serve for switching on up to nine presets (preset IDs 1 to 9 in WLED), 
+  // names are identical as the preset names, switching off can be done by switching off any of them
+  if (alexaNumPresets) {
+    String name = "";
+    for (byte presetIndex = 1; presetIndex <= alexaNumPresets; presetIndex++) 
    {
-      espalexaDevice = new EspalexaDevice(alexaInvocationName, onAlexaChange, EspalexaDeviceType::extendedcolor);
-      espalexa.addDevice(espalexaDevice);
-      espalexa.begin(&server);
-    } else {
-      espalexaDevice->setName(alexaInvocationName);
+      if (!getPresetName(presetIndex, name)) break; // no more presets
+      EspalexaDevice* dev = new EspalexaDevice(name.c_str(), onAlexaChange, EspalexaDeviceType::extendedcolor);
+      espalexa.addDevice(dev);
    }
  }
+  espalexa.begin(&server);
 }

 void handleAlexa()
@@ -35,20 +43,34 @@ void handleAlexa()

 void onAlexaChange(EspalexaDevice* dev)
 {
-  EspalexaDeviceProperty m = espalexaDevice->getLastChangedProperty();
+  EspalexaDeviceProperty m = dev->getLastChangedProperty();
  
  if (m == EspalexaDeviceProperty::on)
  {
-    if (!macroAlexaOn)
+    if (dev->getId() == 0) // Device 0 is for on/off or macros
    {
-      if (bri == 0)
+      if (!macroAlexaOn)
      {
-        bri = briLast;
-        stateUpdated(CALL_MODE_ALEXA);
+        if (bri == 0)
+        {
+          bri = briLast;
+          stateUpdated(CALL_MODE_ALEXA);
+        }
+      } else 
+      {
+        applyPreset(macroAlexaOn, CALL_MODE_ALEXA);
+        if (bri == 0) dev->setValue(briLast); //stop Alexa from complaining if macroAlexaOn does not actually turn on
      }
-    } else {
-      applyPreset(macroAlexaOn, CALL_MODE_ALEXA);
-      if (bri == 0) espalexaDevice->setValue(briLast); //stop Alexa from complaining if macroAlexaOn does not actually turn on
+    } else // switch-on behavior for preset devices
+    {
+      // turn off other preset devices
+      for (byte i = 1; i < espalexa.getDeviceCount(); i++)
+      {
+        if (i == dev->getId()) continue;
+        espalexa.getDevice(i)->setValue(0); // turn off other presets
+      }
+
+      applyPreset(dev->getId(), CALL_MODE_ALEXA); // in alexaInit() preset 1 device was added second (index 1), preset 2 third (index 2) etc.
    }
  } else if (m == EspalexaDeviceProperty::off)
  {
@@ -60,20 +82,25 @@ void onAlexaChange(EspalexaDevice* dev)
        bri = 0;
        stateUpdated(CALL_MODE_ALEXA);
      }
-    } else {
+    } else 
+    {
      applyPreset(macroAlexaOff, CALL_MODE_ALEXA);
-      if (bri != 0) espalexaDevice->setValue(0); //stop Alexa from complaining if macroAlexaOff does not actually turn off
+      // below for loop stops Alexa from complaining if macroAlexaOff does not actually turn off
+    }
+    for (byte i = 0; i < espalexa.getDeviceCount(); i++)
+    {
+      espalexa.getDevice(i)->setValue(0);
    }
  } else if (m == EspalexaDeviceProperty::bri)
  {
-    bri = espalexaDevice->getValue();
+    bri = dev->getValue();
    stateUpdated(CALL_MODE_ALEXA);
  } else //color
  {
-    if (espalexaDevice->getColorMode() == EspalexaColorMode::ct) //shade of white
+    if (dev->getColorMode() == EspalexaColorMode::ct) //shade of white
    {
      byte rgbw[4];
-      uint16_t ct = espalexaDevice->getCt();
+      uint16_t ct = dev->getCt();
 			if (!ct) return;
 			uint16_t k = 1000000 / ct; //mireds to kelvin
 			
@@ -94,7 +121,7 @@ void onAlexaChange(EspalexaDevice* dev)
      }
      strip.setColor(0, RGBW32(rgbw[0], rgbw[1], rgbw[2], rgbw[3]));
    } else {
-      uint32_t color = espalexaDevice->getRGB();
+      uint32_t color = dev->getRGB();
      strip.setColor(0, color);
    }
    stateUpdated(CALL_MODE_ALEXA);
--- a/wled00/cfg.cpp
+++ b/wled00/cfg.cpp
@@ -392,6 +392,8 @@ bool deserializeConfig(JsonObject doc, bool fromFS) {
  CJSON(macroAlexaOn, interfaces["va"]["macros"][0]);
  CJSON(macroAlexaOff, interfaces["va"]["macros"][1]);

+  CJSON(alexaNumPresets, interfaces["va"]["p"]);
+
 #ifndef WLED_DISABLE_BLYNK
  const char* apikey = interfaces["blynk"][F("token")] | "Hidden";
  tdd = strnlen(apikey, 36);
@@ -555,11 +557,21 @@ void deserializeConfigFromFS() {
  DEBUG_PRINTLN(F("Reading settings from /cfg.json..."));

  success = readObjectFromFile("/cfg.json", nullptr, &doc);
-  if (!success) { //if file does not exist, try reading from EEPROM
+  if (!success) { // if file does not exist, optionally try reading from EEPROM and then save defaults to FS
+    releaseJSONBufferLock();
    #ifdef WLED_ADD_EEPROM_SUPPORT
    deEEPSettings();
    #endif
-    releaseJSONBufferLock();
+
+    // save default values to /cfg.json
+    // call readFromConfig() with an empty object so that usermods can initialize to defaults prior to saving
+    JsonObject empty = JsonObject();
+    usermods.readFromConfig(empty);
+    serializeConfig();
+    // init Ethernet (in case default type is set at compile time)
+    #ifdef WLED_USE_ETHERNET
+    WLED::instance().initEthernet();
+    #endif
    return;
  }

@@ -568,7 +580,7 @@ void deserializeConfigFromFS() {
  bool needsSave = deserializeConfig(doc.as<JsonObject>(), true);
  releaseJSONBufferLock();

-  if (needsSave) serializeConfig(); // usermods required new prameters
+  if (needsSave) serializeConfig(); // usermods required new parameters
 }

 void serializeConfig() {
@@ -839,6 +851,8 @@ void serializeConfig() {
  if_va_macros.add(macroAlexaOn);
  if_va_macros.add(macroAlexaOff);

+  if_va["p"] = alexaNumPresets;
+
 #ifndef WLED_DISABLE_BLYNK
  JsonObject if_blynk = interfaces.createNestedObject("blynk");
  if_blynk[F("token")] = strlen(blynkApiKey) ? "Hidden":"";
--- a/wled00/data/index.css
+++ b/wled00/data/index.css
@@ -101,7 +101,7 @@ button {
 	position: fixed;
 	bottom: calc(var(--bh) + 6px);
 	right: 6px;
-	color: var(--c-d);	/* should remain bright (--c-d) with dark shadow (see below) to be legible on gray background */
+	color: var(--c-8); /* set bright (--c-d) with dark text shadow (see below) to be legible on gray background (in image) */
 	cursor: pointer;
 	writing-mode: vertical-rl;
 	/* transform: rotate(180deg); */
@@ -1046,7 +1046,7 @@ textarea {
 }

 .qcs, #namelabel { /* text shadow for name to be legible on grey backround */
-	text-shadow: -1px -1px 0 var(--c-4), 1px -1px 0 var(--c-4), -1px 1px 0 var(--c-4), 1px 1px 0 var(--c-4);
+	text-shadow: -1px -1px 0 var(--c-1), 1px -1px 0 var(--c-1), -1px 1px 0 var(--c-1), 1px 1px 0 var(--c-1);
 }

 .psts {
--- a/wled00/data/index.js
+++ b/wled00/data/index.js
@@ -182,6 +182,7 @@ function loadBg(iUrl)
 		bg.style.opacity = a;
 		bg.style.backgroundImage = `url(${img.src})`;
 		img = null;
+		gId('namelabel').style.color = "var(--c-c)"; // improve namelabel legibility on background image
 	});
 }

@@ -1519,7 +1520,8 @@ function requestJson(command=null)
 			if (tn != tr) command.transition = tn;
 		}
 		req = JSON.stringify(command);
-		if (req.length > 1430) useWs = false; // do not send very long requests over websocket
+		if (req.length > 1340) useWs = false; // do not send very long requests over websocket
+		if (req.length >  500 && lastinfo && lastinfo.arch == "esp8266") useWs = false; // esp8266 can only handle 500 bytes
 	};

 	if (useWs) {
--- a/wled00/data/settings_sync.htm
+++ b/wled00/data/settings_sync.htm
@@ -165,7 +165,8 @@ Disable realtime gamma correction: <input type="checkbox" name="RG"><br>
 Realtime LED offset: <input name="WO" type="number" min="-255" max="255" required>
 <h3>Alexa Voice Assistant</h3>
 Emulate Alexa device: <input type="checkbox" name="AL"><br>
-Alexa invocation name: <input type="text" name="AI" maxlength="32">
+Alexa invocation name: <input type="text" name="AI" maxlength="32"><br>
+Also emulate devices to call the first <input name="AP" type="number" class="s" min="0" max="9" required> presets
 <h3>Blynk</h3>
 <b>Blynk, MQTT and Hue sync all connect to external hosts!<br>
 This may impact the responsiveness of the ESP8266.</b><br>
--- a/wled00/fcn_declare.h
+++ b/wled00/fcn_declare.h
@@ -201,6 +201,7 @@ inline bool applyTemporaryPreset() {return applyPreset(255);};
 void savePreset(byte index, const char* pname = nullptr, JsonObject saveobj = JsonObject());
 inline void saveTemporaryPreset() {savePreset(255);};
 void deletePreset(byte index);
+bool getPresetName(byte index, String& name); 

 //set.cpp
 bool isAsterisksOnly(const char* str, byte maxLen);
--- a/wled00/html_settings.h
+++ b/wled00/html_settings.h
@@ -1028,8 +1028,9 @@ const uint8_t PAGE_settings_ui[] PROGMEM = {


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


--- a/wled00/html_ui.h
+++ b/wled00/html_ui.h
--- a/wled00/presets.cpp
+++ b/wled00/presets.cpp
@@ -75,6 +75,22 @@ static void doSaveState() {
  playlistSave = false;
 }

+bool getPresetName(byte index, String& name) 
+{
+  if (!requestJSONBufferLock(9)) return false;
+  bool presetExists = false;
+  if (readObjectFromFileUsingId("/presets.json", index, &doc))
+  { 
+    JsonObject fdo = doc.as<JsonObject>();
+    if (fdo["n"]) {
+      name = (const char*)(fdo["n"]);
+      presetExists = true;
+    }
+  }
+  releaseJSONBufferLock();
+  return presetExists;
+}
+
 bool applyPreset(byte index, byte callMode)
 {
  DEBUG_PRINT(F("Request to apply preset: "));
--- a/wled00/set.cpp
+++ b/wled00/set.cpp
@@ -277,6 +277,8 @@ void handleSettingsSet(AsyncWebServerRequest *request, byte subPage)

    alexaEnabled = request->hasArg(F("AL"));
    strlcpy(alexaInvocationName, request->arg(F("AI")).c_str(), 33);
+    t = request->arg(F("AP")).toInt();
+    if (t >= 0 && t <= 9) alexaNumPresets = t;

    #ifndef WLED_DISABLE_BLYNK
    strlcpy(blynkHost, request->arg("BH").c_str(), 33);
@@ -503,7 +505,7 @@ void handleSettingsSet(AsyncWebServerRequest *request, byte subPage)
    } else {
      // there is no Wire.end()
      DEBUG_PRINTLN(F("Could not allocate I2C pins."));
-      uint8_t i2c[2] = { i2c_scl, i2c_sda };
+      uint8_t i2c[2] = { static_cast<uint8_t>(i2c_scl), static_cast<uint8_t>(i2c_sda) };
      pinManager.deallocateMultiplePins(i2c, 2, PinOwner::HW_I2C); // just in case deallocation of old pins
      i2c_sda = -1;
      i2c_scl = -1;
@@ -532,7 +534,7 @@ void handleSettingsSet(AsyncWebServerRequest *request, byte subPage)
    } else {
      //SPI.end();
      DEBUG_PRINTLN(F("Could not allocate SPI pins."));
-      uint8_t spi[3] = { spi_mosi, spi_miso, spi_sclk };
+      uint8_t spi[3] = { static_cast<uint8_t>(spi_mosi), static_cast<uint8_t>(spi_miso), static_cast<uint8_t>(spi_sclk) };
      pinManager.deallocateMultiplePins(spi, 3, PinOwner::HW_SPI); // just in case deallocation of old pins
      spi_mosi = -1;
      spi_miso = -1;
--- a/wled00/src/dependencies/espalexa/Espalexa.h
+++ b/wled00/src/dependencies/espalexa/Espalexa.h
@@ -359,6 +359,11 @@ public:
    return false;
  }

+  // get device count, function only in WLED version of Espalexa
+  uint8_t getDeviceCount() {
+    return currentDeviceCount;
+  }
+
  //service loop
  void loop() {
    #ifndef ESPALEXA_ASYNC
@@ -393,6 +398,13 @@ public:
    }
  }

+  // Function only in WLED version of Espalexa, does not actually release memory for names
+  void removeAllDevices()
+  {
+    currentDeviceCount=0;
+    return;
+  }
+
  // returns device index or 0 on failure
  uint8_t addDevice(EspalexaDevice* d)
  {
--- a/wled00/wled.h
+++ b/wled00/wled.h
@@ -113,7 +113,7 @@
 #ifndef WLED_DISABLE_ALEXA
  #define ESPALEXA_ASYNC
  #define ESPALEXA_NO_SUBPAGE
-  #define ESPALEXA_MAXDEVICES 1
+  #define ESPALEXA_MAXDEVICES 10
  // #define ESPALEXA_DEBUG
  #include "src/dependencies/espalexa/Espalexa.h"
 #endif
@@ -358,6 +358,7 @@ WLED_GLOBAL uint8_t udpNumRetries _INIT(0);                       // Number of t

 WLED_GLOBAL bool alexaEnabled _INIT(false);                       // enable device discovery by Amazon Echo
 WLED_GLOBAL char alexaInvocationName[33] _INIT("Light");          // speech control name of device. Choose something voice-to-text can understand
+WLED_GLOBAL byte alexaNumPresets _INIT(0);                        // number of presets to expose to Alexa, starting from preset 1, up to 9

 #ifndef WLED_DISABLE_BLYNK
 WLED_GLOBAL char blynkApiKey[36] _INIT("");                       // Auth token for Blynk server. If empty, no connection will be made
--- a/wled00/wled_eeprom.cpp
+++ b/wled00/wled_eeprom.cpp
@@ -467,11 +467,5 @@ void deEEPSettings() {
  EEPROM.begin(EEPSIZE);
  loadSettingsFromEEPROM();
  EEPROM.end();
-
-  //call readFromConfig() with an empty object so that usermods can initialize to defaults prior to saving
-  JsonObject empty = JsonObject();
-  usermods.readFromConfig(empty);
-
-  serializeConfig();
 }
 #endif
--- a/wled00/wled_server.cpp
+++ b/wled00/wled_server.cpp
@@ -39,11 +39,11 @@ void handleUpload(AsyncWebServerRequest *request, const String& filename, size_t
  if (!index) {
    String finalname = filename;
    if (finalname.charAt(0) != '/') {
-      finalname = "/" + finalname; // prepend slash if missing
+      finalname = '/' + finalname; // prepend slash if missing
    }

    request->_tempFile = WLED_FS.open(finalname, "w");
-    DEBUG_PRINT("Uploading ");
+    DEBUG_PRINT(F("Uploading "));
    DEBUG_PRINTLN(finalname);
    if (finalname.equals("/presets.json")) presetsModifiedTime = toki.second();  // WLEDSR
  }
@@ -622,4 +622,4 @@ void serveSettings(AsyncWebServerRequest* request, bool post)
  response->addHeader(FPSTR(s_content_enc),"gzip");
  setStaticContentCacheHeaders(response);
  request->send(response);
-}
+}
--- a/wled00/xml.cpp
+++ b/wled00/xml.cpp
@@ -509,6 +509,7 @@ void getSettingsJS(byte subPage, char* dest)
    sappend('c',SET_F("AL"),alexaEnabled);
    sappends('s',SET_F("AI"),alexaInvocationName);
    sappend('c',SET_F("SA"),notifyAlexa);
+    sappend('v',SET_F("AP"),alexaNumPresets);
    sappends('s',SET_F("BK"),(char*)((blynkEnabled)?SET_F("Hidden"):""));
    #ifndef WLED_DISABLE_BLYNK
    sappends('s',SET_F("BH"),blynkHost);