fix: keep feature-complete release builds within flash limits

.github/workflows/run-unit-tests.yml

@@ -479,6 +479,7 @@ jobs:
           python3 -B test/test_common_prefs_uncertain_reply.py -v
           python3 -B test/test_common_prefs_apply_reply.py -v
           python3 -B test/test_common_prefs_commit.py -v
+          python3 -B test/test_common_cli_retry_tail.py -v
           python3 -B test/test_common_prefs_legacy_rxgain.py -v
           python3 -B test/test_flood_policy_capacity.py -v
           python3 -B test/test_flood_rule_layout.py -v

src/helpers/CommonCLI.cpp

@@ -1977,6 +1977,75 @@ static bool writeCommonPrefsImage(Writer& writer, NodePrefs* prefs) {
 }
 #endif
 
+// This canonical retry/flood span contains no padding. Guard every boundary
+// before replacing its field writes with one bounded LittleFS transaction write.
+#if defined(__GNUC__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Winvalid-offsetof"
+#endif
+template <typename Writer>
+static void writeCommonRetryPrefs(Writer& writer, NodePrefs* prefs) {
+  static_assert(offsetof(NodePrefs, direct_retry_attempts) == offsetof(NodePrefs, retry_preset)
+      + sizeof(prefs->retry_preset), "Common preference retry tail has padding or changed order");
+  static_assert(offsetof(NodePrefs, direct_retry_base_ms) == offsetof(NodePrefs, direct_retry_attempts)
+      + sizeof(prefs->direct_retry_attempts), "Common preference retry tail has padding or changed order");
+  static_assert(offsetof(NodePrefs, direct_retry_step_ms) == offsetof(NodePrefs, direct_retry_base_ms)
+      + sizeof(prefs->direct_retry_base_ms), "Common preference retry tail has padding or changed order");
+  static_assert(offsetof(NodePrefs, direct_retry_snr_margin_x4) == offsetof(NodePrefs, direct_retry_step_ms)
+      + sizeof(prefs->direct_retry_step_ms), "Common preference retry tail has padding or changed order");
+  static_assert(offsetof(NodePrefs, direct_retry_cr4_snr_x4) == offsetof(NodePrefs, direct_retry_snr_margin_x4)
+      + sizeof(prefs->direct_retry_snr_margin_x4), "Common preference retry tail has padding or changed order");
+  static_assert(offsetof(NodePrefs, direct_retry_cr5_snr_x4) == offsetof(NodePrefs, direct_retry_cr4_snr_x4)
+      + sizeof(prefs->direct_retry_cr4_snr_x4), "Common preference retry tail has padding or changed order");
+  static_assert(offsetof(NodePrefs, direct_retry_cr7_snr_x4) == offsetof(NodePrefs, direct_retry_cr5_snr_x4)
+      + sizeof(prefs->direct_retry_cr5_snr_x4), "Common preference retry tail has padding or changed order");
+  static_assert(offsetof(NodePrefs, direct_retry_cr8_snr_x4) == offsetof(NodePrefs, direct_retry_cr7_snr_x4)
+      + sizeof(prefs->direct_retry_cr7_snr_x4), "Common preference retry tail has padding or changed order");
+  static_assert(offsetof(NodePrefs, direct_retry_enabled) == offsetof(NodePrefs, direct_retry_cr8_snr_x4)
+      + sizeof(prefs->direct_retry_cr8_snr_x4), "Common preference retry tail has padding or changed order");
+  static_assert(offsetof(NodePrefs, direct_retry_cr_enabled) == offsetof(NodePrefs, direct_retry_enabled)
+      + sizeof(prefs->direct_retry_enabled), "Common preference retry tail has padding or changed order");
+  static_assert(offsetof(NodePrefs, direct_retry_prefs_magic) == offsetof(NodePrefs, direct_retry_cr_enabled)
+      + sizeof(prefs->direct_retry_cr_enabled), "Common preference retry tail has padding or changed order");
+  static_assert(offsetof(NodePrefs, flood_retry_attempts) == offsetof(NodePrefs, direct_retry_prefs_magic)
+      + sizeof(prefs->direct_retry_prefs_magic), "Common preference retry tail has padding or changed order");
+  static_assert(offsetof(NodePrefs, flood_retry_max_path) == offsetof(NodePrefs, flood_retry_attempts)
+      + sizeof(prefs->flood_retry_attempts), "Common preference retry tail has padding or changed order");
+  static_assert(offsetof(NodePrefs, flood_retry_prefixes) == offsetof(NodePrefs, flood_retry_max_path)
+      + sizeof(prefs->flood_retry_max_path), "Common preference retry tail has padding or changed order");
+  static_assert(offsetof(NodePrefs, flood_retry_bridge_enabled) == offsetof(NodePrefs, flood_retry_prefixes)
+      + sizeof(prefs->flood_retry_prefixes), "Common preference retry tail has padding or changed order");
+  static_assert(offsetof(NodePrefs, flood_retry_bridge_buckets) == offsetof(NodePrefs, flood_retry_bridge_enabled)
+      + sizeof(prefs->flood_retry_bridge_enabled), "Common preference retry tail has padding or changed order");
+  static_assert(offsetof(NodePrefs, flood_retry_ignore_prefixes) == offsetof(NodePrefs, flood_retry_bridge_buckets)
+      + sizeof(prefs->flood_retry_bridge_buckets), "Common preference retry tail has padding or changed order");
+  static_assert(offsetof(NodePrefs, flood_retry_advert_enabled) == offsetof(NodePrefs, flood_retry_ignore_prefixes)
+      + sizeof(prefs->flood_retry_ignore_prefixes), "Common preference retry tail has padding or changed order");
+  static_assert(offsetof(NodePrefs, battery_alert_enabled) == offsetof(NodePrefs, flood_retry_advert_enabled)
+      + sizeof(prefs->flood_retry_advert_enabled), "Common preference retry tail has padding or changed order");
+  static_assert(offsetof(NodePrefs, battery_alert_low_percent) == offsetof(NodePrefs, battery_alert_enabled)
+      + sizeof(prefs->battery_alert_enabled), "Common preference retry tail has padding or changed order");
+  static_assert(offsetof(NodePrefs, battery_alert_critical_percent) == offsetof(NodePrefs, battery_alert_low_percent)
+      + sizeof(prefs->battery_alert_low_percent), "Common preference retry tail has padding or changed order");
+  static_assert(offsetof(NodePrefs, direct_retry_recent_enabled) == offsetof(NodePrefs, battery_alert_critical_percent)
+      + sizeof(prefs->battery_alert_critical_percent), "Common preference retry tail has padding or changed order");
+  static_assert(offsetof(NodePrefs, flood_channel_data_enabled) == offsetof(NodePrefs, direct_retry_recent_enabled)
+      + sizeof(prefs->direct_retry_recent_enabled), "Common preference retry tail has padding or changed order");
+  static_assert(offsetof(NodePrefs, legacy_flood_channel_block_max_hops) == offsetof(NodePrefs, flood_channel_data_enabled)
+      + sizeof(prefs->flood_channel_data_enabled), "Common preference retry tail has padding or changed order");
+  static_assert(offsetof(NodePrefs, flood_channel_data_max_hops) == offsetof(NodePrefs, legacy_flood_channel_block_max_hops)
+      + sizeof(prefs->legacy_flood_channel_block_max_hops), "Common preference retry tail has padding or changed order");
+  static_assert(offsetof(NodePrefs, telemetry_access) == offsetof(NodePrefs, flood_channel_data_max_hops)
+      + sizeof(prefs->flood_channel_data_max_hops), "Common preference retry tail has padding or changed order");
+  constexpr size_t first = offsetof(NodePrefs, retry_preset);
+  constexpr size_t size = offsetof(NodePrefs, telemetry_access)
+      + sizeof(prefs->telemetry_access) - first;
+  writer.write(reinterpret_cast<const uint8_t*>(prefs) + first, size);
+}
+#if defined(__GNUC__)
+#pragma GCC diagnostic pop
+#endif
+
 void CommonCLI::savePrefs(FILESYSTEM* fs, PrefsSaveRouting::Scope scope) {
   const PrefsSaveRouting::Plan plan = PrefsSaveRouting::planFor(scope);
   if (plan.common) {
@@ -2066,34 +2135,7 @@ void CommonCLI::savePrefs(FILESYSTEM* fs, PrefsSaveRouting::Scope scope) {
     file.write((uint8_t *)&_prefs->cad_enabled, sizeof(_prefs->cad_enabled));                       // 294
     // next: 295
     markDirectRetryPrefsValid(_prefs);
-    file.write((uint8_t *)&_prefs->retry_preset, sizeof(_prefs->retry_preset));                     // 295
-    file.write((uint8_t *)&_prefs->direct_retry_attempts, sizeof(_prefs->direct_retry_attempts));   // 296
-    file.write((uint8_t *)&_prefs->direct_retry_base_ms, sizeof(_prefs->direct_retry_base_ms));     // 297
-    file.write((uint8_t *)&_prefs->direct_retry_step_ms, sizeof(_prefs->direct_retry_step_ms));     // 299
-    file.write((uint8_t *)&_prefs->direct_retry_snr_margin_x4, sizeof(_prefs->direct_retry_snr_margin_x4)); // 301
-    file.write((uint8_t *)&_prefs->direct_retry_cr4_snr_x4, sizeof(_prefs->direct_retry_cr4_snr_x4)); // 303
-    file.write((uint8_t *)&_prefs->direct_retry_cr5_snr_x4, sizeof(_prefs->direct_retry_cr5_snr_x4)); // 304
-    file.write((uint8_t *)&_prefs->direct_retry_cr7_snr_x4, sizeof(_prefs->direct_retry_cr7_snr_x4)); // 305
-    file.write((uint8_t *)&_prefs->direct_retry_cr8_snr_x4, sizeof(_prefs->direct_retry_cr8_snr_x4)); // 306
-    file.write((uint8_t *)&_prefs->direct_retry_enabled, sizeof(_prefs->direct_retry_enabled));       // 307
-    file.write((uint8_t *)&_prefs->direct_retry_cr_enabled, sizeof(_prefs->direct_retry_cr_enabled)); // 308
-    file.write((uint8_t *)&_prefs->direct_retry_prefs_magic, sizeof(_prefs->direct_retry_prefs_magic)); // 309
-    file.write((uint8_t *)&_prefs->flood_retry_attempts, sizeof(_prefs->flood_retry_attempts));       // 311
-    file.write((uint8_t *)&_prefs->flood_retry_max_path, sizeof(_prefs->flood_retry_max_path));       // 312
-    file.write((uint8_t *)&_prefs->flood_retry_prefixes[0][0], sizeof(_prefs->flood_retry_prefixes)); // 313
-    file.write((uint8_t *)&_prefs->flood_retry_bridge_enabled, sizeof(_prefs->flood_retry_bridge_enabled));
-    file.write((uint8_t *)&_prefs->flood_retry_bridge_buckets[0][0][0], sizeof(_prefs->flood_retry_bridge_buckets));
-    file.write((uint8_t *)&_prefs->flood_retry_ignore_prefixes[0][0], sizeof(_prefs->flood_retry_ignore_prefixes));
-    file.write((uint8_t *)&_prefs->flood_retry_advert_enabled, sizeof(_prefs->flood_retry_advert_enabled));
-    file.write((uint8_t *)&_prefs->battery_alert_enabled, sizeof(_prefs->battery_alert_enabled));
-    file.write((uint8_t *)&_prefs->battery_alert_low_percent, sizeof(_prefs->battery_alert_low_percent));
-    file.write((uint8_t *)&_prefs->battery_alert_critical_percent, sizeof(_prefs->battery_alert_critical_percent));
-    file.write((uint8_t *)&_prefs->direct_retry_recent_enabled, sizeof(_prefs->direct_retry_recent_enabled));
-    file.write((uint8_t *)&_prefs->flood_channel_data_enabled, sizeof(_prefs->flood_channel_data_enabled));
-    file.write((uint8_t *)&_prefs->legacy_flood_channel_block_max_hops,
-               sizeof(_prefs->legacy_flood_channel_block_max_hops));
-    file.write((uint8_t *)&_prefs->flood_channel_data_max_hops, sizeof(_prefs->flood_channel_data_max_hops));
-    file.write((uint8_t *)&_prefs->telemetry_access, sizeof(_prefs->telemetry_access));             // 674
+    writeCommonRetryPrefs(file, _prefs); // Same canonical retry/flood bytes; no file-format change.
 #if defined(ENABLE_OTA)
     file.write((uint8_t *)&_prefs->ota_autofetch, sizeof(_prefs->ota_autofetch));                   // 675
     file.write((uint8_t *)&_prefs->ota_autoinstall, sizeof(_prefs->ota_autoinstall));               // 676

src/helpers/LedSettings.cpp

@@ -15,93 +15,91 @@ FILESYSTEM* settings_fs = nullptr;
 const char* const path = "/leds_v1";
 const char* const backup = "/leds_v1.bak";
 
-void encode(bool on, uint8_t (&data)[8]) {
-  const uint8_t value = on ? 1 : 0;
-  const uint8_t image[] = {'L', 'E', 'D', 1, value,
-                          static_cast<uint8_t>(value ^ 0xff), 0, 0};
-  memcpy(data, image, sizeof(data));
-}
+const uint8_t images[2][8] = {
+    {'L', 'E', 'D', 1, 0, 0xff, 0, 0},
+    {'L', 'E', 'D', 1, 1, 0xfe, 0, 0}};
 
-bool readSetting(const char* name, bool& on) {
-  if (!settings_fs) return false;
+// Return the saved value, or -1 for an absent or invalid image. Comparing the
+// two canonical images shares the write format without a second encoder.
+int readSetting(const char* name) {
+  if (!settings_fs) return -1;
 #if defined(NRF52_PLATFORM) || defined(STM32_PLATFORM)
   File file(*settings_fs);
-  if (!file.open(name, FILE_O_READ)) return false;
+  if (!file.open(name, FILE_O_READ)) return -1;
 #else
   File file = settings_fs->open(name, "r");
-  if (!file) return false;
+  if (!file) return -1;
 #endif
-  uint8_t data[8], expected[8];
+  uint8_t data[8];
   const bool complete = file.size() == sizeof(data)
       && file.read(data, sizeof(data)) == sizeof(data);
   file.close();
-  if (!complete || data[4] > 1) return false;
-  encode(data[4] != 0, expected);
-  if (memcmp(data, expected, sizeof(data)) != 0) return false;
-  on = data[4] != 0;
-  return true;
+  if (!complete || data[4] > 1
+      || memcmp(data, images[data[4]], sizeof(data)) != 0) return -1;
+  return data[4];
 }
 
 bool saveSetting(bool on) {
   if (!settings_fs) return false;
-  uint8_t data[8];
-  encode(on, data);
+  const uint8_t* data = images[on ? 1 : 0];
 #if defined(NRF52_PLATFORM) || defined(STM32_PLATFORM)
   AtomicFileWriter file(settings_fs, path);
 #else
   ContactFileTransaction file(settings_fs, path);
 #endif
-  if (!file || file.write(data, sizeof(data)) != sizeof(data) || !file.commit())
+  if (!file || file.write(data, sizeof(images[0])) != sizeof(images[0]) || !file.commit())
     return false;
-  bool checked = !on;
-  return readSetting(path, checked) && checked == on;
+  return readSetting(path) == int(on);
 }
 } // namespace
 
 void beginSettings(MainBoard& board, FILESYSTEM* fs) {
   main_board = &board;
   settings_fs = fs;
-  bool on = true;
-  if (!readSetting(path, on) && readSetting(backup, on)) {
+  int setting = readSetting(path);
+  if (setting < 0 && (setting = readSetting(backup)) >= 0) {
     // Recover the rename gap without discarding the last complete preference.
     if ((!fs->exists(path) || fs->remove(path)) && fs->rename(backup, path)) {
-      bool checked = !on;
-      if (!readSetting(path, checked) || checked != on) settings_fs = nullptr;
+      if (readSetting(path) != setting) settings_fs = nullptr;
     } else {
       settings_fs = nullptr;
     }
   }
-  setEnabled(on);
+  setEnabled(setting != 0);
   board.applyLedPolicy();
   applyStatusPolicy();
 }
 
+// Keep the uncommon filesystem transaction out of the large STM32 CLI
+// dispatcher, while retaining ordinary inlining choices elsewhere.
+#if defined(STM32_PLATFORM)
+__attribute__((noinline))
+#endif
 bool handleCommand(const char* command, char* reply, size_t capacity) {
   if (!command || !reply || capacity == 0) return false;
-  const bool get = strncmp(command, "get ", 4) == 0;
-  const bool set = strncmp(command, "set ", 4) == 0;
-  if ((!get && !set) || strncmp(command + 4, "leds", 4) != 0) return false;
+  const bool get = command[0] == 'g';
+  if ((!get && command[0] != 's')
+      || strncmp(command + 1, "et leds", 7) != 0) return false;
   const char* value = command + 8;
   if (*value && *value != ' ' && *value != '\t') return false;
+  const char* message;
   if (get) {
-    if (*value) snprintf(reply, capacity, "Error: usage get leds");
-    else snprintf(reply, capacity, "> %s", enabled() ? "on" : "off");
-    return true;
+    message = *value ? "Error: usage get leds" : enabled() ? "> on" : "> off";
+  } else {
+    while (*value == ' ' || *value == '\t') ++value;
+    const bool on = strcmp(value, "on") == 0;
+    if (!on && strcmp(value, "off") != 0) {
+      message = "Error: usage set leds on|off";
+    } else if (!main_board || !saveSetting(on)) {
+      message = "Error: LED setting save unconfirmed; reboot may differ";
+    } else {
+      setEnabled(on);
+      main_board->applyLedPolicy();
+      applyStatusPolicy();
+      message = "OK";
+    }
   }
-  while (*value == ' ' || *value == '\t') ++value;
-  if (strcmp(value, "on") != 0 && strcmp(value, "off") != 0) {
-    snprintf(reply, capacity, "Error: usage set leds on|off");
-    return true;
-  }
-  const bool on = strcmp(value, "on") == 0;
-  if (!main_board || !saveSetting(on)) {
-    snprintf(reply, capacity, "Error: LED setting save unconfirmed; reboot may differ");
-    return true;
-  }
-  setEnabled(on);
-  main_board->applyLedPolicy();
-  applyStatusPolicy();
-  snprintf(reply, capacity, "OK");
+  snprintf(reply, capacity, "%s", message);
   return true;
 }
 } } // namespace mesh::leds

src/helpers/ota/OtaTargets.h

@@ -85,186 +85,117 @@ inline const char* ota_target_env_name(uint32_t target_id, char* buffer, size_t
   };
   enum { DECODE_CHUNK_BYTES = 4096 };
   static const uint16_t OFFSETS[] = {
-    0, 1066, 2165, 2715,
+    0, 1610,
   };
   static const uint16_t RAW_LENGTHS[] = {
-    4087, 4061, 2042,
+    3942,
   };
   static const uint16_t FIRSTS[] = {
-    0, 274, 536, 683,
+    0, 683,
   };
-  // 2715 encoded bytes; 3 independent chunks, at most 4096 decoded bytes.
+  // 1610 encoded bytes; 1 independent chunks, at most 4096 decoded bytes.
   static const uint8_t NAMES[] = {
-    0xad, 0x57, 0x57, 0x9b, 0xa3, 0x38, 0x10, 0xd4, 0xe5, 0xbb, 0xc9, 0x39, 0x3a, 0x6f, 0xce, 0x36,
-    0xde, 0xf8, 0x76, 0x69, 0x73, 0xce, 0x8f, 0xfd, 0xc9, 0x20, 0xaf, 0xf9, 0x0c, 0x88, 0x93, 0x34,
-    0xe9, 0xdf, 0xdf, 0x08, 0x31, 0xb8, 0xd1, 0xca, 0x6c, 0xde, 0x09, 0xc2, 0x1a, 0xba, 0xaa, 0xab,
-    0xab, 0x1b, 0x44, 0xee, 0x0e, 0x8e, 0x14, 0x83, 0xbb, 0xfc, 0x15, 0xbd, 0xf2, 0xba, 0x0f, 0x3e,
-    0x8f, 0x53, 0x9a, 0x84, 0x3c, 0x01, 0x41, 0x83, 0x90, 0xc3, 0x20, 0x62, 0xa4, 0xb1, 0x27, 0x07,
-    0x64, 0x61, 0x1c, 0x4a, 0x09, 0x31, 0x0f, 0x58, 0x4c, 0x16, 0x5e, 0xb1, 0x94, 0x51, 0xc5, 0x04,
-    0x59, 0x10, 0xf9, 0x0a, 0xf8, 0x40, 0x32, 0xb1, 0xcf, 0x04, 0xc4, 0xff, 0x29, 0x45, 0x16, 0x39,
-    0x8f, 0xc1, 0x7c, 0x40, 0xb6, 0xad, 0xbd, 0x05, 0xc5, 0x44, 0x1c, 0x26, 0x34, 0x02, 0x7f, 0x44,
-    0x15, 0x21, 0xf7, 0xff, 0x7a, 0x73, 0xe3, 0xa6, 0x07, 0xfd, 0xee, 0x6b, 0x78, 0xca, 0xe4, 0x08,
-    0x1e, 0x87, 0xca, 0x49, 0xe3, 0xb4, 0xa6, 0xb1, 0x86, 0x68, 0xac, 0x15, 0xe0, 0x11, 0x17, 0x14,
-    0xb8, 0xa2, 0x90, 0x70, 0x60, 0x87, 0x8a, 0x09, 0x1d, 0x5d, 0xb2, 0x44, 0x72, 0x21, 0xc9, 0x3a,
-    0xe2, 0xf2, 0x5b, 0x86, 0x70, 0xf7, 0xdd, 0xdf, 0xf0, 0x42, 0x70, 0x70, 0xc5, 0x22, 0xb5, 0xcf,
-    0x8f, 0x36, 0xf7, 0x46, 0x50, 0x7f, 0xcc, 0x84, 0x0e, 0xe6, 0xa4, 0x7c, 0x5e, 0x53, 0xde, 0x42,
-    0x30, 0x5b, 0x9f, 0x47, 0x79, 0x1b, 0x83, 0xbc, 0xa7, 0xca, 0x1f, 0xf5, 0xdc, 0xa5, 0xc1, 0x72,
-    0xfc, 0xc0, 0x12, 0x26, 0x42, 0x1f, 0xee, 0x7a, 0x1e, 0xce, 0x6c, 0x4e, 0x1e, 0xf6, 0xbc, 0x63,
-    0x7d, 0x8b, 0x04, 0x97, 0x6f, 0x4f, 0xd6, 0x7f, 0xbc, 0x7e, 0xf1, 0xec, 0xf9, 0xfb, 0x2c, 0x74,
-    0x1e, 0x55, 0x33, 0x5e, 0x34, 0xfb, 0x82, 0x2c, 0x65, 0x3c, 0xf6, 0x05, 0x59, 0x2c, 0xd7, 0xec,
-    0x87, 0xbb, 0x2f, 0x5e, 0xfd, 0x03, 0x4f, 0xc2, 0x64, 0x3c, 0x8c, 0xf8, 0x01, 0xdc, 0xe9, 0x76,
-    0x27, 0x21, 0xc9, 0x03, 0x16, 0x29, 0xe6, 0x83, 0xaf, 0x6e, 0x7a, 0x4e, 0xce, 0x4d, 0x48, 0x25,
-    0xa9, 0x69, 0x9c, 0x39, 0x4c, 0xb3, 0x08, 0xb0, 0x06, 0x03, 0x11, 0x06, 0x1f, 0x18, 0x30, 0x99,
-    0x26, 0xfc, 0x80, 0xcc, 0x19, 0x55, 0xc8, 0x6f, 0x77, 0x3d, 0xb7, 0x0a, 0x5f, 0x12, 0x6c, 0xbd,
-    0xec, 0xc5, 0x79, 0x24, 0xf4, 0xa6, 0xe5, 0xd3, 0x3f, 0xee, 0x74, 0x11, 0x9a, 0xc6, 0xd9, 0xd0,
-    0x38, 0xdb, 0x7a, 0xf9, 0xfd, 0xd1, 0x7e, 0x8b, 0xb5, 0x33, 0x25, 0x8f, 0xa8, 0x40, 0x5a, 0x8e,
-    0x8c, 0x96, 0xc2, 0xef, 0xbb, 0xb5, 0xac, 0x0d, 0xf7, 0xa2, 0xc8, 0xe4, 0x5f, 0x3b, 0x08, 0x87,
-    0xe1, 0x77, 0xe7, 0x55, 0xa8, 0x3f, 0x57, 0x76, 0xc0, 0xdc, 0x41, 0xa8, 0x46, 0x7c, 0x4f, 0x41,
-    0x10, 0xca, 0x34, 0xa2, 0x47, 0x4e, 0x76, 0x97, 0x33, 0x76, 0x97, 0x35, 0xbb, 0xcb, 0x19, 0xbb,
-    0x5a, 0xc1, 0xe8, 0xb4, 0xc5, 0xe8, 0x4c, 0x19, 0xb5, 0x8e, 0x18, 0x9d, 0xb3, 0x18, 0xd5, 0x0c,
-    0xa3, 0xc2, 0x68, 0xaa, 0x7b, 0xe7, 0xa6, 0x0b, 0x1e, 0x86, 0x2c, 0xe6, 0xc3, 0x21, 0x39, 0x9d,
-    0x64, 0x02, 0xa1, 0x4b, 0xa7, 0x48, 0x27, 0x84, 0x84, 0xf4, 0xfa, 0xde, 0x27, 0x66, 0x40, 0xd5,
-    0x2e, 0x56, 0xb3, 0x50, 0xef, 0xf7, 0x5e, 0xef, 0x7a, 0xb5, 0x75, 0xab, 0xf9, 0x7c, 0x05, 0xe4,
-    0xe7, 0x55, 0x48, 0xc3, 0xdb, 0x55, 0x29, 0x40, 0xcf, 0x54, 0x82, 0xe2, 0x1a, 0xfd, 0xf6, 0xa6,
-    0x77, 0xa7, 0xeb, 0x2c, 0x82, 0xd1, 0x9e, 0xb4, 0xb2, 0xb5, 0x3b, 0x51, 0xb2, 0x5e, 0xf2, 0x02,
-    0x54, 0xd8, 0x13, 0xc8, 0x96, 0xd5, 0x36, 0xaa, 0x07, 0x9f, 0x37, 0x53, 0x7f, 0xe7, 0x07, 0x4c,
-    0xc0, 0x3e, 0x1a, 0x84, 0x5b, 0xd5, 0x37, 0x2c, 0xc9, 0xc0, 0xa7, 0x22, 0xf8, 0xbc, 0xf0, 0x45,
-    0xab, 0xaa, 0xfc, 0x91, 0xb0, 0xdf, 0x03, 0xc4, 0xac, 0x44, 0x1a, 0x3d, 0x43, 0xec, 0x9d, 0x25,
-    0xaf, 0xca, 0xc9, 0x17, 0x13, 0xd2, 0xd1, 0x2d, 0x95, 0x5d, 0x1f, 0xaf, 0xb5, 0xb2, 0x68, 0x4b,
-    0xb7, 0xd8, 0xc9, 0xf5, 0xa5, 0x84, 0xac, 0x20, 0xb1, 0x57, 0x8a, 0xa4, 0x77, 0xac, 0xc6, 0xeb,
-    0x98, 0x52, 0xef, 0x96, 0x79, 0xac, 0xa2, 0xda, 0xd6, 0x2d, 0x8e, 0x2b, 0xb9, 0xc1, 0x56, 0x4a,
-    0x13, 0xa1, 0x68, 0xc7, 0x7d, 0xf7, 0xa4, 0xaa, 0xeb, 0xa9, 0xbf, 0xa3, 0xed, 0xb6, 0xa3, 0x79,
-    0x92, 0x19, 0xc4, 0x6e, 0xa6, 0x60, 0x37, 0x8b, 0x70, 0x67, 0xca, 0xf1, 0x7f, 0xef, 0x57, 0xc4,
-    0xd5, 0xaa, 0xe0, 0xe8, 0x0d, 0x43, 0xd5, 0x0d, 0xb2, 0x62, 0x49, 0xb0, 0x63, 0x24, 0x58, 0x2d,
-    0xa7, 0xd9, 0x02, 0x19, 0xc6, 0x25, 0x42, 0xeb, 0x96, 0x10, 0x33, 0x46, 0x08, 0x8b, 0x68, 0xe1,
-    0x84, 0xfd, 0xeb, 0xe0, 0xe9, 0x1f, 0x1f, 0xf3, 0x46, 0x35, 0x9c, 0xe9, 0x57, 0x15, 0xbc, 0x95,
-    0xca, 0x7c, 0x69, 0x26, 0x7d, 0x71, 0x81, 0x2a, 0x5f, 0xc3, 0x65, 0x6f, 0x6b, 0x62, 0x27, 0x17,
-    0x73, 0xec, 0xf0, 0x38, 0xb0, 0x3c, 0x8e, 0x3c, 0x0e, 0x15, 0xa8, 0xa1, 0xaa, 0x82, 0x9a, 0xfb,
-    0xc4, 0x7e, 0x0b, 0xe3, 0xb7, 0x10, 0x7e, 0x0b, 0xe3, 0xcf, 0xb8, 0x4b, 0x94, 0xef, 0x76, 0x12,
-    0xd2, 0xc8, 0x33, 0x4a, 0x4c, 0xb5, 0xcc, 0x96, 0xfe, 0xb8, 0x48, 0xf4, 0x4c, 0x62, 0x6a, 0x98,
-    0xef, 0x34, 0x4d, 0x46, 0x46, 0x2c, 0x9c, 0xd0, 0xa4, 0x8f, 0x9b, 0x56, 0x5d, 0xb6, 0xa6, 0xb6,
-    0xd7, 0x66, 0x55, 0x92, 0x09, 0xb9, 0x96, 0x4a, 0x72, 0x09, 0x17, 0x07, 0xdb, 0x27, 0xa5, 0x42,
-    0x85, 0x4a, 0xdf, 0x96, 0xb1, 0x08, 0xb4, 0x43, 0xc5, 0x6d, 0xa7, 0x27, 0x5b, 0xda, 0x93, 0xf5,
-    0xcc, 0x93, 0xf5, 0x2c, 0xcb, 0xcc, 0x93, 0xf3, 0x28, 0xda, 0x7c, 0x41, 0xde, 0x36, 0xd5, 0x02,
-    0x32, 0xdc, 0x96, 0xb5, 0x37, 0x9f, 0x1b, 0x6e, 0xbe, 0x6c, 0xb8, 0x05, 0x77, 0x52, 0xa4, 0x9d,
-    0x31, 0x68, 0x6b, 0x06, 0xed, 0x8c, 0xc1, 0x32, 0x62, 0xb0, 0x9c, 0x72, 0xa1, 0x04, 0x45, 0x3a,
-    0x5a, 0x60, 0xbb, 0x53, 0x55, 0x5c, 0x2e, 0xc8, 0x6f, 0xdb, 0xa3, 0x01, 0x91, 0xaf, 0xd9, 0x77,
-    0xe5, 0xe4, 0x97, 0xcb, 0xe4, 0x67, 0xa7, 0x75, 0xe5, 0x6a, 0xc4, 0x3e, 0x50, 0xff, 0x08, 0x26,
-    0xba, 0x2b, 0x26, 0x95, 0xdd, 0xa5, 0x5f, 0xd1, 0x9f, 0xb3, 0x95, 0x1e, 0x68, 0xa0, 0xfa, 0xeb,
-    0x83, 0xcf, 0xc9, 0x12, 0x59, 0x72, 0xa1, 0xc8, 0x7f, 0xc3, 0xe2, 0x8c, 0x8f, 0x3d, 0x0b, 0x39,
-    0xfa, 0x82, 0x7b, 0x4c, 0xbe, 0x0f, 0x05, 0x8b, 0x98, 0x94, 0xf0, 0x82, 0xa6, 0x4c, 0x38, 0xeb,
-    0x77, 0x41, 0xdb, 0xe8, 0xac, 0x2e, 0xdf, 0x06, 0x2a, 0xdc, 0x46, 0x81, 0xde, 0xb0, 0xd0, 0x9b,
-    0x96, 0xd9, 0x11, 0x99, 0xb6, 0xfd, 0x9c, 0x31, 0x27, 0x17, 0x37, 0xee, 0x25, 0x8d, 0x3b, 0xfd,
-    0xe8, 0x42, 0x5a, 0x16, 0x6e, 0xbb, 0x1c, 0x1b, 0x1f, 0x5e, 0x4e, 0x59, 0xb8, 0xbf, 0xbf, 0x7e,
-    0xd2, 0xaf, 0x3e, 0x14, 0x98, 0x79, 0x56, 0xf1, 0xee, 0x5a, 0x33, 0xd3, 0xfa, 0x2b, 0x5e, 0x61,
-    0x49, 0x38, 0xe6, 0x63, 0x0a, 0x23, 0x9a, 0x04, 0x23, 0x16, 0x05, 0x90, 0x88, 0x21, 0x30, 0x4f,
-    0x9f, 0x3c, 0x83, 0x41, 0x0c, 0x53, 0xde, 0x22, 0x49, 0x2f, 0xeb, 0x1f, 0xc1, 0x15, 0x55, 0x2c,
-    0x70, 0xfe, 0xc5, 0x9d, 0xac, 0xc7, 0x27, 0x65, 0x41, 0x54, 0x56, 0x91, 0x80, 0xbf, 0x26, 0x34,
-    0xe1, 0x19, 0xa8, 0xe7, 0x69, 0x40, 0x57, 0xa8, 0x33, 0x3a, 0xd4, 0x3a, 0xba, 0x69, 0x7d, 0xe2,
-    0x35, 0x14, 0x76, 0x51, 0x53, 0xfe, 0xa6, 0x08, 0xff, 0x03, 0xbd, 0x96, 0x05, 0x93, 0xe3, 0x38,
-    0x10, 0x85, 0xb5, 0x98, 0xcc, 0x62, 0x38, 0xcb, 0x70, 0xcc, 0x67, 0x58, 0x2c, 0x3c, 0x5a, 0xe6,
-    0xc1, 0xe2, 0x2e, 0xc5, 0xe9, 0x49, 0x54, 0xb1, 0xa5, 0xac, 0xa4, 0x0c, 0xfd, 0xfa, 0x1b, 0x85,
-    0x2c, 0xab, 0x14, 0x1f, 0x5f, 0x71, 0x62, 0xab, 0xdf, 0xd7, 0xfd, 0xba, 0xe5, 0x26, 0x6c, 0x24,
-    0x46, 0x14, 0x38, 0xe5, 0x02, 0xb8, 0xdc, 0x85, 0x38, 0xee, 0xf7, 0x32, 0x48, 0x44, 0x36, 0xa6,
-    0x9c, 0x09, 0x0e, 0x92, 0xf6, 0x99, 0x80, 0x5e, 0x8a, 0xe4, 0xf3, 0x89, 0xea, 0x91, 0xf6, 0x88,
-    0x29, 0x05, 0x99, 0xe8, 0x63, 0x46, 0xda, 0x12, 0xc7, 0x48, 0x35, 0x4a, 0xd2, 0x11, 0x22, 0x03,
-    0x85, 0x72, 0x0f, 0x25, 0x39, 0xab, 0x34, 0x4b, 0x46, 0xd3, 0x58, 0x51, 0xb4, 0x2a, 0xd6, 0x17,
-    0x26, 0x56, 0xc7, 0x8a, 0xd5, 0x59, 0xc6, 0xea, 0x5a, 0xb1, 0x6a, 0x71, 0xf0, 0x0f, 0x23, 0xd4,
-    0xe3, 0x7f, 0x18, 0x80, 0xbc, 0x42, 0x1c, 0x6b, 0x44, 0xfe, 0x7a, 0x33, 0x84, 0xe5, 0x1b, 0x2d,
-    0x48, 0x85, 0xa4, 0x20, 0x34, 0x05, 0x2e, 0x00, 0x0f, 0x34, 0x4a, 0x4e, 0x53, 0x50, 0xc8, 0x95,
-    0x90, 0x8a, 0x90, 0xd7, 0x2c, 0x3d, 0x7c, 0x26, 0x60, 0xf3, 0xfb, 0x27, 0xc9, 0x50, 0x7c, 0xff,
-    0x9a, 0x69, 0xf4, 0x32, 0x7c, 0x6a, 0x18, 0x9a, 0x16, 0x43, 0x93, 0x0b, 0x0e, 0x6a, 0x88, 0x69,
-    0xea, 0x7d, 0xff, 0xfb, 0xe9, 0xfb, 0x39, 0x85, 0xc5, 0x79, 0x11, 0x7e, 0xa5, 0xb2, 0xff, 0x27,
-    0x55, 0xbc, 0x11, 0x2e, 0xf9, 0xce, 0xde, 0x32, 0x67, 0x2f, 0x59, 0x67, 0x2f, 0x2d, 0xcf, 0x5e,
-    0xb6, 0xce, 0x56, 0xe3, 0x8d, 0x18, 0xd4, 0x41, 0x18, 0x3d, 0x88, 0xfc, 0xc5, 0x86, 0xb1, 0x2a,
-    0xe3, 0xb8, 0x0e, 0x3d, 0xc9, 0xfa, 0x03, 0x04, 0x54, 0x63, 0x2e, 0xf6, 0xc9, 0x0d, 0xd1, 0x9b,
-    0x45, 0x86, 0xec, 0xa3, 0xd6, 0x05, 0xcc, 0x5b, 0x50, 0x7c, 0xd6, 0xd4, 0x28, 0x33, 0x66, 0xaa,
-    0x9f, 0x0c, 0xa9, 0x26, 0xb5, 0x87, 0x0f, 0xbc, 0x04, 0xff, 0x8b, 0x78, 0x15, 0x5e, 0x64, 0xe3,
-    0x49, 0xaa, 0x10, 0xde, 0xa7, 0x13, 0x95, 0xb7, 0x4b, 0xf5, 0x17, 0xa4, 0x19, 0x84, 0x3b, 0x7e,
-    0x32, 0x53, 0x9b, 0x3b, 0xbb, 0x93, 0x34, 0x25, 0x77, 0x0c, 0xe4, 0x9d, 0x7d, 0xb6, 0xcb, 0x48,
-    0xcd, 0x42, 0xad, 0x2d, 0x03, 0x5d, 0x71, 0x50, 0xaf, 0x16, 0x71, 0xea, 0x16, 0xea, 0x75, 0x07,
-    0xb5, 0xfa, 0x1b, 0x26, 0x23, 0x2f, 0xc0, 0x4d, 0xa3, 0x7a, 0xd1, 0xd2, 0xbb, 0x98, 0x83, 0x3f,
-    0xd9, 0x7c, 0x0e, 0x4f, 0x52, 0xa6, 0xb1, 0xcc, 0xdd, 0xaf, 0x4d, 0x80, 0xab, 0x56, 0x80, 0xab,
-    0xcb, 0x00, 0x77, 0x1d, 0x8a, 0x6b, 0x16, 0xe1, 0x67, 0x2e, 0xe1, 0x74, 0xa6, 0x7e, 0xf5, 0xfa,
-    0x07, 0xfe, 0x82, 0x80, 0x9d, 0x32, 0x90, 0xea, 0x6b, 0x13, 0x61, 0x3b, 0x82, 0x10, 0x42, 0x78,
-    0xe0, 0x67, 0x35, 0xd5, 0x9e, 0xce, 0xfe, 0x17, 0xa6, 0xce, 0xfe, 0x1b, 0xc0, 0xf5, 0x19, 0x0a,
-    0x57, 0xc2, 0x5d, 0xf7, 0x61, 0xa7, 0xd8, 0x05, 0xe4, 0xcd, 0xfd, 0x0d, 0x4d, 0x93, 0x11, 0x6c,
-    0x71, 0xa6, 0x8f, 0xf3, 0x79, 0xed, 0x05, 0xb9, 0x6b, 0x18, 0xea, 0x96, 0x7a, 0x7d, 0xa9, 0xde,
-    0xb0, 0xc4, 0x4e, 0xa0, 0x1a, 0xc2, 0x58, 0x24, 0x23, 0xd4, 0x7f, 0xfa, 0xfa, 0x39, 0x4d, 0xfb,
-    0x7b, 0xc8, 0xf5, 0x44, 0xa2, 0x2c, 0xb1, 0xed, 0x4f, 0xde, 0x80, 0x6e, 0x76, 0xad, 0x47, 0xff,
-    0x62, 0xb0, 0xd3, 0x2c, 0x63, 0x7e, 0xbb, 0xab, 0xb9, 0xc5, 0x24, 0x43, 0x35, 0xe4, 0x22, 0x15,
-    0x83, 0x43, 0xd8, 0x0f, 0xfd, 0xb9, 0xdc, 0x9e, 0xce, 0xcf, 0x6d, 0x03, 0x71, 0x7b, 0xea, 0xeb,
-    0x65, 0x0b, 0xe5, 0x72, 0x8e, 0xe2, 0xcc, 0xcf, 0x95, 0x62, 0x07, 0xd6, 0x2c, 0xd2, 0x6b, 0x4e,
-    0x77, 0x5e, 0x9e, 0x55, 0x97, 0x5c, 0x76, 0xcd, 0x66, 0x1c, 0xf7, 0x15, 0x66, 0x0c, 0x32, 0x8c,
-    0xee, 0xa7, 0x2a, 0x08, 0x21, 0xbf, 0x59, 0xca, 0x7d, 0x3a, 0xf1, 0xea, 0x09, 0xa8, 0xd8, 0x9b,
-    0x4f, 0xd7, 0x64, 0xd2, 0x9d, 0x66, 0x52, 0xc9, 0x6f, 0x5c, 0x87, 0xbe, 0x2b, 0x55, 0x14, 0x47,
-    0xa4, 0x6a, 0x51, 0x57, 0xe6, 0x94, 0x15, 0x87, 0x32, 0x13, 0x52, 0x21, 0xf4, 0x90, 0x27, 0x43,
-    0x90, 0x74, 0x74, 0xef, 0x41, 0x1c, 0xe6, 0xba, 0xe4, 0x82, 0x0e, 0x1e, 0x3f, 0xb0, 0x7e, 0x9f,
-    0x1d, 0x4b, 0xd1, 0x9f, 0x24, 0x7a, 0xc6, 0xe4, 0xbe, 0x4d, 0xde, 0x9a, 0x65, 0xe1, 0x59, 0x04,
-    0x5b, 0xa9, 0x96, 0x34, 0xcf, 0x96, 0x70, 0xd6, 0x33, 0xde, 0xa9, 0x44, 0x22, 0x72, 0x48, 0x04,
-    0xe7, 0x98, 0x68, 0xbf, 0xbd, 0x5f, 0x18, 0xbf, 0x60, 0xda, 0x35, 0x30, 0x9b, 0x44, 0xb0, 0xbb,
-    0x07, 0xf2, 0xf6, 0x01, 0x72, 0xbb, 0x90, 0x75, 0x61, 0x16, 0xdd, 0xd9, 0x03, 0x52, 0x39, 0x42,
-    0x29, 0xca, 0xb5, 0x3f, 0x9b, 0x69, 0x7f, 0x36, 0xd5, 0xfe, 0x6c, 0xa6, 0xdd, 0xca, 0xe5, 0x6e,
-    0x3a, 0x72, 0x6d, 0x5b, 0xae, 0xe5, 0xc8, 0x91, 0xf7, 0x52, 0xbc, 0x61, 0x89, 0x14, 0x5e, 0x17,
-    0xaf, 0x1a, 0x17, 0xd7, 0xac, 0x4e, 0x5c, 0x5b, 0x16, 0xab, 0xbe, 0xf0, 0x72, 0xea, 0xa1, 0x89,
-    0xcf, 0x68, 0x1a, 0x92, 0x46, 0x69, 0xc3, 0x9c, 0xb3, 0x9c, 0x5e, 0x9b, 0x3b, 0xbd, 0xe6, 0x38,
-    0xbd, 0x1e, 0xbe, 0x45, 0x3f, 0x4d, 0xc7, 0xd0, 0x9c, 0xb5, 0x68, 0xce, 0x2e, 0x69, 0x2e, 0x95,
-    0x37, 0x6a, 0xa5, 0xb0, 0xdf, 0xcd, 0x74, 0xcf, 0x16, 0x75, 0x4f, 0xfc, 0xfc, 0x0a, 0xe2, 0x70,
-    0xc5, 0x74, 0x5e, 0x35, 0x15, 0x9f, 0x55, 0xe3, 0xaa, 0xa9, 0x77, 0x79, 0x4d, 0xf2, 0xaf, 0xdb,
-    0xac, 0xbf, 0x1b, 0xc5, 0x41, 0xb4, 0x8b, 0xd0, 0x72, 0x86, 0x74, 0x45, 0x51, 0xce, 0xdc, 0xb3,
-    0xa6, 0xb2, 0x3c, 0xd5, 0x86, 0xa4, 0xa3, 0x30, 0x8e, 0x83, 0x08, 0xf6, 0xa3, 0xfb, 0x1f, 0xc3,
-    0x07, 0xcb, 0xb7, 0x49, 0x63, 0xc2, 0x8f, 0xd1, 0xb1, 0x9f, 0xff, 0x73, 0xda, 0x0c, 0x86, 0x3f,
-    0x61, 0xd4, 0x43, 0x94, 0x1c, 0xb5, 0x95, 0xba, 0x3f, 0x69, 0x6f, 0x1b, 0x94, 0x23, 0x7e, 0x1e,
-    0x41, 0x79, 0x0a, 0x7f, 0x9c, 0xe0, 0xfd, 0x20, 0x08, 0x41, 0xa5, 0x42, 0x43, 0x92, 0xa7, 0x73,
-    0x35, 0x02, 0xd5, 0x07, 0x85, 0xd8, 0x47, 0x09, 0x82, 0xa7, 0x87, 0x9e, 0x94, 0x1b, 0x6e, 0x55,
-    0x2c, 0x37, 0x60, 0x91, 0x74, 0x39, 0x5e, 0xbb, 0xec, 0xe9, 0xc2, 0xc1, 0xf2, 0x10, 0x8e, 0xbd,
-    0xa7, 0x77, 0x98, 0x7a, 0x63, 0xbe, 0x93, 0x9b, 0x74, 0xe0, 0xb5, 0xc3, 0xec, 0x55, 0x2b, 0x37,
-    0xaa, 0x52, 0x25, 0x7b, 0xa3, 0xaa, 0xcd, 0x9b, 0x8b, 0x6c, 0x20, 0x57, 0xf8, 0x2b, 0x1d, 0xc3,
-    0x86, 0x48, 0xa9, 0xb4, 0xd6, 0xbc, 0x17, 0xbc, 0xcf, 0x12, 0xaa, 0x85, 0xfc, 0xfe, 0xc9, 0xc6,
-    0xfb, 0xb7, 0x62, 0x7f, 0x0a, 0x33, 0xe7, 0x30, 0x08, 0x8d, 0xd7, 0x62, 0x9d, 0x7e, 0xff, 0x36,
-    0x7c, 0xb0, 0x1e, 0x39, 0x8f, 0x60, 0xb6, 0x8c, 0xb8, 0x07, 0x3e, 0x9f, 0xfd, 0x4f, 0x94, 0x11,
-    0x3a, 0x60, 0x54, 0x40, 0x1c, 0x6c, 0xc0, 0x5f, 0x5c, 0xd4, 0x3b, 0x85, 0x1e, 0x2b, 0xec, 0xed,
-    0x57, 0x73, 0x23, 0xcf, 0xc7, 0xff, 0x51, 0x60, 0xb2, 0xa1, 0xa9, 0x36, 0x31, 0x9f, 0x99, 0xbe,
-    0x1d, 0x0c, 0x18, 0x1f, 0xc0, 0xca, 0xdd, 0xfb, 0xfc, 0xf2, 0x49, 0xd3, 0x79, 0xb2, 0x16, 0xc3,
-    0x71, 0x51, 0xe3, 0xc8, 0xbf, 0x4c, 0x99, 0x29, 0x9b, 0xad, 0x54, 0x77, 0x4d, 0xc5, 0x8a, 0x8b,
-    0x95, 0xab, 0x4a, 0xea, 0x32, 0xca, 0x7f, 0xdc, 0x70, 0xee, 0x90, 0xb6, 0x95, 0xc6, 0x6d, 0xe7,
-    0x59, 0x6b, 0xde, 0x02, 0x8d, 0xc5, 0xe1, 0xab, 0xce, 0x0b, 0xf6, 0xea, 0xe6, 0x06, 0xae, 0x2f,
-    0xfa, 0x47, 0x87, 0x41, 0x10, 0xe0, 0xea, 0xef, 0x7e, 0x25, 0x87, 0xb7, 0xbf, 0xfe, 0xe5, 0x9d,
-    0xea, 0xdb, 0x02, 0x7e, 0x07, 0xb5, 0x54, 0x55, 0xb7, 0xdb, 0x30, 0x0c, 0xd6, 0x18, 0x0a, 0x63,
-    0x66, 0x66, 0x48, 0x7a, 0xf1, 0x71, 0xcc, 0xcc, 0x4f, 0x3a, 0x4e, 0xab, 0xae, 0x3e, 0x4d, 0xec,
-    0xcc, 0x4e, 0xe1, 0xe7, 0x2f, 0x2e, 0x78, 0x8e, 0xe7, 0xf1, 0xee, 0xab, 0x2d, 0x7d, 0x20, 0x82,
-    0xb7, 0x78, 0x9b, 0x58, 0x86, 0x6f, 0x5a, 0xf8, 0x66, 0x90, 0x2b, 0xca, 0x08, 0xdf, 0x7c, 0x8c,
-    0xe2, 0xa5, 0x18, 0xdb, 0x32, 0xcb, 0x99, 0xe0, 0x52, 0xa0, 0x62, 0x1d, 0x2e, 0x31, 0x49, 0x09,
-    0xae, 0x62, 0xae, 0xe1, 0xd2, 0x88, 0x77, 0x39, 0x1c, 0xea, 0x73, 0xad, 0x31, 0x93, 0x1d, 0xca,
-    0xe0, 0x90, 0xa2, 0x9c, 0x58, 0x41, 0x0a, 0x4e, 0x61, 0xa2, 0x78, 0xe7, 0x33, 0x21, 0xe9, 0x5c,
-    0xc8, 0x11, 0x9c, 0x96, 0x89, 0x26, 0x35, 0x24, 0x85, 0xd9, 0x97, 0xa2, 0x80, 0xc3, 0x52, 0x66,
-    0x38, 0x7d, 0x80, 0xb3, 0x58, 0xfd, 0x5b, 0x97, 0x18, 0x1d, 0x3f, 0x21, 0x3f, 0x69, 0xc8, 0x1b,
-    0x0e, 0x6d, 0xc3, 0xd2, 0xee, 0xf3, 0xb0, 0x9a, 0x0e, 0xcf, 0x41, 0xef, 0x6f, 0xfb, 0xf2, 0xd2,
-    0x5a, 0xc2, 0xaf, 0x23, 0xa1, 0x0b, 0xa6, 0xf0, 0x4e, 0x0b, 0xf5, 0x78, 0xe2, 0xc5, 0x81, 0xdc,
-    0x6d, 0x21, 0x0f, 0x7b, 0x85, 0xda, 0xb9, 0xf2, 0x7b, 0x71, 0xeb, 0x7a, 0x5c, 0xf4, 0x9f, 0x97,
-    0x41, 0xf8, 0x2c, 0x0a, 0xda, 0x38, 0x36, 0xd0, 0x49, 0xd8, 0x46, 0x45, 0x76, 0x2d, 0x0e, 0x67,
-    0x77, 0x07, 0x69, 0x0a, 0xc7, 0xca, 0x20, 0xce, 0xd2, 0x29, 0xd6, 0x31, 0xd3, 0xee, 0x2a, 0xe2,
-    0x6b, 0x5b, 0x18, 0x4f, 0x5d, 0x43, 0x39, 0x14, 0x8d, 0x32, 0x22, 0xe3, 0x82, 0xa5, 0xd8, 0xee,
-    0xb1, 0x02, 0x6a, 0xad, 0x3f, 0xd5, 0xbb, 0x0f, 0x53, 0xa9, 0x18, 0xca, 0x82, 0xa1, 0x90, 0x48,
-    0xe3, 0xf2, 0xcd, 0xa0, 0x69, 0x12, 0x5a, 0x2a, 0x5d, 0xb5, 0xb3, 0xf8, 0xe3, 0x9e, 0xae, 0xa5,
-    0xa7, 0xa5, 0x7f, 0xea, 0xc1, 0x72, 0x38, 0x9b, 0x8a, 0x1e, 0x29, 0x41, 0xc5, 0x5c, 0xb9, 0xab,
-    0xf8, 0x5f, 0xc7, 0xb3, 0xb6, 0x1a, 0xe2, 0xc4, 0x09, 0x09, 0x4e, 0x59, 0x30, 0x4c, 0x83, 0x2e,
-    0x2e, 0x02, 0x7c, 0x60, 0x43, 0xd2, 0x3d, 0xa6, 0xc8, 0xdc, 0x8e, 0xa7, 0xaf, 0xa3, 0x28, 0x0e,
-    0x0f, 0xe4, 0x59, 0x23, 0x7f, 0xaf, 0x83, 0xb8, 0x37, 0x67, 0xaa, 0xe0, 0x85, 0x89, 0xa2, 0x71,
-    0x19, 0xde, 0x21, 0x85, 0x73, 0x12, 0x4f, 0xed, 0x45, 0xcb, 0xe8, 0xff, 0xec, 0xb5, 0xee, 0x8f,
-    0x7a, 0x3f, 0xfb, 0x1c, 0xf7, 0x27, 0xfc, 0xe5, 0x7c, 0xf8, 0x29, 0xbe, 0x19, 0x2f, 0x62, 0xc2,
-    0x4c, 0x83, 0x83, 0x85, 0x68, 0x7e, 0xf3, 0xbb, 0xae, 0x7c, 0x7b, 0xab, 0x58, 0xbb, 0x4f, 0x0a,
-    0x9f, 0x86, 0xf7, 0xe5, 0x84, 0x31, 0xb7, 0xc3, 0x6a, 0xd9, 0xe9, 0x70, 0xc3, 0xa8, 0x8c, 0x19,
-    0x65, 0x51, 0x14, 0xdd, 0x44, 0x1b, 0x00, 0x1f, 0xb8, 0x9c, 0x41, 0x3e, 0x8d, 0xd6, 0x70, 0x1f,
-    0xea, 0xf7, 0xb8, 0xe8, 0x07, 0xf1, 0x77, 0x39, 0xd0, 0xf0, 0x91, 0x33, 0x69, 0x2e, 0x55, 0x28,
-    0xf0, 0x88, 0xd9, 0x9d, 0x83, 0x46, 0xcd, 0xc1, 0xc9, 0xec, 0x6d, 0x75, 0x12, 0xb7, 0x5a, 0x4d,
-    0xdb, 0x1c, 0xd2, 0xcd, 0xc1, 0x6d, 0xc0, 0x70, 0x26, 0xc2, 0x26, 0xa1, 0xba, 0x8b, 0x71, 0x98,
-    0xdb, 0xd0, 0xd6, 0x9c, 0xb4, 0x9a, 0x25, 0xdc, 0x33, 0x5f, 0x4f, 0xa5, 0xe3, 0x56, 0x0c, 0x75,
-    0x87, 0x7f, 0xd3, 0x9b, 0x5f, 0x39, 0x09, 0x7b, 0xd8, 0xe9, 0x6d, 0xfc, 0xae, 0xea, 0xd0, 0xb8,
-    0x16, 0xf7, 0x78, 0x03, 0xb5, 0x75, 0x5a, 0x7c, 0xd8, 0xfa, 0xe1, 0xd1, 0x8b, 0xf0, 0x80, 0x18,
-    0xee, 0xa3, 0x93, 0x3d, 0x3e, 0x3a, 0xbb, 0x40, 0x47, 0x8d, 0x92, 0xa3, 0x93, 0x9a, 0xd6, 0x1d,
-    0x3d, 0xf5, 0xef, 0xd7, 0x02, 0xea, 0x56, 0xe3, 0x5e, 0x4f, 0xe3, 0xbe, 0xaa, 0x8e, 0x86, 0xa3,
-    0xf1, 0x80, 0xa7, 0xb1, 0x3e, 0xd3, 0x58, 0xaf, 0xde, 0xae, 0xaf,
+    0xf2, 0x0c, 0x66, 0x67, 0x88, 0x0f, 0x02, 0x90, 0x52, 0x1d, 0xb8, 0x8e, 0x83, 0x40, 0xd4, 0x37,
+    0x4a, 0xcf, 0x75, 0x9e, 0x70, 0x3c, 0xce, 0xa2, 0x50, 0x9c, 0x19, 0xd2, 0x4e, 0xbf, 0xcd, 0x42,
+    0x21, 0x7c, 0xe6, 0x57, 0x15, 0xca, 0x6b, 0x74, 0x68, 0x22, 0x93, 0x88, 0x9f, 0x2d, 0xf4, 0x6c,
+    0x87, 0x23, 0x81, 0x64, 0x0a, 0xf1, 0xd6, 0xe1, 0x10, 0xfd, 0x04, 0x36, 0x83, 0x8d, 0xb8, 0x48,
+    0x5f, 0xf7, 0x71, 0xb3, 0xa3, 0x9d, 0x41, 0x13, 0x6c, 0x0c, 0x45, 0x13, 0xbd, 0xa3, 0xb2, 0x3b,
+    0x7b, 0x34, 0x10, 0x6d, 0x74, 0x24, 0x1f, 0xc7, 0x51, 0xe7, 0x42, 0x9b, 0x9a, 0x44, 0xc3, 0xb5,
+    0xc4, 0x4c, 0x2b, 0xa1, 0x94, 0x7e, 0x11, 0x07, 0x4a, 0x6f, 0x99, 0xf1, 0xe2, 0x5c, 0x1b, 0x85,
+    0x02, 0x97, 0x33, 0xa8, 0x49, 0x6d, 0x7c, 0x21, 0xb6, 0xa6, 0x1a, 0xa7, 0x3c, 0x92, 0x1a, 0x44,
+    0x1b, 0xed, 0x1d, 0x29, 0x4c, 0x9e, 0x94, 0xc6, 0x85, 0x26, 0xa5, 0x6f, 0x68, 0xa6, 0x15, 0x73,
+    0x7d, 0x6f, 0x0a, 0x14, 0x0a, 0x9c, 0xc7, 0x51, 0xc9, 0xa0, 0x70, 0xfe, 0x9c, 0xd2, 0x3b, 0x54,
+    0x15, 0xac, 0x29, 0xca, 0xf4, 0x6a, 0xdb, 0xf3, 0xd6, 0x76, 0x38, 0x59, 0x11, 0xf8, 0x38, 0x90,
+    0x2f, 0xdb, 0xe8, 0x30, 0x19, 0x4e, 0x36, 0xfd, 0xd3, 0xd2, 0x7d, 0x32, 0x61, 0x20, 0x6e, 0x61,
+    0xe0, 0xfc, 0x08, 0x63, 0x2f, 0xc4, 0x57, 0xe2, 0x79, 0xf2, 0x4d, 0x69, 0x8c, 0x1e, 0xb3, 0xa8,
+    0x56, 0xe7, 0x94, 0x67, 0x0b, 0xb9, 0x59, 0xbf, 0x6f, 0x0d, 0x6f, 0x18, 0x58, 0xd6, 0x9b, 0xb5,
+    0x02, 0xc3, 0x45, 0x36, 0x88, 0xc9, 0x20, 0x44, 0xd0, 0x3d, 0x11, 0x07, 0xe3, 0x20, 0x14, 0x24,
+    0xb2, 0x68, 0x9e, 0xf9, 0x4e, 0xaf, 0x3e, 0xa0, 0x7f, 0x10, 0xfd, 0xe9, 0x69, 0x39, 0x3a, 0x9a,
+    0xc3, 0xa3, 0xd8, 0xe5, 0x44, 0x52, 0xec, 0xe3, 0x07, 0x31, 0xca, 0xa1, 0x29, 0x38, 0x54, 0x42,
+    0xac, 0x2f, 0x38, 0x36, 0xa7, 0xd5, 0x66, 0xb3, 0x5c, 0xe3, 0xb6, 0xde, 0x9d, 0x57, 0x7b, 0xe4,
+    0x39, 0x54, 0x92, 0xdd, 0x72, 0xb9, 0x82, 0xb8, 0x98, 0x70, 0x80, 0x2e, 0x59, 0x43, 0x06, 0x08,
+    0xd1, 0x40, 0x8c, 0x18, 0xdc, 0xa3, 0x50, 0x5c, 0x82, 0x1d, 0x2d, 0x0d, 0x2d, 0xb3, 0x32, 0x32,
+    0x77, 0xe5, 0xe5, 0x7b, 0xe9, 0xe0, 0xb5, 0x97, 0x7f, 0xcd, 0x0f, 0x36, 0xb0, 0xb4, 0x64, 0x65,
+    0x13, 0xd5, 0xfd, 0xca, 0x53, 0xd0, 0x29, 0x64, 0xee, 0xca, 0xdd, 0x9c, 0x94, 0xeb, 0x8f, 0x46,
+    0x4b, 0xc4, 0xde, 0xfe, 0x43, 0xfe, 0x94, 0x55, 0x1d, 0xdc, 0x69, 0x23, 0x5d, 0xf4, 0x51, 0x25,
+    0x21, 0x1c, 0x13, 0xbe, 0xf4, 0xde, 0x13, 0xb7, 0x6f, 0x91, 0x06, 0x48, 0x75, 0xb7, 0x56, 0xce,
+    0x31, 0x76, 0x0a, 0x24, 0x64, 0x4f, 0x9b, 0x23, 0xc4, 0xd8, 0xe8, 0x20, 0x34, 0x1c, 0x69, 0xdc,
+    0xf6, 0xd7, 0xef, 0x9b, 0x41, 0xb2, 0x53, 0x6d, 0x4f, 0xbb, 0x33, 0xba, 0xaf, 0xdd, 0xe7, 0x8f,
+    0x3c, 0xf1, 0xdb, 0x92, 0x02, 0x38, 0x83, 0x73, 0xc1, 0xa8, 0xc3, 0xbf, 0x7a, 0x2b, 0x5d, 0x02,
+    0xba, 0x76, 0xed, 0x59, 0xae, 0xb9, 0xba, 0xe5, 0x82, 0xbb, 0xd9, 0x6b, 0xb5, 0x6d, 0x4a, 0x1a,
+    0x5d, 0xba, 0xcf, 0x92, 0x11, 0xdd, 0x0b, 0x04, 0x94, 0xf0, 0x94, 0xac, 0x6a, 0x6a, 0xed, 0x7c,
+    0xdf, 0xa2, 0x9f, 0x63, 0x0e, 0xc5, 0x67, 0x0b, 0x64, 0xb5, 0xda, 0x8b, 0x3d, 0x7f, 0xcc, 0x62,
+    0xb9, 0x93, 0xa2, 0xaa, 0x7d, 0x4f, 0xf8, 0x23, 0x8b, 0x40, 0x5e, 0x7b, 0x96, 0x63, 0x11, 0x26,
+    0xb8, 0x4f, 0x1d, 0xdb, 0x86, 0xdc, 0x33, 0x93, 0x26, 0x67, 0x96, 0xdd, 0xc6, 0xe9, 0xc2, 0xd5,
+    0x37, 0xf8, 0xc7, 0xe8, 0x7e, 0x3e, 0xf8, 0xd4, 0x87, 0x62, 0xe1, 0xc3, 0x8e, 0x9b, 0x73, 0x3e,
+    0x7f, 0xdd, 0xa6, 0x9d, 0x20, 0x1a, 0x1f, 0x86, 0x58, 0xd5, 0x6f, 0x1b, 0x0d, 0x04, 0xc0, 0x2e,
+    0x0b, 0x05, 0xf3, 0xa9, 0x2f, 0xf0, 0x92, 0xa6, 0x99, 0xd7, 0x9e, 0x2d, 0x2c, 0x39, 0x9a, 0x63,
+    0x5b, 0x8a, 0x2f, 0x2e, 0x90, 0xb0, 0xf1, 0xb6, 0x01, 0x46, 0xf9, 0xc9, 0xd3, 0xd9, 0x4a, 0x9b,
+    0x48, 0x8a, 0x09, 0x0f, 0xbd, 0x58, 0xde, 0x1f, 0xcd, 0xee, 0xc7, 0x3e, 0xb1, 0xa1, 0xaa, 0xcd,
+    0x5f, 0xbb, 0x3b, 0x43, 0x39, 0xae, 0x89, 0xa2, 0x29, 0x46, 0xfc, 0x58, 0xd0, 0x61, 0x90, 0x4c,
+    0x43, 0xef, 0x1c, 0x2a, 0xf2, 0x78, 0x76, 0x9a, 0x7d, 0x56, 0x34, 0xde, 0xb6, 0xc1, 0x30, 0x2a,
+    0x37, 0x6f, 0x3d, 0xfb, 0x3f, 0x59, 0x75, 0x74, 0xcb, 0x6a, 0x82, 0x86, 0xdf, 0x5d, 0xc1, 0xc5,
+    0x9f, 0x0f, 0x94, 0xb5, 0x6b, 0x0b, 0x78, 0xa2, 0xf5, 0x2c, 0xc9, 0x48, 0xbf, 0x7e, 0xe3, 0xd9,
+    0xe2, 0x72, 0x73, 0x6d, 0x4b, 0x13, 0x16, 0xe4, 0x88, 0xce, 0x4f, 0xd1, 0x49, 0x27, 0x36, 0xe4,
+    0x17, 0xc8, 0x3c, 0xe6, 0xb8, 0xef, 0xc5, 0x43, 0xdc, 0xce, 0x08, 0x8a, 0xd4, 0x8b, 0x27, 0x16,
+    0xb5, 0x20, 0xdf, 0xdc, 0xaa, 0xd9, 0x50, 0x33, 0x2a, 0xf5, 0x9b, 0xb7, 0xee, 0x3f, 0x40, 0xc6,
+    0x2b, 0x8a, 0x72, 0xc6, 0x0a, 0x1f, 0xd1, 0x35, 0x53, 0x9a, 0xb2, 0xea, 0xea, 0x04, 0x6a, 0x9a,
+    0x89, 0xc4, 0x1f, 0x2a, 0x58, 0x5b, 0xe1, 0x46, 0x29, 0xae, 0x49, 0x6d, 0xf9, 0x87, 0x40, 0xae,
+    0x5e, 0x21, 0x50, 0x36, 0xaa, 0x57, 0x6f, 0xde, 0x7f, 0x64, 0xce, 0x84, 0x39, 0x41, 0xf1, 0x18,
+    0x07, 0x82, 0x8a, 0x43, 0x01, 0x39, 0xa3, 0x2a, 0x87, 0xa2, 0x81, 0xe7, 0x06, 0xfa, 0xc1, 0xa8,
+    0xcc, 0x5d, 0xbb, 0x75, 0xfb, 0xce, 0x83, 0xc7, 0xc6, 0x2f, 0x58, 0x28, 0x2c, 0x34, 0xb7, 0x6e,
+    0xa8, 0x1b, 0x85, 0x8a, 0x59, 0x37, 0x20, 0xff, 0xec, 0x85, 0x41, 0xe3, 0x37, 0xe8, 0x58, 0x53,
+    0x79, 0x56, 0xb1, 0xac, 0x2a, 0x40, 0x49, 0xf9, 0xba, 0x46, 0xa7, 0x3c, 0x46, 0xd3, 0x02, 0xa1,
+    0x6c, 0x82, 0xf2, 0x0c, 0x62, 0x80, 0xbe, 0xb0, 0x64, 0xcf, 0xa6, 0x0a, 0x8d, 0x96, 0xde, 0x7a,
+    0xb0, 0xb0, 0xb4, 0x7a, 0x69, 0x63, 0x3f, 0x88, 0x59, 0xc8, 0xb0, 0x2d, 0x7d, 0xf6, 0xa6, 0x2c,
+    0x06, 0x43, 0x33, 0xd3, 0x68, 0xd7, 0xd2, 0x7c, 0xfb, 0x69, 0x4b, 0xef, 0x76, 0x08, 0x98, 0xd2,
+    0x23, 0xa9, 0xa7, 0x20, 0x18, 0xf3, 0xb1, 0x47, 0x47, 0xd8, 0x7e, 0xd0, 0x15, 0x43, 0x1a, 0xc5,
+    0x87, 0x94, 0xd9, 0x32, 0xa3, 0x87, 0x83, 0x09, 0x95, 0x31, 0xcd, 0x6b, 0xd7, 0x1e, 0xd1, 0x18,
+    0x0b, 0x47, 0xb0, 0xa1, 0x5c, 0xdc, 0xc3, 0xb0, 0xac, 0xd6, 0x31, 0x43, 0xcb, 0x91, 0x17, 0x71,
+    0x75, 0xc1, 0xb6, 0x11, 0xac, 0x32, 0x7a, 0x61, 0x75, 0x5e, 0xdd, 0x4c, 0x17, 0x35, 0x72, 0x39,
+    0x2f, 0x27, 0x22, 0xf0, 0xc7, 0x7f, 0xe0, 0x6b, 0x3f, 0xe3, 0xaf, 0xfe, 0x84, 0x87, 0x3d, 0xc6,
+    0xa6, 0x82, 0xb1, 0xa8, 0xd3, 0xb3, 0x64, 0x26, 0x40, 0x27, 0x08, 0xcf, 0x5d, 0x4e, 0x7b, 0x2b,
+    0x8e, 0x3f, 0xe2, 0x2b, 0x9d, 0x40, 0x30, 0x28, 0x20, 0xb2, 0x8e, 0x05, 0x1d, 0xd1, 0x04, 0xd9,
+    0x87, 0x92, 0x5e, 0x5d, 0xd2, 0x9b, 0xa3, 0xdb, 0x98, 0x33, 0xe9, 0x43, 0x73, 0xe9, 0xa8, 0x93,
+    0x2e, 0xc9, 0x8a, 0xaa, 0x72, 0xe1, 0x11, 0xb7, 0xf6, 0x1a, 0xf3, 0x56, 0xcb, 0x56, 0x3a, 0xfd,
+    0x38, 0x99, 0x1e, 0x87, 0x09, 0xa3, 0x9f, 0xc3, 0xe3, 0x04, 0xcb, 0x42, 0xdf, 0x62, 0xde, 0x84,
+    0x5a, 0x7d, 0xe9, 0xb5, 0x8b, 0x9a, 0xd0, 0x77, 0x98, 0x3f, 0x86, 0xa2, 0xbc, 0xa5, 0x3b, 0xbd,
+    0x5d, 0xea, 0x84, 0xc8, 0x26, 0x7b, 0x5b, 0x93, 0xdb, 0x12, 0xa4, 0x14, 0x67, 0xbb, 0x0d, 0x45,
+    0xfd, 0xd9, 0xe2, 0x9a, 0xde, 0x91, 0xab, 0xef, 0x36, 0xb5, 0xf0, 0x7f, 0x5b, 0x11, 0xc0, 0xc7,
+    0x5a, 0xab, 0xdb, 0x2e, 0xec, 0xb7, 0xba, 0x02, 0x03, 0x45, 0xbf, 0x45, 0x81, 0x40, 0x7c, 0x27,
+    0xe5, 0x9b, 0x93, 0xd5, 0x39, 0xe5, 0x18, 0x41, 0x21, 0xed, 0x2f, 0x7a, 0xc3, 0x13, 0x16, 0x89,
+    0xe3, 0x98, 0xc5, 0xd9, 0x97, 0xca, 0x0a, 0xe7, 0x5e, 0x7b, 0x93, 0xcd, 0x8a, 0xc1, 0x24, 0x80,
+    0xbc, 0xbe, 0x08, 0xb2, 0xb2, 0x23, 0x1e, 0xf2, 0xa3, 0x73, 0x7a, 0x6a, 0xfd, 0x56, 0xce, 0xb0,
+    0x1f, 0x44, 0xec, 0x34, 0x61, 0x93, 0x80, 0x4e, 0x98, 0xdd, 0x0a, 0x93, 0x86, 0xf2, 0x6f, 0x6e,
+    0xcf, 0xa1, 0x09, 0x41, 0x57, 0xa8, 0xdc, 0x90, 0xf9, 0x35, 0xe1, 0x31, 0xfa, 0x61, 0xc0, 0x22,
+    0x7f, 0x24, 0x5b, 0x4e, 0xb3, 0x4d, 0xb0, 0x3a, 0x4b, 0x55, 0x59, 0xe9, 0x38, 0x96, 0xa7, 0x31,
+    0x1f, 0x1e, 0xfb, 0xaa, 0xb3, 0x5e, 0x9e, 0xc2, 0x81, 0x4c, 0x0a, 0xd7, 0xa6, 0xdf, 0x42, 0x4c,
+    0x66, 0x29, 0x2b, 0x51, 0x30, 0x18, 0x84, 0xe8, 0x1c, 0x3f, 0xc6, 0x58, 0x52, 0x9f, 0x47, 0x11,
+    0xf3, 0x05, 0xd6, 0x7c, 0xed, 0xfa, 0xbd, 0xe7, 0x8b, 0xcb, 0x6b, 0xbb, 0xda, 0xbf, 0x2c, 0xe6,
+    0x17, 0xfb, 0xba, 0xdc, 0x97, 0xdb, 0x80, 0x22, 0xb9, 0x1f, 0xf8, 0x31, 0x9f, 0x05, 0xe7, 0x2f,
+    0x22, 0x19, 0x7d, 0xb5, 0x0e, 0x18, 0x9f, 0xc9, 0x99, 0x5c, 0xe7, 0x36, 0xf7, 0x28, 0xb1, 0xd0,
+    0xbe, 0x39, 0x65, 0x5f, 0x56, 0xfc, 0xa5, 0x26, 0x5a, 0x54, 0x20, 0xaf, 0xdf, 0x15, 0x15, 0xa9,
+    0x9a, 0x76, 0x65, 0xfe, 0xda, 0xb3, 0x86, 0x45, 0xde, 0xbc, 0x7d, 0xf7, 0x7e, 0x7d, 0xf3, 0x6f,
+    0xb7, 0xd8, 0x0f, 0x12, 0xa5, 0xce, 0x3d, 0xef, 0x08, 0xb4, 0xf4, 0x31, 0xe8, 0x62, 0x2b, 0x60,
+    0xdb, 0xde, 0x94, 0x76, 0x53, 0x41, 0xd4, 0x3f, 0x46, 0xc3, 0xc0, 0xf7, 0x04, 0x8f, 0x57, 0x1c,
+    0x14, 0x5f, 0x7e, 0x0a, 0xb9, 0x42, 0xbd, 0x23, 0x5b, 0xc0, 0x81, 0xd5, 0xfe, 0x8a, 0xc2, 0x5c,
+    0xbc, 0x01, 0xf9, 0x42, 0x11, 0x94, 0x80, 0x9e, 0x05, 0x1e, 0x97, 0x6d, 0x60, 0xf6, 0xde, 0xca,
+    0xea, 0x86, 0x49, 0x2e, 0xe7, 0x80, 0xf1, 0x55, 0x7e, 0x42, 0xbf, 0x60, 0x4c, 0x8e, 0x82, 0xe8,
+    0x08, 0x3d, 0xbe, 0x54, 0x91, 0x7f, 0x0c, 0x42, 0xf1, 0x75, 0x62, 0x67, 0x32, 0x90, 0x01, 0xa4,
+    0xee, 0xc7, 0xb8, 0xab, 0x64, 0xa0, 0x96, 0x8e, 0x20, 0xac, 0x46, 0xa3, 0xc1, 0x2e, 0x49, 0xf7,
+    0xa8, 0x4a, 0x4f, 0x4c, 0xec, 0xee, 0xf1, 0x34, 0x66, 0x13, 0x46, 0xbb, 0x3f, 0x54, 0x6a, 0x60,
+    0xc9, 0xa7, 0x01, 0xcf, 0x0d, 0x10, 0x91, 0x6d, 0x63, 0x5f, 0x50, 0xb9, 0x59, 0xc1, 0xa4, 0xcf,
+    0xe6, 0x39, 0x34, 0x5c, 0x78, 0x31, 0xdd, 0xbe, 0xa8, 0x8e, 0x02, 0xde, 0xac, 0xbd, 0x51, 0x43,
+    0x6e, 0x84, 0x5d, 0xe6, 0x80, 0x0f, 0x19, 0xdd, 0xb7, 0xd2, 0xbc, 0x34, 0x6d, 0xa9, 0xff, 0xff,
+    0x43, 0xb2, 0xb9, 0xfc, 0xaa, 0x6b, 0xa2, 0x5a, 0xce, 0xd8, 0x98, 0x2d, 0x55, 0x23, 0x17, 0x07,
+    0xed, 0x0c, 0xff, 0x1a, 0xf1, 0x57, 0x32, 0xd5, 0x33, 0xdf, 0x42, 0x59, 0xbf, 0x7e, 0x0f, 0x2b,
+    0x02, 0xfa, 0xde, 0x09, 0x46, 0xc1, 0x8b, 0x99, 0xe4, 0xdf, 0xf9, 0x8a, 0x81, 0xb4, 0x54, 0xb0,
+    0x5f, 0xbe, 0x52, 0xb4, 0x76, 0xff, 0xb1, 0x1b, 0x76, 0x8b, 0x0e, 0xbc, 0xe1, 0x11, 0x93, 0x49,
+    0x9d, 0x0b, 0x38, 0xcd, 0x3a, 0x68, 0xc7, 0x96, 0xd5, 0x87, 0x22, 0x71, 0x8a, 0x9b, 0xa7, 0x13,
+    0xcb, 0xb2, 0x54, 0x0b, 0xec, 0x07, 0x3c, 0x45, 0x74, 0xac, 0x8c, 0x56, 0xd5, 0x41, 0x0b, 0x64,
+    0x7f, 0x85, 0x1f, 0x18, 0x23, 0xb4, 0x12, 0xb4, 0xb4, 0x23, 0x94, 0xdb, 0x50, 0xc0, 0xd2, 0x2c,
+    0xa1, 0x24, 0xb5, 0xd2, 0x62, 0x5a, 0x59, 0x2d, 0x75, 0xc9, 0x4f, 0xea, 0xe0, 0x68, 0xb4, 0xff,
+    0xf1, 0x13, 0xcc, 0xa7, 0x76, 0xbd, 0x48, 0x4b, 0xe8, 0x3f,
   };
   // Rare display lookup: one heap buffer, each candidate chunk decoded once.
   // Keep complete names private until both ID and caller capacity are validated.
@@ -282,31 +213,62 @@ inline const char* ota_target_env_name(uint32_t target_id, char* buffer, size_t
     if (tinf_uncompress_exact(raw, &produced, NAMES + OFFSETS[group],
                               OFFSETS[group + 1] - OFFSETS[group]) != TINF_OK ||
         produced != RAW_LENGTHS[group]) return nullptr;
-    const uint8_t* record = raw;
+    if (produced < 3) return nullptr;
+    const unsigned suffix_count = raw[0];
+    const size_t suffix_bytes = (size_t)raw[1] | (size_t)raw[2] << 8;
+    if (!suffix_count || suffix_bytes > produced - 3) return nullptr;
+    const uint8_t* suffixes = raw + 3;
+    const uint8_t* record = suffixes + suffix_bytes;
     const uint8_t* end = raw + produced;
+    const uint8_t* checked_suffix = suffixes;
+    for (unsigned n = 0; n < suffix_count; n++) {
+      while (checked_suffix < record && *checked_suffix) checked_suffix++;
+      if (checked_suffix == record) return nullptr;
+      checked_suffix++;
+    }
+    if (checked_suffix != record) return nullptr;
     size_t previous_length = 0;
-    for (unsigned row = FIRSTS[group]; row < FIRSTS[group + 1]; row++) {
+    unsigned row = FIRSTS[group];
+    while (row < FIRSTS[group + 1]) {
       if (record == end) return nullptr;
-      size_t length = *record++;
-      if (length > previous_length || length >= sizeof(name)) return nullptr;
+      size_t base_length = *record++;
+      if (base_length > previous_length || base_length >= sizeof(name)) return nullptr;
       while (record < end && *record) {
-        if (length + 1 >= sizeof(name)) return nullptr;
-        name[length++] = (char)*record++;
+        if (base_length + 1 >= sizeof(name)) return nullptr;
+        name[base_length++] = (char)*record++;
       }
       if (record == end) return nullptr;
       record++;
-      name[length] = 0;
-      previous_length = length;
-      if (FINGERPRINTS[row] != fingerprint) continue;
-      uint8_t hash[4];
-      mesh::Utils::sha256(hash, sizeof(hash), (const uint8_t*)name, length);
-      const uint32_t id = (uint32_t)hash[0] | (uint32_t)hash[1] << 8 |
-                          (uint32_t)hash[2] << 16 | (uint32_t)hash[3] << 24;
-      if (id != target_id) continue;
-      if (length >= capacity) return nullptr;
-      memcpy(buffer, name, length + 1);
-      return buffer;
+      previous_length = base_length;
+      if (record == end) return nullptr;
+      const unsigned aliases = *record++;
+      if (!aliases || aliases > FIRSTS[group + 1] - row || aliases > (size_t)(end - record)) return nullptr;
+      for (unsigned alias = 0; alias < aliases; alias++, row++) {
+        const unsigned suffix_index = *record++;
+        if (suffix_index >= suffix_count) return nullptr;
+        if (FINGERPRINTS[row] != fingerprint) continue;
+        const uint8_t* suffix = suffixes;
+        for (unsigned n = 0; n < suffix_index; n++) {
+          while (*suffix) suffix++;
+          suffix++;
+        }
+        size_t length = base_length;
+        while (*suffix) {
+          if (length + 1 >= sizeof(name)) return nullptr;
+          name[length++] = (char)*suffix++;
+        }
+        name[length] = 0;
+        uint8_t hash[4];
+        mesh::Utils::sha256(hash, sizeof(hash), (const uint8_t*)name, length);
+        const uint32_t id = (uint32_t)hash[0] | (uint32_t)hash[1] << 8 |
+                            (uint32_t)hash[2] << 16 | (uint32_t)hash[3] << 24;
+        if (id != target_id) continue;
+        if (length >= capacity) return nullptr;
+        memcpy(buffer, name, length + 1);
+        return buffer;
+      }
     }
+    if (record != end) return nullptr;
   }
   return nullptr;
 #else

src/helpers/ui/DisplayPowerSettings.cpp

@@ -4,8 +4,9 @@
 
 namespace mesh { namespace ui {
 namespace {
-FILESYSTEM* settings_fs = nullptr;
 bool pairing_available = false;
+#ifdef MESHCORE_HAS_REAL_DISPLAY
+FILESYSTEM* settings_fs = nullptr;
 const char* const path = "/display_prefs";
 const char* const backup = "/display_prefs.bak";
 const char* const temporary = "/display_prefs.tmp";
@@ -78,15 +79,21 @@ bool savePrefs(const DisplayPowerPrefs& prefs) {
   settings_fs->remove(backup);
   return true;
 }
+#endif  // MESHCORE_HAS_REAL_DISPLAY
 }
 
 bool loadDisplayPowerSettings(FILESYSTEM* fs, bool pairing_supported, bool wake_on_boot) {
+#ifdef MESHCORE_HAS_REAL_DISPLAY
   settings_fs = fs;
+#else
+  (void)fs;
+#endif
   pairing_available = pairing_supported;
   DisplayPowerPrefs prefs;
   prefs.wake_on_boot = wake_on_boot;
   if (pairing_supported) prefs.battery.mode = prefs.usb.mode = DisplayMode::ButtonPairing;
   displayPowerPrefs() = prefs;
+#ifdef MESHCORE_HAS_REAL_DISPLAY
   if (!fs) return false;
   bool loaded = readPrefs(path, prefs);
   if (!loaded && readPrefs(backup, prefs)) {
@@ -101,6 +108,11 @@ bool loadDisplayPowerSettings(FILESYSTEM* fs, bool pairing_supported, bool wake_
   }
   displayPowerPrefs() = prefs;
   return true;
+#else
+  // Headless commands already report unsupported. Preserve runtime defaults
+  // without retaining or touching a display-only persistent store.
+  return false;
+#endif
 }
 bool displayPairingSupported() { return pairing_available; }
 
@@ -111,11 +123,29 @@ void migrateLegacyDisplayTimeout(uint16_t seconds) {
   if (seconds) prefs.battery.seconds = prefs.usb.seconds = seconds;
   // Keep the old behavior in memory even if flash is temporarily unavailable.
   displayPowerPrefs() = prefs;
+#ifdef MESHCORE_HAS_REAL_DISPLAY
   savePrefs(prefs);
+#endif
 }
 
 bool handleDisplayPowerCommand(const char* command, char* reply, size_t reply_size,
                                bool inbox_supported) {
+#ifndef MESHCORE_HAS_REAL_DISPLAY
+  (void)inbox_supported;
+  if ((command[0] != 'g' && command[0] != 's')
+      || strncmp(command + 1, "et display.", 11) != 0) return false;
+  const char* key = command + 12;
+  const bool usb = strncmp(key, "usb.", 4) == 0;
+  if (usb) key += 4;
+  size_t length;
+  if (strncmp(key, "mode", 4) == 0) length = 4;
+  else if (strncmp(key, "timeout", 7) == 0) length = 7;
+  else if (!usb && strncmp(key, "inbox", 5) == 0) length = 5;
+  else return false;
+  if (key[length] && key[length] != ' ') return false;
+  snprintf(reply, reply_size, "Error: display unsupported");
+  return true;
+#else
   const bool get = strncmp(command, "get ", 4) == 0;
   const bool set = strncmp(command, "set ", 4) == 0;
   if (!get && !set) return false;
@@ -129,11 +159,6 @@ bool handleDisplayPowerCommand(const char* command, char* reply, size_t reply_si
     }
   }
   if (index < 0) return false;
-#ifndef MESHCORE_HAS_REAL_DISPLAY
-  (void)inbox_supported;
-  snprintf(reply, reply_size, "Error: display unsupported");
-  return true;
-#else
   auto candidate = displayPowerPrefs();
   auto& profile = index < 2 ? candidate.battery : candidate.usb;
   const char* value = key + strlen(keys[index]);

src/helpers/ui/DisplayPowerSettings.h

@@ -8,6 +8,7 @@ namespace mesh { namespace ui {
 // Separate, versioned file: existing node and MQTT preference layouts stay
 // readable by older firmware. Returns true when a saved profile was loaded.
 // Companion startup enables a timed boot screen without changing saved modes.
+// Headless builds initialize runtime defaults and never access this file.
 bool loadDisplayPowerSettings(FILESYSTEM* fs, bool pairing_supported,
                               bool wake_on_boot = false);
 bool handleDisplayPowerCommand(const char* command, char* reply, size_t reply_size,

test/fixtures/regulator_cli_stub.h

@@ -8,3 +8,10 @@
 namespace mesh { namespace power {
 inline bool handleRegulatorCommand(const char*, char*, size_t) { return false; }
 }}
+
+// LED persistence has its own executable coverage in test_led_settings.py.
+// These command-dispatch fixtures likewise leave unrelated LED commands to
+// that subsystem instead of requiring a board/filesystem implementation.
+namespace mesh { namespace leds {
+inline bool handleCommand(const char*, char*, size_t) { return false; }
+}}

test/test_common_cli_retry_tail.py

@@ -0,0 +1,149 @@
+"""Keep canonical retry preference bytes while batching their atomic write."""
+from pathlib import Path
+import shutil
+import subprocess
+import tempfile
+import unittest
+
+ROOT = Path(__file__).resolve().parents[1]
+
+PREFIX = r'''
+#include <cstdint>
+#include <cstddef>
+#include <cassert>
+#include <cstdio>
+#include <cstring>
+#include <vector>
+#include <algorithm>
+#include <limits>
+#define DEFAULT_POWERSAVING_ENABLED 0
+#define DEFAULT_ADVERT_LOC_POLICY 0
+#ifndef FLOOD_RETRY_PREFIX_SLOTS
+#define FLOOD_RETRY_PREFIX_SLOTS 8
+#define FLOOD_RETRY_PREFIX_LEN 3
+#define FLOOD_RETRY_BRIDGE_BUCKETS 6
+#define FLOOD_RETRY_BUCKET_PREFIXES 17
+#define FLOOD_RETRY_IGNORE_PREFIXES 8
+#endif
+namespace mesh { namespace bridge {constexpr uint8_t ESPNOW_FORMAT_WRAPPED=0;} struct RepeaterRadioTiming {static constexpr uint8_t DEFAULT_RX_WATCHDOG_ENABLED=1;}; }
+class ConfigSerializer {public:virtual void structure() {} uint8_t base_padding[3] = {};};
+'''
+
+WRITER = r'''
+struct Writer {
+ std::vector<uint8_t> bytes;size_t budget=std::numeric_limits<size_t>::max();bool okay=true;
+ __attribute__((noinline)) size_t write(const uint8_t* p,size_t n) {
+  if(!okay)return 0;const size_t used=std::min(n,budget);bytes.insert(bytes.end(),p,p+used);budget-=used;
+  if(used!=n)okay=false;return used;
+ }
+ bool commit()const{return okay;}
+};
+'''
+
+REFERENCE_WRITES = r'''
+    writer.write((uint8_t *)&prefs->retry_preset, sizeof(prefs->retry_preset));                     // 295
+    writer.write((uint8_t *)&prefs->direct_retry_attempts, sizeof(prefs->direct_retry_attempts));   // 296
+    writer.write((uint8_t *)&prefs->direct_retry_base_ms, sizeof(prefs->direct_retry_base_ms));     // 297
+    writer.write((uint8_t *)&prefs->direct_retry_step_ms, sizeof(prefs->direct_retry_step_ms));     // 299
+    writer.write((uint8_t *)&prefs->direct_retry_snr_margin_x4, sizeof(prefs->direct_retry_snr_margin_x4)); // 301
+    writer.write((uint8_t *)&prefs->direct_retry_cr4_snr_x4, sizeof(prefs->direct_retry_cr4_snr_x4)); // 303
+    writer.write((uint8_t *)&prefs->direct_retry_cr5_snr_x4, sizeof(prefs->direct_retry_cr5_snr_x4)); // 304
+    writer.write((uint8_t *)&prefs->direct_retry_cr7_snr_x4, sizeof(prefs->direct_retry_cr7_snr_x4)); // 305
+    writer.write((uint8_t *)&prefs->direct_retry_cr8_snr_x4, sizeof(prefs->direct_retry_cr8_snr_x4)); // 306
+    writer.write((uint8_t *)&prefs->direct_retry_enabled, sizeof(prefs->direct_retry_enabled));       // 307
+    writer.write((uint8_t *)&prefs->direct_retry_cr_enabled, sizeof(prefs->direct_retry_cr_enabled)); // 308
+    writer.write((uint8_t *)&prefs->direct_retry_prefs_magic, sizeof(prefs->direct_retry_prefs_magic)); // 309
+    writer.write((uint8_t *)&prefs->flood_retry_attempts, sizeof(prefs->flood_retry_attempts));       // 311
+    writer.write((uint8_t *)&prefs->flood_retry_max_path, sizeof(prefs->flood_retry_max_path));       // 312
+    writer.write((uint8_t *)&prefs->flood_retry_prefixes[0][0], sizeof(prefs->flood_retry_prefixes)); // 313
+    writer.write((uint8_t *)&prefs->flood_retry_bridge_enabled, sizeof(prefs->flood_retry_bridge_enabled));
+    writer.write((uint8_t *)&prefs->flood_retry_bridge_buckets[0][0][0], sizeof(prefs->flood_retry_bridge_buckets));
+    writer.write((uint8_t *)&prefs->flood_retry_ignore_prefixes[0][0], sizeof(prefs->flood_retry_ignore_prefixes));
+    writer.write((uint8_t *)&prefs->flood_retry_advert_enabled, sizeof(prefs->flood_retry_advert_enabled));
+    writer.write((uint8_t *)&prefs->battery_alert_enabled, sizeof(prefs->battery_alert_enabled));
+    writer.write((uint8_t *)&prefs->battery_alert_low_percent, sizeof(prefs->battery_alert_low_percent));
+    writer.write((uint8_t *)&prefs->battery_alert_critical_percent, sizeof(prefs->battery_alert_critical_percent));
+    writer.write((uint8_t *)&prefs->direct_retry_recent_enabled, sizeof(prefs->direct_retry_recent_enabled));
+    writer.write((uint8_t *)&prefs->flood_channel_data_enabled, sizeof(prefs->flood_channel_data_enabled));
+    writer.write((uint8_t *)&prefs->legacy_flood_channel_block_max_hops,
+               sizeof(prefs->legacy_flood_channel_block_max_hops));
+    writer.write((uint8_t *)&prefs->flood_channel_data_max_hops, sizeof(prefs->flood_channel_data_max_hops));
+    writer.write((uint8_t *)&prefs->telemetry_access, sizeof(prefs->telemetry_access));             // 674
+'''
+
+CHECKS = r'''
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Winvalid-offsetof"
+int main(){
+ NodePrefs prefs;uint32_t state=1;size_t length=0;
+ for(unsigned seed=0;seed<32;seed++) {
+  Writer expected;
+  auto* first=reinterpret_cast<uint8_t*>(&prefs)+__builtin_offsetof(NodePrefs,retry_preset);
+  const size_t size=__builtin_offsetof(NodePrefs,telemetry_access)+sizeof(prefs.telemetry_access)-__builtin_offsetof(NodePrefs,retry_preset);
+  for(size_t i=0;i<size;i++){state=state*1664525u+1013904223u;first[i]=uint8_t(state>>24);}
+  reference(expected,&prefs);length=expected.bytes.size();assert(expected.commit());
+  Writer actual;writeCommonRetryPrefs(actual,&prefs);assert(actual.commit()&&actual.bytes==expected.bytes);
+  for(size_t limit=0;limit<=length;limit++){
+   Writer a,b;a.budget=b.budget=limit;reference(a,&prefs);writeCommonRetryPrefs(b,&prefs);
+   assert(a.bytes==b.bytes&&a.commit()==b.commit());assert(a.commit()==(limit==length));
+  }
+ }
+ printf("PASS: exact canonical %zu-byte tail, 32 arbitrary states, every cumulative short-write boundary\n",length);
+}
+#pragma GCC diagnostic pop
+'''
+
+def fixture(padded=False):
+    header = (ROOT / "src/helpers/CommonCLI.h").read_text()
+    begin = header.index("class NodePrefs : public ConfigSerializer")
+    begin = header.index("public:", begin)
+    end = header.index("\nprivate:", begin)
+    declarations = "class NodePrefs : public ConfigSerializer {\n" + header[begin:end] + "\n};\n"
+    if padded:
+        original = "  uint8_t direct_retry_attempts = 0;"
+        assert original in declarations
+        declarations = declarations.replace(original, original + "\n  uint8_t layout_break = 0;", 1)
+    source = (ROOT / "src/helpers/CommonCLI.cpp").read_text()
+    begin = source.index("// This canonical retry/flood span contains no padding.")
+    end = source.index("void CommonCLI::savePrefs(FILESYSTEM* fs", begin)
+    helper = source[begin:end]
+    return (PREFIX + declarations + helper + WRITER
+            + "void reference(Writer& writer, NodePrefs* prefs) {\n"
+            + REFERENCE_WRITES + "}\n" + CHECKS)
+
+
+class CommonRetryTailTests(unittest.TestCase):
+    def compile(self, work, definitions=(), padded=False):
+        compiler = shutil.which("g++") or shutil.which("clang++")
+        self.assertIsNotNone(compiler, "native C++ compiler required")
+        cpp, executable = work / "tail.cpp", work / "tail"
+        cpp.write_text(fixture(padded))
+        result = subprocess.run([
+            compiler, "-std=c++17", "-O1", "-Wall", "-Wextra", "-Werror",
+            "-Wno-misleading-indentation", "-fsanitize=address,undefined",
+            "-fno-sanitize-recover=all", "-fno-pie", "-no-pie", *definitions,
+            str(cpp), "-o", str(executable),
+        ], capture_output=True, text=True, timeout=60)
+        return result, executable
+
+    def test_actual_members_match_old_bytes_and_every_short_write_boundary(self):
+        for definitions in ((), ("-DENABLE_OTA=1", "-DRAK_4631=1"), (
+                "-DFLOOD_RETRY_PREFIX_SLOTS=3", "-DFLOOD_RETRY_PREFIX_LEN=5",
+                "-DFLOOD_RETRY_BRIDGE_BUCKETS=2", "-DFLOOD_RETRY_BUCKET_PREFIXES=7",
+                "-DFLOOD_RETRY_IGNORE_PREFIXES=4")):
+            with self.subTest(definitions=definitions), tempfile.TemporaryDirectory() as directory:
+                result, executable = self.compile(Path(directory), definitions)
+                self.assertEqual(result.returncode, 0, result.stdout + result.stderr)
+                checked = subprocess.run([str(executable)], capture_output=True, text=True, timeout=30)
+                self.assertEqual(checked.returncode, 0, checked.stdout + checked.stderr)
+                self.assertIn("exact canonical", checked.stdout)
+
+    def test_changed_member_layout_refuses_to_compile(self):
+        with tempfile.TemporaryDirectory() as directory:
+            result, _ = self.compile(Path(directory), padded=True)
+            self.assertNotEqual(result.returncode, 0)
+            self.assertIn("retry tail has padding or changed order", result.stderr)
+
+
+if __name__ == "__main__":
+    unittest.main()

test/test_common_prefs_uncertain_reply.py

@@ -58,7 +58,7 @@ def actual_harness():
         'SERIALIZER': 'template<typename Writer>\n' + extract_braced(
             source, 'static bool writeCommonPrefsImage('),
         'STORE': extract_braced(source, 'class CommonPrefsFileStore'),
-        'METHODS': methods,
+        'METHODS': ("\n#include <stddef.h>\ntemplate<typename Writer>\n" + extract_braced(source, "static void writeCommonRetryPrefs(") + "\n" + methods),
         'SET_DEBUG': extract_braced(source, 'if (strncmp(config, "usb.debug", 9)'),
         'SET_MASTER': extract_braced(source, 'if (strncmp(config, "usb.logging", 11)'),
         'GET_DEBUG': extract_braced(source, 'if (strcmp(config, "usb.debug") == 0)'),

test/test_common_radio_persistence.py

@@ -155,7 +155,7 @@ class CommonRadioPersistenceTest(unittest.TestCase):
             'bool CommonCLI::savePrimaryRadioParams('))
         serializer = 'template<typename Writer>\n' + extract_braced(source, 'static bool writeCommonPrefsImage(')
         tail = extract_braced(source, 'if (file.available() >= (int)sizeof(_prefs->bridge_format))')
-        code = HARNESS.replace('@FIELDS@',fields).replace('@METHODS@',methods)
+        code = HARNESS.replace('@FIELDS@',fields).replace('@METHODS@',("\n#include <stddef.h>\ntemplate<typename Writer>\n" + extract_braced(source, "static void writeCommonRetryPrefs(") + "\n" + methods))
         code = code.replace('@SERIALIZER@',serializer).replace('@TAIL@',tail)
         sanitizer_flags = [] if os.name == 'nt' else [
             '-fsanitize=address,undefined', '-fno-sanitize-recover=all',

test/test_common_usb_debug.py

@@ -318,7 +318,7 @@ class CommonUsbDebugTest(unittest.TestCase):
             'SERIALIZER': 'template<typename Writer>\n' + extract_braced(
                 source, 'static bool writeCommonPrefsImage('),
             'STORE': extract_braced(source, 'class CommonPrefsFileStore'),
-            'METHODS': methods,
+            'METHODS': ("\n#include <stddef.h>\ntemplate<typename Writer>\n" + extract_braced(source, "static void writeCommonRetryPrefs(") + "\n" + methods),
             'DYNAMIC': extract_braced(header, 'class BridgePrefs :'),
             'SET_DEBUG': extract_braced(source, 'if (strncmp(config, "usb.debug", 9)'),
             'SET_MASTER': extract_braced(source, 'if (strncmp(config, "usb.logging", 11)'),

test/test_display_power.py

@@ -28,14 +28,17 @@ struct File {
 struct FakeFS {
   std::map<std::string, std::vector<uint8_t>> files;
   bool fail_write = false, fail_publish = false;
-  bool exists(const char* name) { return files.count(name); }
-  bool remove(const char* name) { files.erase(name); return true; }
+  unsigned calls = 0;
+  bool exists(const char* name) { ++calls; return files.count(name); }
+  bool remove(const char* name) { ++calls; files.erase(name); return true; }
   bool rename(const char* from, const char* to) {
+    ++calls;
     if (fail_publish && std::string(from) == "/display_prefs.tmp") return false;
     if (!exists(from) || exists(to)) return false;
     files[to] = files[from]; files.erase(from); return true;
   }
   File open(const char* name, const char* mode, bool = false) {
+    ++calls;
     if (*mode == 'w') files[name].clear();
     if (!exists(name)) return {};
     return File{this, name};
@@ -326,6 +329,61 @@ int main() {
 '''
 
 
+HEADLESS_TEST = r'''
+#include <cassert>
+#include <helpers/ui/DisplayPowerSettings.h>
+using namespace mesh::ui;
+int main() {
+  FakeFS fs;
+  fs.files["/display_prefs"] = {'D', 'P', 2, 5, 42, 0, 1, 57, 0, 2, 0, 0};
+  fs.files["/display_prefs.bak"] = {'b', 'a', 'c', 'k', 'u', 'p'};
+  fs.files["/display_prefs.tmp"] = {'t', 'e', 'm', 'p'};
+  const auto original = fs.files;
+  for (bool pairing : {false, true}) for (bool wake : {false, true}) {
+    displayPowerPrefs().battery = {DisplayMode::Off, 123};
+    displayPowerPrefs().usb = {DisplayMode::On, 456};
+    displayPowerPrefs().inbox = DisplayInboxMode::Unread;
+    assert(!loadDisplayPowerSettings(&fs, pairing, wake));
+    const auto& prefs = displayPowerPrefs();
+    const auto mode = pairing ? DisplayMode::ButtonPairing : DisplayMode::Button;
+    assert(prefs.battery.mode == mode && prefs.usb.mode == mode);
+    assert(prefs.battery.seconds == 15 && prefs.usb.seconds == 15);
+    assert(prefs.inbox == DisplayInboxMode::History && prefs.wake_on_boot == wake);
+    assert(displayPairingSupported() == pairing);
+    for (const char* key : {"display.mode", "display.timeout", "display.usb.mode",
+                            "display.usb.timeout", "display.inbox"}) {
+      for (const char* prefix : {"get ", "set "}) for (const char* suffix : {"", " off", " typo"}) {
+        char reply[160] = {};
+        const std::string text = std::string(prefix) + key + suffix;
+        assert(handleDisplayPowerCommand(text.c_str(), reply, sizeof(reply), true));
+        assert(std::string(reply) == "Error: display unsupported");
+      }
+    }
+    char reply[32] = "untouched";
+    assert(!handleDisplayPowerCommand("get display.model", reply, sizeof(reply)));
+    assert(std::string(reply) == "untouched");
+    char bounded[3] = {'x', 'y', 'z'};
+    assert(handleDisplayPowerCommand("get display.mode", bounded, 1));
+    assert(bounded[0] == 0 && bounded[1] == 'y' && bounded[2] == 'z');
+    migrateLegacyDisplayTimeout(0);
+    assert(displayPowerPrefs().battery.mode == DisplayMode::On);
+    assert(displayPowerPrefs().usb.mode == DisplayMode::On);
+    migrateLegacyDisplayTimeout(42);
+    assert(displayPowerPrefs().battery.mode == DisplayMode::Automatic);
+    assert(displayPowerPrefs().usb.mode == DisplayMode::Automatic);
+    assert(displayPowerPrefs().battery.seconds == 42 && displayPowerPrefs().usb.seconds == 42);
+    assert(displayPowerPrefs().wake_on_boot == wake && displayPairingSupported() == pairing);
+    migrateLegacyDisplayTimeout(3601);
+    assert(displayPowerPrefs().battery.seconds == 42 && displayPowerPrefs().usb.seconds == 42);
+    assert(fs.calls == 0 && fs.files == original);
+    assert(!loadDisplayPowerSettings(nullptr, pairing, wake));
+    assert(displayPowerPrefs().battery.mode == mode && displayPowerPrefs().wake_on_boot == wake);
+    assert(fs.calls == 0 && fs.files == original);
+  }
+}
+'''
+
+
 class DisplayPowerTest(unittest.TestCase):
     def test_companion_boot_wake_is_transport_and_layout_independent(self):
         mesh = (ROOT / "examples/companion_radio/MyMesh.cpp").read_text()
@@ -344,6 +402,27 @@ class DisplayPowerTest(unittest.TestCase):
         infrastructure = (ROOT / "src/helpers/CommonCLI.cpp").read_text()
         self.assertIn("loadDisplayPowerSettings(fs, false);", infrastructure)
 
+    def test_headless_defaults_commands_and_legacy_migration_do_not_touch_files(self):
+        compiler = shutil.which("g++") or shutil.which("clang++")
+        self.assertIsNotNone(compiler, "host C++ compiler required")
+        with tempfile.TemporaryDirectory(prefix="mesh-headless-display-test-") as name:
+            work = Path(name)
+            (work / "helpers").mkdir()
+            (work / "helpers/IdentityStore.h").write_text(FS_STUB)
+            (work / "test.cpp").write_text(HEADLESS_TEST)
+            for label, definitions in (("absent", ()), ("null", ("-DDISPLAY_CLASS=NullDisplayDriver",))):
+                with self.subTest(display=label):
+                    executable = work / (label + ".exe")
+                    result = subprocess.run([
+                        compiler, "-std=c++17", "-Wall", "-Wextra", "-Werror",
+                        *definitions, "-I" + str(work), "-I" + str(ROOT / "src"),
+                        str(work / "test.cpp"), str(ROOT / "src/helpers/ui/DisplayPowerSettings.cpp"),
+                        "-o", str(executable),
+                    ], capture_output=True, text=True, timeout=60)
+                    self.assertEqual(result.returncode, 0, result.stdout + result.stderr)
+                    result = subprocess.run([str(executable)], capture_output=True, text=True, timeout=10)
+                    self.assertEqual(result.returncode, 0, result.stdout + result.stderr)
+
     def test_policy_and_persistent_commands(self):
         compiler = shutil.which("g++") or shutil.which("clang++")
         self.assertIsNotNone(compiler, "host C++ compiler required")

test/test_ota_channel_persistence.py

@@ -238,7 +238,7 @@ def persistence_harness():
         "SERIALIZER": "template<typename Writer>\n" + extract_braced(
             source, "static bool writeCommonPrefsImage("),
         "STORE": extract_braced(source, "class CommonPrefsFileStore"),
-        "METHODS": methods,
+        "METHODS": ("\n#include <stddef.h>\ntemplate<typename Writer>\n" + extract_braced(source, "static void writeCommonRetryPrefs(") + "\n" + methods),
         "DYNAMIC": "", "SET_DEBUG": "", "SET_MASTER": "",
         "GET_DEBUG": "", "GET_MASTER": "",
     }

test/test_ota_target_names.py

@@ -124,7 +124,7 @@ class OtaTargetNameTest(unittest.TestCase):
 
     def test_rak_full_lookup_fails_closed_without_heap_and_keeps_every_name(self):
         flags = ["-DOTA_TARGET_NAME_FRONT_CODED=1", "-DOTA_RAK15002_SD_STORE=1", "-DCOMPANION_RADIO_FULL=1"]
-        data, offsets, lengths, firsts = gen_targets.compressed_name_chunks(
+        data, offsets, lengths, firsts = gen_targets.grouped_name_chunks(
             self.rows, gen_targets.RAK_FULL_NAME_DECODE_CHUNK_SIZE)
         ordinary = gen_targets.compressed_name_chunks(self.rows)
         self.assertGreater(len(ordinary[0]) - len(data), 1500)
@@ -134,6 +134,76 @@ class OtaTargetNameTest(unittest.TestCase):
         self.assertEqual(self.compile_and_lookup(flags + ["-DOTA_TEST_MALLOC_FAIL=1"],
                                                 [self.rows[0][0], 0]), ["?", "?"])
 
+    def grouped_roundtrip(self, rows, chunk_size=4096):
+        data, offsets, lengths, firsts = gen_targets.grouped_name_chunks(rows, chunk_size)
+        names = []
+        for group, length in enumerate(lengths):
+            raw = zlib.decompress(data[offsets[group]:offsets[group + 1]], -15)
+            self.assertEqual(len(raw), length)
+            self.assertLessEqual(length, chunk_size)
+            count, dictionary_bytes = raw[0], int.from_bytes(raw[1:3], "little")
+            dictionary_end = 3 + dictionary_bytes
+            dictionary = raw[3:dictionary_end].split(b"\0")
+            self.assertEqual(dictionary[-1], b"")
+            self.assertEqual(len(dictionary) - 1, count)
+            position, previous, row = dictionary_end, b"", firsts[group]
+            while row < firsts[group + 1]:
+                prefix = raw[position]
+                self.assertLessEqual(prefix, len(previous))
+                end = raw.index(0, position + 1)
+                previous = previous[:prefix] + raw[position + 1:end]
+                aliases = raw[end + 1]
+                self.assertGreater(aliases, 0)
+                position = end + 2
+                for index in raw[position:position + aliases]:
+                    self.assertLess(index, count)
+                    names.append((previous + dictionary[index]).decode("utf-8"))
+                position += aliases; row += aliases
+            self.assertEqual(row, firsts[group + 1])
+            self.assertEqual(position, len(raw))
+        self.assertEqual(names, [name for _, name in rows])
+        return data, lengths
+
+    def test_rak_full_grouped_roles_keep_all_names_in_same_scratch_and_save_flash(self):
+        data, lengths = self.grouped_roundtrip(self.rows)
+        previous = gen_targets.compressed_name_chunks(self.rows, 4096)
+        self.assertGreater(len(previous[0]) - len(data), 1000)
+        self.assertLessEqual(max(lengths), 4096)
+        # Unusual/legacy names stay complete; larger future inventories restart
+        # board prefixes and carry a complete suffix dictionary in each chunk.
+        future = gen_targets.target_rows(
+            [f"board_{i:04d}_{role}" for i in range(700)
+             for role in ("repeater", "companion_radio_usb", "room_server")]
+            + ["legacy_without_role", "odd_BOARD_repeatr", "case_Companion_ble"])
+        _, chunks = self.grouped_roundtrip(future)
+        self.assertGreater(len(chunks), 1)
+
+    def test_grouped_decoder_rejects_bad_dictionary_prefix_count_and_role_index(self):
+        from zopfli_compress import raw_deflate_compress
+        rows = gen_targets.target_rows(["hello"])
+        header = gen_targets.generate_header(rows)
+        data, offsets, lengths, firsts = gen_targets.grouped_name_chunks(rows)
+        raw = zlib.decompress(data, -15)
+        invalid = []
+        for offset, value in ((0, 0), (1, 255), (3, 88), (4, 255), (-2, 0), (-1, 255)):
+            changed = bytearray(raw); changed[offset] = value; invalid.append(bytes(changed))
+        invalid.append(raw[:-1])
+        for changed in invalid:
+            stream = raw_deflate_compress(changed, numiterations=1000)
+            altered = re.sub(
+                r"(static const uint8_t NAMES\[\] = \{).*?(\n  \};)",
+                lambda match: match[1] + "\n    " + ", ".join(f"0x{byte:02x}" for byte in stream) + "," + match[2],
+                header, count=1, flags=re.S)
+            altered = re.sub(
+                r"(static const uint16_t OFFSETS\[\] = \{).*?(\n  \};)",
+                lambda match: match[1] + f"\n    0, {len(stream)}," + match[2], altered, count=1, flags=re.S)
+            altered = re.sub(
+                r"(static const uint16_t RAW_LENGTHS\[\] = \{).*?(\n  \};)",
+                lambda match: match[1] + f"\n    {len(changed)}," + match[2], altered, count=1, flags=re.S)
+            with self.subTest(raw=changed.hex()):
+                flags = ["-DOTA_TARGET_NAME_FRONT_CODED=1", "-DOTA_RAK15002_SD_STORE=1", "-DCOMPANION_RADIO_FULL=1"]
+                self.assertEqual(self.compile_and_lookup(flags, [rows[0][0]], altered), ["?"])
+
     def test_rak_full_fingerprint_collisions_verify_the_entire_target_id(self):
         flags = ["-DOTA_TARGET_NAME_FRONT_CODED=1", "-DOTA_RAK15002_SD_STORE=1", "-DCOMPANION_RADIO_FULL=1"]
         known = {target for target, _ in self.rows}
@@ -198,6 +268,8 @@ class OtaTargetNameTest(unittest.TestCase):
             with self.subTest(name=name):
                 with self.assertRaises(ValueError):
                     gen_targets.compressed_name_chunks([(1, name)])
+                with self.assertRaises(ValueError):
+                    gen_targets.grouped_name_chunks([(1, name)])
 
 
 if __name__ == "__main__":

test/test_peripheral_mode_prefs.py

@@ -80,7 +80,7 @@ def common_code():
         "FIELDS": fields, "CONSTANTS": constants, "HELPERS": helpers,
         "LEGACY": extract_braced(header, "struct LegacyObserverTail") + ";",
         "SERIALIZER": "template<typename Writer>\n" + extract_braced(source, "static bool writeCommonPrefsImage("),
-        "STORE": extract_braced(source, "class CommonPrefsFileStore"), "METHODS": methods,
+        "STORE": extract_braced(source, "class CommonPrefsFileStore"), "METHODS": ("\n#include <stddef.h>\ntemplate<typename Writer>\n" + extract_braced(source, "static void writeCommonRetryPrefs(") + "\n" + methods),
         "DYNAMIC": extract_braced(header, "class BridgePrefs :"),
         "SET_DEBUG": "", "SET_MASTER": "", "GET_DEBUG": "", "GET_MASTER": "",
     }.items():

test/test_repeater_trace_repeat.py

@@ -216,7 +216,7 @@ def production_harness(source, header):
         'SERIALIZER': 'template<typename Writer>\n' + extract_braced(
             source, 'static bool writeCommonPrefsImage('),
         'STORE': extract_braced(source, 'class CommonPrefsFileStore'),
-        'METHODS': methods,
+        'METHODS': ("\n#include <stddef.h>\ntemplate<typename Writer>\n" + extract_braced(source, "static void writeCommonRetryPrefs(") + "\n" + methods),
         'DYNAMIC': extract_braced(header, 'class RepeatPrefs :'),
         'SET_DEBUG': extract_braced(setter, branch), 'SET_MASTER': '',
         'GET_DEBUG': extract_braced(getter, branch), 'GET_MASTER': '',

tools/mota/gen_targets.py

@@ -15,6 +15,9 @@ from __future__ import annotations
 
 import json
 import os
+import re
+from collections import Counter
+from itertools import groupby
 import subprocess
 import sys
 from functools import lru_cache
@@ -126,11 +129,76 @@ def _compressed_name_chunks(rows, max_chunk_size):
     return bytes(data), tuple(offsets), tuple(len(raw) for raw in raw_chunks), tuple(firsts)
 
 
+def grouped_name_chunks(rows, max_chunk_size=RAK_FULL_NAME_DECODE_CHUNK_SIZE):
+    """Share complete role suffixes and contiguous board prefixes, retaining order.
+
+    Each independent chunk contains its own bounded suffix dictionary followed
+    by board groups. One record reconstructs a board base, then lists every role
+    index for that contiguous run. IDs/names remain byte-for-byte unchanged.
+    """
+    return _grouped_name_chunks(tuple(rows), max_chunk_size)
+
+
+@lru_cache(maxsize=8)
+def _grouped_name_chunks(rows, max_chunk_size):
+    sys.path.insert(0, str(ROOT / "scripts"))
+    from zopfli_compress import MAXIMUM_ITERATIONS, raw_deflate_compress
+
+    if not rows or max_chunk_size < 1024 or max_chunk_size > 65535:
+        raise ValueError("OTA grouped-name chunk size or inventory is invalid")
+    parts = []
+    for _, name in rows:
+        encoded = name.encode("utf-8")
+        if b"\0" in encoded or len(encoded) > 255:
+            raise ValueError(f"OTA target name is not encodable: {name!r}")
+        role = re.search(r"_(?:companion(?:_radio)?|comp_radio|repeater|repeatr|room_server|room_svr|sensor|kiss_modem|terminal_chat|term_chat|partition_expander)(?:_|$)", name, re.I)
+        parts.append((name[:role.start()], name[role.start():]) if role else (name, ""))
+    frequency = Counter(suffix for _, suffix in parts if suffix)
+    suffixes = sorted(frequency)
+    # Leave at least half the same scratch buffer for records. Rare/future
+    # suffixes can stay in the board base without losing or renaming a target.
+    while len(suffixes) > 254 or 1 + sum(len(s.encode("utf-8")) + 1 for s in suffixes) > max_chunk_size // 2:
+        suffixes.remove(min(suffixes, key=lambda suffix: (frequency[suffix], -len(suffix), suffix)))
+    suffixes.insert(0, "")
+    indices = {suffix: index for index, suffix in enumerate(suffixes)}
+    dictionary = b"".join(suffix.encode("utf-8") + b"\0" for suffix in suffixes)
+    header = bytes([len(suffixes)]) + len(dictionary).to_bytes(2, "little") + dictionary
+    chosen = [(base, suffix) if suffix in indices else (name, "")
+              for (_, name), (base, suffix) in zip(rows, parts)]
+    records = []
+    for base, run in groupby(chosen, key=lambda part: part[0]):
+        roles = [indices[suffix] for _, suffix in run]
+        for start in range(0, len(roles), 255):
+            records.append((base.encode("utf-8"), bytes(roles[start:start + 255])))
+    raw_chunks, firsts, row = [], [0], 0
+    current, previous = bytearray(header), b""
+    for base, roles in records:
+        prefix = 0
+        while prefix < min(len(previous), len(base)) and previous[prefix] == base[prefix]:
+            prefix += 1
+        record = bytes([prefix]) + base[prefix:] + b"\0" + bytes([len(roles)]) + roles
+        if len(current) + len(record) > max_chunk_size:
+            raw_chunks.append(bytes(current)); firsts.append(row)
+            current, previous = bytearray(header), b""
+            record = b"\0" + base + b"\0" + bytes([len(roles)]) + roles
+        if len(header) + len(record) > max_chunk_size:
+            raise ValueError("OTA board-name group exceeds its bounded chunk")
+        current.extend(record); previous = base; row += len(roles)
+    raw_chunks.append(bytes(current)); firsts.append(len(rows))
+    data, offsets = bytearray(), [0]
+    for raw in raw_chunks:
+        data.extend(raw_deflate_compress(raw, numiterations=MAXIMUM_ITERATIONS)); offsets.append(len(data))
+    if len(data) > 65535 or len(rows) > 65535:
+        raise ValueError("OTA grouped-name data exceeds uint16_t restart offsets")
+    return bytes(data), tuple(offsets), tuple(map(len, raw_chunks)), tuple(firsts)
+
+
 def generate_header(rows):
     capacity = max((len(name.encode("utf-8")) + 1 for _, name in rows), default=1)
 
-    def chunk_tables(chunk_size):
-        data, offsets, raw_lengths, firsts = compressed_name_chunks(rows, chunk_size)
+    def chunk_tables(chunk_size, grouped=False):
+        codec = grouped_name_chunks if grouped else compressed_name_chunks
+        data, offsets, raw_lengths, firsts = codec(rows, chunk_size)
         lines = [f"  enum {{ DECODE_CHUNK_BYTES = {chunk_size} }};"]
         for name, values in (("OFFSETS", offsets), ("RAW_LENGTHS", raw_lengths), ("FIRSTS", firsts)):
             lines += [f"  static const uint16_t {name}[] = {{"]
@@ -188,7 +256,7 @@ def generate_header(rows):
     ]
     out += ["    " + ", ".join(f"0x{tid & 0xff:02x}" for tid, _ in rows[i:i + 16]) + ","
             for i in range(0, len(rows), 16)]
-    out += ["  };"] + chunk_tables(RAK_FULL_NAME_DECODE_CHUNK_SIZE)
+    out += ["  };"] + chunk_tables(RAK_FULL_NAME_DECODE_CHUNK_SIZE, grouped=True)
     out += [
         "  // Rare display lookup: one heap buffer, each candidate chunk decoded once.",
         "  // Keep complete names private until both ID and caller capacity are validated.",
@@ -206,31 +274,62 @@ def generate_header(rows):
         "    if (tinf_uncompress_exact(raw, &produced, NAMES + OFFSETS[group],",
         "                              OFFSETS[group + 1] - OFFSETS[group]) != TINF_OK ||",
         "        produced != RAW_LENGTHS[group]) return nullptr;",
-        "    const uint8_t* record = raw;",
+        "    if (produced < 3) return nullptr;",
+        "    const unsigned suffix_count = raw[0];",
+        "    const size_t suffix_bytes = (size_t)raw[1] | (size_t)raw[2] << 8;",
+        "    if (!suffix_count || suffix_bytes > produced - 3) return nullptr;",
+        "    const uint8_t* suffixes = raw + 3;",
+        "    const uint8_t* record = suffixes + suffix_bytes;",
         "    const uint8_t* end = raw + produced;",
+        "    const uint8_t* checked_suffix = suffixes;",
+        "    for (unsigned n = 0; n < suffix_count; n++) {",
+        "      while (checked_suffix < record && *checked_suffix) checked_suffix++;",
+        "      if (checked_suffix == record) return nullptr;",
+        "      checked_suffix++;",
+        "    }",
+        "    if (checked_suffix != record) return nullptr;",
         "    size_t previous_length = 0;",
-        "    for (unsigned row = FIRSTS[group]; row < FIRSTS[group + 1]; row++) {",
+        "    unsigned row = FIRSTS[group];",
+        "    while (row < FIRSTS[group + 1]) {",
         "      if (record == end) return nullptr;",
-        "      size_t length = *record++;",
-        "      if (length > previous_length || length >= sizeof(name)) return nullptr;",
+        "      size_t base_length = *record++;",
+        "      if (base_length > previous_length || base_length >= sizeof(name)) return nullptr;",
         "      while (record < end && *record) {",
-        "        if (length + 1 >= sizeof(name)) return nullptr;",
-        "        name[length++] = (char)*record++;",
+        "        if (base_length + 1 >= sizeof(name)) return nullptr;",
+        "        name[base_length++] = (char)*record++;",
         "      }",
         "      if (record == end) return nullptr;",
         "      record++;",
-        "      name[length] = 0;",
-        "      previous_length = length;",
-        "      if (FINGERPRINTS[row] != fingerprint) continue;",
-        "      uint8_t hash[4];",
-        "      mesh::Utils::sha256(hash, sizeof(hash), (const uint8_t*)name, length);",
-        "      const uint32_t id = (uint32_t)hash[0] | (uint32_t)hash[1] << 8 |",
-        "                          (uint32_t)hash[2] << 16 | (uint32_t)hash[3] << 24;",
-        "      if (id != target_id) continue;",
-        "      if (length >= capacity) return nullptr;",
-        "      memcpy(buffer, name, length + 1);",
-        "      return buffer;",
+        "      previous_length = base_length;",
+        "      if (record == end) return nullptr;",
+        "      const unsigned aliases = *record++;",
+        "      if (!aliases || aliases > FIRSTS[group + 1] - row || aliases > (size_t)(end - record)) return nullptr;",
+        "      for (unsigned alias = 0; alias < aliases; alias++, row++) {",
+        "        const unsigned suffix_index = *record++;",
+        "        if (suffix_index >= suffix_count) return nullptr;",
+        "        if (FINGERPRINTS[row] != fingerprint) continue;",
+        "        const uint8_t* suffix = suffixes;",
+        "        for (unsigned n = 0; n < suffix_index; n++) {",
+        "          while (*suffix) suffix++;",
+        "          suffix++;",
+        "        }",
+        "        size_t length = base_length;",
+        "        while (*suffix) {",
+        "          if (length + 1 >= sizeof(name)) return nullptr;",
+        "          name[length++] = (char)*suffix++;",
+        "        }",
+        "        name[length] = 0;",
+        "        uint8_t hash[4];",
+        "        mesh::Utils::sha256(hash, sizeof(hash), (const uint8_t*)name, length);",
+        "        const uint32_t id = (uint32_t)hash[0] | (uint32_t)hash[1] << 8 |",
+        "                            (uint32_t)hash[2] << 16 | (uint32_t)hash[3] << 24;",
+        "        if (id != target_id) continue;",
+        "        if (length >= capacity) return nullptr;",
+        "        memcpy(buffer, name, length + 1);",
+        "        return buffer;",
+        "      }",
         "    }",
+        "    if (record != end) return nullptr;",
         "  }",
         "  return nullptr;",
         "#else",